z-vue-design 0.0.44 → 0.0.46

package/dist/ZSelect-kZEqPVr9.mjs

@@ -0,0 +1,3586 @@
+import { defineComponent as ue, computed as F, ref as ve, createVNode as C, cloneVNode as In, isVNode as xn, inject as Fe, provide as _e, onUnmounted as On, shallowRef as Y, watch as pe, watchEffect as Ce, onMounted as Ie, createTextVNode as Me, Fragment as xe, onBeforeUnmount as ke, isRef as $n, reactive as Qe, toRefs as Pn, toRaw as Bt, nextTick as wt, toRef as ge, mergeModels as En, useModel as Fn, resolveComponent as Ct, createBlock as It, openBlock as Ke, mergeProps as Dn, withCtx as xt, createElementBlock as Vn, renderList as Nn, toDisplayString as Rn } from "vue";
+import { _ as b, p as Tn, P as $, J as Mn, b as L, a as ce, c as zt, R as Lt, M as et, K as z, O as tt, Q as nt, m as Ee, S as _n, o as Ae, U as An, V as Bn, X as me, Y as Ot, Z as $t, I as zn, C as Ln, L as Hn, y as ot, $ as Ze, D as he, z as Ht, v as Wn, x as Kn, u as jn, F as Gn, a0 as Un, d as Xn, g as Yn, h as Qn, a1 as Zn, a2 as qn, a3 as Jn, n as kn, s as Pe, q as eo, r as Pt, A as to } from "./index-QQhQzbiW.mjs";
+import { B as no, i as oo, S as lo, D as ao } from "./SearchOutlined-04lkgnOZ.mjs";
+import { u as io, a as Et, C as ro, i as Ft, b as Dt, s as uo, c as so, d as co, e as fo } from "./slide-CsS-qo4J.mjs";
+import { g as po, a as mo } from "./statusUtils-CSUOMQvB.mjs";
+function Vt(e, n) {
+  const {
+    key: o
+  } = e;
+  let t;
+  return "value" in e && ({
+    value: t
+  } = e), o ?? (t !== void 0 ? t : `rc-index-key-${n}`);
+}
+function Wt(e, n) {
+  const {
+    label: o,
+    value: t,
+    options: l
+  } = e || {};
+  return {
+    label: o || (n ? "children" : "label"),
+    value: t || "value",
+    options: l || "options"
+  };
+}
+function vo(e) {
+  let {
+    fieldNames: n,
+    childrenAsData: o
+  } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  const t = [], {
+    label: l,
+    value: a,
+    options: c
+  } = Wt(n, !1);
+  function s(m, p) {
+    m.forEach((u) => {
+      const g = u[l];
+      if (p || !(c in u)) {
+        const N = u[a];
+        t.push({
+          key: Vt(u, t.length),
+          groupOption: p,
+          data: u,
+          label: g,
+          value: N
+        });
+      } else {
+        let N = g;
+        N === void 0 && o && (N = u.label), t.push({
+          key: Vt(u, t.length),
+          group: !0,
+          data: u,
+          label: N
+        }), s(u[c], !0);
+      }
+    });
+  }
+  return s(e, !1), t;
+}
+function qe(e) {
+  const n = b({}, e);
+  return "props" in n || Object.defineProperty(n, "props", {
+    get() {
+      return Tn(!1, "Return type is option instead of Option instance. Please read value directly instead of reading from `props`."), n;
+    }
+  }), n;
+}
+function go(e, n) {
+  if (!n || !n.length)
+    return null;
+  let o = !1;
+  function t(a, c) {
+    let [s, ...m] = c;
+    if (!s)
+      return [a];
+    const p = a.split(s);
+    return o = o || p.length > 1, p.reduce((u, g) => [...u, ...t(g, m)], []).filter((u) => u);
+  }
+  const l = t(e, n);
+  return o ? l : null;
+}
+var ho = function(e, n) {
+  var o = {};
+  for (var t in e) Object.prototype.hasOwnProperty.call(e, t) && n.indexOf(t) < 0 && (o[t] = e[t]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function") for (var l = 0, t = Object.getOwnPropertySymbols(e); l < t.length; l++)
+    n.indexOf(t[l]) < 0 && Object.prototype.propertyIsEnumerable.call(e, t[l]) && (o[t[l]] = e[t[l]]);
+  return o;
+};
+const bo = (e) => {
+  const n = e === !0 ? 0 : 1;
+  return {
+    bottomLeft: {
+      points: ["tl", "bl"],
+      offset: [0, 4],
+      overflow: {
+        adjustX: n,
+        adjustY: 1
+      }
+    },
+    bottomRight: {
+      points: ["tr", "br"],
+      offset: [0, 4],
+      overflow: {
+        adjustX: n,
+        adjustY: 1
+      }
+    },
+    topLeft: {
+      points: ["bl", "tl"],
+      offset: [0, -4],
+      overflow: {
+        adjustX: n,
+        adjustY: 1
+      }
+    },
+    topRight: {
+      points: ["br", "tr"],
+      offset: [0, -4],
+      overflow: {
+        adjustX: n,
+        adjustY: 1
+      }
+    }
+  };
+}, yo = ue({
+  name: "SelectTrigger",
+  inheritAttrs: !1,
+  props: {
+    dropdownAlign: Object,
+    visible: {
+      type: Boolean,
+      default: void 0
+    },
+    disabled: {
+      type: Boolean,
+      default: void 0
+    },
+    dropdownClassName: String,
+    dropdownStyle: $.object,
+    placement: String,
+    empty: {
+      type: Boolean,
+      default: void 0
+    },
+    prefixCls: String,
+    popupClassName: String,
+    animation: String,
+    transitionName: String,
+    getPopupContainer: Function,
+    dropdownRender: Function,
+    containerWidth: Number,
+    dropdownMatchSelectWidth: $.oneOfType([Number, Boolean]).def(!0),
+    popupElement: $.any,
+    direction: String,
+    getTriggerDOMNode: Function,
+    onPopupVisibleChange: Function,
+    onPopupMouseEnter: Function,
+    onPopupFocusin: Function,
+    onPopupFocusout: Function
+  },
+  setup(e, n) {
+    let {
+      slots: o,
+      attrs: t,
+      expose: l
+    } = n;
+    const a = F(() => {
+      const {
+        dropdownMatchSelectWidth: s
+      } = e;
+      return bo(s);
+    }), c = ve();
+    return l({
+      getPopupElement: () => c.value
+    }), () => {
+      const s = b(b({}, e), t), {
+        empty: m = !1
+      } = s, p = ho(s, ["empty"]), {
+        visible: u,
+        dropdownAlign: g,
+        prefixCls: N,
+        popupElement: D,
+        dropdownClassName: v,
+        dropdownStyle: h,
+        direction: y = "ltr",
+        placement: S,
+        dropdownMatchSelectWidth: V,
+        containerWidth: M,
+        dropdownRender: O,
+        animation: d,
+        transitionName: P,
+        getPopupContainer: x,
+        getTriggerDOMNode: R,
+        onPopupVisibleChange: A,
+        onPopupMouseEnter: X,
+        onPopupFocusin: W,
+        onPopupFocusout: ee
+      } = p, Q = `${N}-dropdown`;
+      let U = D;
+      O && (U = O({
+        menuNode: D,
+        props: e
+      }));
+      const I = d ? `${Q}-${d}` : P, T = b({
+        minWidth: `${M}px`
+      }, h);
+      return typeof V == "number" ? T.width = `${V}px` : V && (T.width = `${M}px`), C(Mn, L(L({}, e), {}, {
+        showAction: A ? ["click"] : [],
+        hideAction: A ? ["click"] : [],
+        popupPlacement: S || (y === "rtl" ? "bottomRight" : "bottomLeft"),
+        builtinPlacements: a.value,
+        prefixCls: Q,
+        popupTransitionName: I,
+        popupAlign: g,
+        popupVisible: u,
+        getPopupContainer: x,
+        popupClassName: ce(v, {
+          [`${Q}-empty`]: m
+        }),
+        popupStyle: T,
+        getTriggerDOMNode: R,
+        onPopupVisibleChange: A
+      }), {
+        default: o.default,
+        popup: () => C("div", {
+          ref: c,
+          onMouseenter: X,
+          onFocusin: W,
+          onFocusout: ee
+        }, [U])
+      });
+    };
+  }
+}), ye = (e, n) => {
+  let {
+    slots: o
+  } = n;
+  var t;
+  const {
+    class: l,
+    customizeIcon: a,
+    customizeIconProps: c,
+    onMousedown: s,
+    onClick: m
+  } = e;
+  let p;
+  return typeof a == "function" ? p = a(c) : p = xn(a) ? In(a) : a, C("span", {
+    class: l,
+    onMousedown: (u) => {
+      u.preventDefault(), s && s(u);
+    },
+    style: {
+      userSelect: "none",
+      WebkitUserSelect: "none"
+    },
+    unselectable: "on",
+    onClick: m,
+    "aria-hidden": !0
+  }, [p !== void 0 ? p : C("span", {
+    class: l.split(/\s+/).map((u) => `${u}-icon`)
+  }, [(t = o.default) === null || t === void 0 ? void 0 : t.call(o)])]);
+};
+ye.inheritAttrs = !1;
+ye.displayName = "TransBtn";
+ye.props = {
+  class: String,
+  customizeIcon: $.any,
+  customizeIconProps: $.any,
+  onMousedown: Function,
+  onClick: Function
+};
+const So = {
+  inputRef: $.any,
+  prefixCls: String,
+  id: String,
+  inputElement: $.VueNode,
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  autofocus: {
+    type: Boolean,
+    default: void 0
+  },
+  autocomplete: String,
+  editable: {
+    type: Boolean,
+    default: void 0
+  },
+  activeDescendantId: String,
+  value: String,
+  open: {
+    type: Boolean,
+    default: void 0
+  },
+  tabindex: $.oneOfType([$.number, $.string]),
+  /** Pass accessibility props to input */
+  attrs: $.object,
+  onKeydown: {
+    type: Function
+  },
+  onMousedown: {
+    type: Function
+  },
+  onChange: {
+    type: Function
+  },
+  onPaste: {
+    type: Function
+  },
+  onCompositionstart: {
+    type: Function
+  },
+  onCompositionend: {
+    type: Function
+  },
+  onFocus: {
+    type: Function
+  },
+  onBlur: {
+    type: Function
+  }
+}, Kt = ue({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "SelectInput",
+  inheritAttrs: !1,
+  props: So,
+  setup(e) {
+    let n = null;
+    const o = Fe("VCSelectContainerEvent");
+    return () => {
+      var t;
+      const {
+        prefixCls: l,
+        id: a,
+        inputElement: c,
+        disabled: s,
+        tabindex: m,
+        autofocus: p,
+        autocomplete: u,
+        editable: g,
+        activeDescendantId: N,
+        value: D,
+        onKeydown: v,
+        onMousedown: h,
+        onChange: y,
+        onPaste: S,
+        onCompositionstart: V,
+        onCompositionend: M,
+        onFocus: O,
+        onBlur: d,
+        open: P,
+        inputRef: x,
+        attrs: R
+      } = e;
+      let A = c || C(no, null, null);
+      const X = A.props || {}, {
+        onKeydown: W,
+        onInput: ee,
+        onFocus: Q,
+        onBlur: U,
+        onMousedown: I,
+        onCompositionstart: T,
+        onCompositionend: j,
+        style: Z
+      } = X;
+      return A = zt(A, b(b(b(b(b({
+        type: "search"
+      }, X), {
+        id: a,
+        ref: x,
+        disabled: s,
+        tabindex: m,
+        lazy: !1,
+        autocomplete: u || "off",
+        autofocus: p,
+        class: ce(`${l}-selection-search-input`, (t = A == null ? void 0 : A.props) === null || t === void 0 ? void 0 : t.class),
+        role: "combobox",
+        "aria-expanded": P,
+        "aria-haspopup": "listbox",
+        "aria-owns": `${a}_list`,
+        "aria-autocomplete": "list",
+        "aria-controls": `${a}_list`,
+        "aria-activedescendant": N
+      }), R), {
+        value: g ? D : "",
+        readonly: !g,
+        unselectable: g ? null : "on",
+        style: b(b({}, Z), {
+          opacity: g ? null : 0
+        }),
+        onKeydown: (K) => {
+          v(K), W && W(K);
+        },
+        onMousedown: (K) => {
+          h(K), I && I(K);
+        },
+        onInput: (K) => {
+          y(K), ee && ee(K);
+        },
+        onCompositionstart(K) {
+          V(K), T && T(K);
+        },
+        onCompositionend(K) {
+          M(K), j && j(K);
+        },
+        onPaste: S,
+        onFocus: function() {
+          clearTimeout(n), Q && Q(arguments.length <= 0 ? void 0 : arguments[0]), O && O(arguments.length <= 0 ? void 0 : arguments[0]), o == null || o.focus(arguments.length <= 0 ? void 0 : arguments[0]);
+        },
+        onBlur: function() {
+          for (var K = arguments.length, ne = new Array(K), _ = 0; _ < K; _++)
+            ne[_] = arguments[_];
+          n = setTimeout(() => {
+            U && U(ne[0]), d && d(ne[0]), o == null || o.blur(ne[0]);
+          }, 100);
+        }
+      }), A.type === "textarea" ? {} : {
+        type: "search"
+      }), !0, !0), A;
+    };
+  }
+}), jt = Symbol("OverflowContextProviderKey"), Je = ue({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "OverflowContextProvider",
+  inheritAttrs: !1,
+  props: {
+    value: {
+      type: Object
+    }
+  },
+  setup(e, n) {
+    let {
+      slots: o
+    } = n;
+    return _e(jt, F(() => e.value)), () => {
+      var t;
+      return (t = o.default) === null || t === void 0 ? void 0 : t.call(o);
+    };
+  }
+}), wo = () => Fe(jt, F(() => null));
+var Co = function(e, n) {
+  var o = {};
+  for (var t in e) Object.prototype.hasOwnProperty.call(e, t) && n.indexOf(t) < 0 && (o[t] = e[t]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function") for (var l = 0, t = Object.getOwnPropertySymbols(e); l < t.length; l++)
+    n.indexOf(t[l]) < 0 && Object.prototype.propertyIsEnumerable.call(e, t[l]) && (o[t[l]] = e[t[l]]);
+  return o;
+};
+const Se = void 0, Te = ue({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "Item",
+  props: {
+    prefixCls: String,
+    item: $.any,
+    renderItem: Function,
+    responsive: Boolean,
+    itemKey: {
+      type: [String, Number]
+    },
+    registerSize: Function,
+    display: Boolean,
+    order: Number,
+    component: $.any,
+    invalidate: Boolean
+  },
+  setup(e, n) {
+    let {
+      slots: o,
+      expose: t
+    } = n;
+    const l = F(() => e.responsive && !e.display), a = ve();
+    t({
+      itemNodeRef: a
+    });
+    function c(s) {
+      e.registerSize(e.itemKey, s);
+    }
+    return On(() => {
+      c(null);
+    }), () => {
+      var s;
+      const {
+        prefixCls: m,
+        invalidate: p,
+        item: u,
+        renderItem: g,
+        responsive: N,
+        registerSize: D,
+        itemKey: v,
+        display: h,
+        order: y,
+        component: S = "div"
+      } = e, V = Co(e, ["prefixCls", "invalidate", "item", "renderItem", "responsive", "registerSize", "itemKey", "display", "order", "component"]), M = (s = o.default) === null || s === void 0 ? void 0 : s.call(o), O = g && u !== Se ? g(u) : M;
+      let d;
+      p || (d = {
+        opacity: l.value ? 0 : 1,
+        height: l.value ? 0 : Se,
+        overflowY: l.value ? "hidden" : Se,
+        order: N ? y : Se,
+        pointerEvents: l.value ? "none" : Se,
+        position: l.value ? "absolute" : Se
+      });
+      const P = {};
+      return l.value && (P["aria-hidden"] = !0), C(Lt, {
+        disabled: !N,
+        onResize: (x) => {
+          let {
+            offsetWidth: R
+          } = x;
+          c(R);
+        }
+      }, {
+        default: () => C(S, L(L(L({
+          class: ce(!p && m),
+          style: d
+        }, P), V), {}, {
+          ref: a
+        }), {
+          default: () => [O]
+        })
+      });
+    };
+  }
+});
+var je = function(e, n) {
+  var o = {};
+  for (var t in e) Object.prototype.hasOwnProperty.call(e, t) && n.indexOf(t) < 0 && (o[t] = e[t]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function") for (var l = 0, t = Object.getOwnPropertySymbols(e); l < t.length; l++)
+    n.indexOf(t[l]) < 0 && Object.prototype.propertyIsEnumerable.call(e, t[l]) && (o[t[l]] = e[t[l]]);
+  return o;
+};
+const Io = ue({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "RawItem",
+  inheritAttrs: !1,
+  props: {
+    component: $.any,
+    title: $.any,
+    id: String,
+    onMouseenter: {
+      type: Function
+    },
+    onMouseleave: {
+      type: Function
+    },
+    onClick: {
+      type: Function
+    },
+    onKeydown: {
+      type: Function
+    },
+    onFocus: {
+      type: Function
+    },
+    role: String,
+    tabindex: Number
+  },
+  setup(e, n) {
+    let {
+      slots: o,
+      attrs: t
+    } = n;
+    const l = wo();
+    return () => {
+      var a;
+      if (!l.value) {
+        const {
+          component: g = "div"
+        } = e, N = je(e, ["component"]);
+        return C(g, L(L({}, N), t), {
+          default: () => [(a = o.default) === null || a === void 0 ? void 0 : a.call(o)]
+        });
+      }
+      const c = l.value, {
+        className: s
+      } = c, m = je(c, ["className"]), {
+        class: p
+      } = t, u = je(t, ["class"]);
+      return C(Je, {
+        value: null
+      }, {
+        default: () => [C(Te, L(L(L({
+          class: ce(s, p)
+        }, m), u), e), o)]
+      });
+    };
+  }
+});
+var xo = function(e, n) {
+  var o = {};
+  for (var t in e) Object.prototype.hasOwnProperty.call(e, t) && n.indexOf(t) < 0 && (o[t] = e[t]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function") for (var l = 0, t = Object.getOwnPropertySymbols(e); l < t.length; l++)
+    n.indexOf(t[l]) < 0 && Object.prototype.propertyIsEnumerable.call(e, t[l]) && (o[t[l]] = e[t[l]]);
+  return o;
+};
+const Gt = "responsive", Ut = "invalidate";
+function Oo(e) {
+  return `+ ${e.length} ...`;
+}
+const $o = () => ({
+  id: String,
+  prefixCls: String,
+  data: Array,
+  itemKey: [String, Number, Function],
+  /** Used for `responsive`. It will limit render node to avoid perf issue */
+  itemWidth: {
+    type: Number,
+    default: 10
+  },
+  renderItem: Function,
+  /** @private Do not use in your production. Render raw node that need wrap Item by developer self */
+  renderRawItem: Function,
+  maxCount: [Number, String],
+  renderRest: Function,
+  /** @private Do not use in your production. Render raw node that need wrap Item by developer self */
+  renderRawRest: Function,
+  suffix: $.any,
+  component: String,
+  itemComponent: $.any,
+  /** @private This API may be refactor since not well design */
+  onVisibleChange: Function,
+  /** When set to `full`, ssr will render full items by default and remove at client side */
+  ssr: String,
+  onMousedown: Function,
+  role: String
+}), Be = ue({
+  name: "Overflow",
+  inheritAttrs: !1,
+  props: $o(),
+  emits: ["visibleChange"],
+  setup(e, n) {
+    let {
+      attrs: o,
+      emit: t,
+      slots: l
+    } = n;
+    const a = F(() => e.ssr === "full"), c = Y(null), s = F(() => c.value || 0), m = Y(/* @__PURE__ */ new Map()), p = Y(0), u = Y(0), g = Y(0), N = Y(null), D = Y(null), v = F(() => D.value === null && a.value ? Number.MAX_SAFE_INTEGER : D.value || 0), h = Y(!1), y = F(() => `${e.prefixCls}-item`), S = F(() => Math.max(p.value, u.value)), V = F(() => !!(e.data.length && e.maxCount === Gt)), M = F(() => e.maxCount === Ut), O = F(() => V.value || typeof e.maxCount == "number" && e.data.length > e.maxCount), d = F(() => {
+      let I = e.data;
+      return V.value ? c.value === null && a.value ? I = e.data : I = e.data.slice(0, Math.min(e.data.length, s.value / e.itemWidth)) : typeof e.maxCount == "number" && (I = e.data.slice(0, e.maxCount)), I;
+    }), P = F(() => V.value ? e.data.slice(v.value + 1) : e.data.slice(d.value.length)), x = (I, T) => {
+      var j;
+      return typeof e.itemKey == "function" ? e.itemKey(I) : (j = e.itemKey && (I == null ? void 0 : I[e.itemKey])) !== null && j !== void 0 ? j : T;
+    }, R = F(() => e.renderItem || ((I) => I)), A = (I, T) => {
+      D.value = I, T || (h.value = I < e.data.length - 1, t("visibleChange", I));
+    }, X = (I, T) => {
+      c.value = T.clientWidth;
+    }, W = (I, T) => {
+      const j = new Map(m.value);
+      T === null ? j.delete(I) : j.set(I, T), m.value = j;
+    }, ee = (I, T) => {
+      p.value = u.value, u.value = T;
+    }, Q = (I, T) => {
+      g.value = T;
+    }, U = (I) => m.value.get(x(d.value[I], I));
+    return pe([s, m, u, g, () => e.itemKey, d], () => {
+      if (s.value && S.value && d.value) {
+        let I = g.value;
+        const T = d.value.length, j = T - 1;
+        if (!T) {
+          A(0), N.value = null;
+          return;
+        }
+        for (let Z = 0; Z < T; Z += 1) {
+          const K = U(Z);
+          if (K === void 0) {
+            A(Z - 1, !0);
+            break;
+          }
+          if (I += K, // Only one means `totalWidth` is the final width
+          j === 0 && I <= s.value || // Last two width will be the final width
+          Z === j - 1 && I + U(j) <= s.value) {
+            A(j), N.value = null;
+            break;
+          } else if (I + S.value > s.value) {
+            A(Z - 1), N.value = I - K - g.value + u.value;
+            break;
+          }
+        }
+        e.suffix && U(0) + g.value > s.value && (N.value = null);
+      }
+    }), () => {
+      const I = h.value && !!P.value.length, {
+        itemComponent: T,
+        renderRawItem: j,
+        renderRawRest: Z,
+        renderRest: K,
+        prefixCls: ne = "rc-overflow",
+        suffix: _,
+        component: q = "div",
+        id: oe,
+        onMousedown: ie
+      } = e, {
+        class: re,
+        style: te
+      } = o, de = xo(o, ["class", "style"]);
+      let se = {};
+      N.value !== null && V.value && (se = {
+        position: "absolute",
+        left: `${N.value}px`,
+        top: 0
+      });
+      const f = {
+        prefixCls: y.value,
+        responsive: V.value,
+        component: T,
+        invalidate: M.value
+      }, i = j ? (B, H) => {
+        const G = x(B, H);
+        return C(Je, {
+          key: G,
+          value: b(b({}, f), {
+            order: H,
+            item: B,
+            itemKey: G,
+            registerSize: W,
+            display: H <= v.value
+          })
+        }, {
+          default: () => [j(B, H)]
+        });
+      } : (B, H) => {
+        const G = x(B, H);
+        return C(Te, L(L({}, f), {}, {
+          order: H,
+          key: G,
+          item: B,
+          renderItem: R.value,
+          itemKey: G,
+          registerSize: W,
+          display: H <= v.value
+        }), null);
+      };
+      let r = () => null;
+      const E = {
+        order: I ? v.value : Number.MAX_SAFE_INTEGER,
+        className: `${y.value} ${y.value}-rest`,
+        registerSize: ee,
+        display: I
+      };
+      if (Z)
+        Z && (r = () => C(Je, {
+          value: b(b({}, f), E)
+        }, {
+          default: () => [Z(P.value)]
+        }));
+      else {
+        const B = K || Oo;
+        r = () => C(Te, L(L({}, f), E), {
+          default: () => typeof B == "function" ? B(P.value) : B
+        });
+      }
+      const w = () => {
+        var B;
+        return C(q, L({
+          id: oe,
+          class: ce(!M.value && ne, re),
+          style: te,
+          onMousedown: ie,
+          role: e.role
+        }, de), {
+          default: () => [d.value.map(i), O.value ? r() : null, _ && C(Te, L(L({}, f), {}, {
+            order: v.value,
+            class: `${y.value}-suffix`,
+            registerSize: Q,
+            display: !0,
+            style: se
+          }), {
+            default: () => _
+          }), (B = l.default) === null || B === void 0 ? void 0 : B.call(l)]
+        });
+      };
+      return C(Lt, {
+        disabled: !V.value,
+        onResize: X
+      }, {
+        default: w
+      });
+    };
+  }
+});
+Be.Item = Io;
+Be.RESPONSIVE = Gt;
+Be.INVALIDATE = Ut;
+const Po = Symbol("TreeSelectLegacyContextPropsKey");
+function lt() {
+  return Fe(Po, {});
+}
+const Eo = {
+  id: String,
+  prefixCls: String,
+  values: $.array,
+  open: {
+    type: Boolean,
+    default: void 0
+  },
+  searchValue: String,
+  inputRef: $.any,
+  placeholder: $.any,
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  mode: String,
+  showSearch: {
+    type: Boolean,
+    default: void 0
+  },
+  autofocus: {
+    type: Boolean,
+    default: void 0
+  },
+  autocomplete: String,
+  activeDescendantId: String,
+  tabindex: $.oneOfType([$.number, $.string]),
+  compositionStatus: Boolean,
+  removeIcon: $.any,
+  choiceTransitionName: String,
+  maxTagCount: $.oneOfType([$.number, $.string]),
+  maxTagTextLength: Number,
+  maxTagPlaceholder: $.any.def(() => (e) => `+ ${e.length} ...`),
+  tagRender: Function,
+  onToggleOpen: {
+    type: Function
+  },
+  onRemove: Function,
+  onInputChange: Function,
+  onInputPaste: Function,
+  onInputKeyDown: Function,
+  onInputMouseDown: Function,
+  onInputCompositionStart: Function,
+  onInputCompositionEnd: Function
+}, Nt = (e) => {
+  e.preventDefault(), e.stopPropagation();
+}, Fo = ue({
+  name: "MultipleSelectSelector",
+  inheritAttrs: !1,
+  props: Eo,
+  setup(e) {
+    const n = Y(), o = Y(0), t = Y(!1), l = lt(), a = F(() => `${e.prefixCls}-selection`), c = F(() => e.open || e.mode === "tags" ? e.searchValue : ""), s = F(() => e.mode === "tags" || e.showSearch && (e.open || t.value)), m = ve("");
+    Ce(() => {
+      m.value = c.value;
+    }), Ie(() => {
+      pe(m, () => {
+        o.value = n.value.scrollWidth;
+      }, {
+        flush: "post",
+        immediate: !0
+      });
+    });
+    function p(v, h, y, S, V) {
+      return C("span", {
+        class: ce(`${a.value}-item`, {
+          [`${a.value}-item-disabled`]: y
+        }),
+        title: typeof v == "string" || typeof v == "number" ? v.toString() : void 0
+      }, [C("span", {
+        class: `${a.value}-item-content`
+      }, [h]), S && C(ye, {
+        class: `${a.value}-item-remove`,
+        onMousedown: Nt,
+        onClick: V,
+        customizeIcon: e.removeIcon
+      }, {
+        default: () => [Me("×")]
+      })]);
+    }
+    function u(v, h, y, S, V, M) {
+      var O;
+      const d = (x) => {
+        Nt(x), e.onToggleOpen(!open);
+      };
+      let P = M;
+      return l.keyEntities && (P = ((O = l.keyEntities[v]) === null || O === void 0 ? void 0 : O.node) || {}), C("span", {
+        key: v,
+        onMousedown: d
+      }, [e.tagRender({
+        label: h,
+        value: v,
+        disabled: y,
+        closable: S,
+        onClose: V,
+        option: P
+      })]);
+    }
+    function g(v) {
+      const {
+        disabled: h,
+        label: y,
+        value: S,
+        option: V
+      } = v, M = !e.disabled && !h;
+      let O = y;
+      if (typeof e.maxTagTextLength == "number" && (typeof y == "string" || typeof y == "number")) {
+        const P = String(O);
+        P.length > e.maxTagTextLength && (O = `${P.slice(0, e.maxTagTextLength)}...`);
+      }
+      const d = (P) => {
+        var x;
+        P && P.stopPropagation(), (x = e.onRemove) === null || x === void 0 || x.call(e, v);
+      };
+      return typeof e.tagRender == "function" ? u(S, O, h, M, d, V) : p(y, O, h, M, d);
+    }
+    function N(v) {
+      const {
+        maxTagPlaceholder: h = (S) => `+ ${S.length} ...`
+      } = e, y = typeof h == "function" ? h(v) : h;
+      return p(y, y, !1);
+    }
+    const D = (v) => {
+      const h = v.target.composing;
+      m.value = v.target.value, h || e.onInputChange(v);
+    };
+    return () => {
+      const {
+        id: v,
+        prefixCls: h,
+        values: y,
+        open: S,
+        inputRef: V,
+        placeholder: M,
+        disabled: O,
+        autofocus: d,
+        autocomplete: P,
+        activeDescendantId: x,
+        tabindex: R,
+        compositionStatus: A,
+        onInputPaste: X,
+        onInputKeyDown: W,
+        onInputMouseDown: ee,
+        onInputCompositionStart: Q,
+        onInputCompositionEnd: U
+      } = e, I = C("div", {
+        class: `${a.value}-search`,
+        style: {
+          width: o.value + "px"
+        },
+        key: "input"
+      }, [C(Kt, {
+        inputRef: V,
+        open: S,
+        prefixCls: h,
+        id: v,
+        inputElement: null,
+        disabled: O,
+        autofocus: d,
+        autocomplete: P,
+        editable: s.value,
+        activeDescendantId: x,
+        value: m.value,
+        onKeydown: W,
+        onMousedown: ee,
+        onChange: D,
+        onPaste: X,
+        onCompositionstart: Q,
+        onCompositionend: U,
+        tabindex: R,
+        attrs: et(e, !0),
+        onFocus: () => t.value = !0,
+        onBlur: () => t.value = !1
+      }, null), C("span", {
+        ref: n,
+        class: `${a.value}-search-mirror`,
+        "aria-hidden": !0
+      }, [m.value, Me(" ")])]), T = C(Be, {
+        prefixCls: `${a.value}-overflow`,
+        data: y,
+        renderItem: g,
+        renderRest: N,
+        suffix: I,
+        itemKey: "key",
+        maxCount: e.maxTagCount,
+        key: "overflow"
+      }, null);
+      return C(xe, null, [T, !y.length && !c.value && !A && C("span", {
+        class: `${a.value}-placeholder`
+      }, [M])]);
+    };
+  }
+}), Do = {
+  inputElement: $.any,
+  id: String,
+  prefixCls: String,
+  values: $.array,
+  open: {
+    type: Boolean,
+    default: void 0
+  },
+  searchValue: String,
+  inputRef: $.any,
+  placeholder: $.any,
+  compositionStatus: {
+    type: Boolean,
+    default: void 0
+  },
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  mode: String,
+  showSearch: {
+    type: Boolean,
+    default: void 0
+  },
+  autofocus: {
+    type: Boolean,
+    default: void 0
+  },
+  autocomplete: String,
+  activeDescendantId: String,
+  tabindex: $.oneOfType([$.number, $.string]),
+  activeValue: String,
+  backfill: {
+    type: Boolean,
+    default: void 0
+  },
+  optionLabelRender: Function,
+  onInputChange: Function,
+  onInputPaste: Function,
+  onInputKeyDown: Function,
+  onInputMouseDown: Function,
+  onInputCompositionStart: Function,
+  onInputCompositionEnd: Function
+}, at = ue({
+  name: "SingleSelector",
+  setup(e) {
+    const n = Y(!1), o = F(() => e.mode === "combobox"), t = F(() => o.value || e.showSearch), l = F(() => {
+      let u = e.searchValue || "";
+      return o.value && e.activeValue && !n.value && (u = e.activeValue), u;
+    }), a = lt();
+    pe([o, () => e.activeValue], () => {
+      o.value && (n.value = !1);
+    }, {
+      immediate: !0
+    });
+    const c = F(() => e.mode !== "combobox" && !e.open && !e.showSearch ? !1 : !!l.value || e.compositionStatus), s = F(() => {
+      const u = e.values[0];
+      return u && (typeof u.label == "string" || typeof u.label == "number") ? u.label.toString() : void 0;
+    }), m = () => {
+      if (e.values[0])
+        return null;
+      const u = c.value ? {
+        visibility: "hidden"
+      } : void 0;
+      return C("span", {
+        class: `${e.prefixCls}-selection-placeholder`,
+        style: u
+      }, [e.placeholder]);
+    }, p = (u) => {
+      u.target.composing || (n.value = !0, e.onInputChange(u));
+    };
+    return () => {
+      var u, g, N, D;
+      const {
+        inputElement: v,
+        prefixCls: h,
+        id: y,
+        values: S,
+        inputRef: V,
+        disabled: M,
+        autofocus: O,
+        autocomplete: d,
+        activeDescendantId: P,
+        open: x,
+        tabindex: R,
+        optionLabelRender: A,
+        onInputKeyDown: X,
+        onInputMouseDown: W,
+        onInputPaste: ee,
+        onInputCompositionStart: Q,
+        onInputCompositionEnd: U
+      } = e, I = S[0];
+      let T = null;
+      if (I && a.customSlots) {
+        const j = (u = I.key) !== null && u !== void 0 ? u : I.value, Z = ((g = a.keyEntities[j]) === null || g === void 0 ? void 0 : g.node) || {};
+        T = a.customSlots[(N = Z.slots) === null || N === void 0 ? void 0 : N.title] || a.customSlots.title || I.label, typeof T == "function" && (T = T(Z));
+      } else
+        T = A && I ? A(I.option) : I == null ? void 0 : I.label;
+      return C(xe, null, [C("span", {
+        class: `${h}-selection-search`
+      }, [C(Kt, {
+        inputRef: V,
+        prefixCls: h,
+        id: y,
+        open: x,
+        inputElement: v,
+        disabled: M,
+        autofocus: O,
+        autocomplete: d,
+        editable: t.value,
+        activeDescendantId: P,
+        value: l.value,
+        onKeydown: X,
+        onMousedown: W,
+        onChange: p,
+        onPaste: ee,
+        onCompositionstart: Q,
+        onCompositionend: U,
+        tabindex: R,
+        attrs: et(e, !0)
+      }, null)]), !o.value && I && !c.value && C("span", {
+        class: `${h}-selection-item`,
+        title: s.value
+      }, [C(xe, {
+        key: (D = I.key) !== null && D !== void 0 ? D : I.value
+      }, [T])]), m()]);
+    };
+  }
+});
+at.props = Do;
+at.inheritAttrs = !1;
+function Vo(e) {
+  return ![
+    // System function button
+    z.ESC,
+    z.SHIFT,
+    z.BACKSPACE,
+    z.TAB,
+    z.WIN_KEY,
+    z.ALT,
+    z.META,
+    z.WIN_KEY_RIGHT,
+    z.CTRL,
+    z.SEMICOLON,
+    z.EQUALS,
+    z.CAPS_LOCK,
+    z.CONTEXT_MENU,
+    // F1-F12
+    z.F1,
+    z.F2,
+    z.F3,
+    z.F4,
+    z.F5,
+    z.F6,
+    z.F7,
+    z.F8,
+    z.F9,
+    z.F10,
+    z.F11,
+    z.F12
+  ].includes(e);
+}
+function Xt() {
+  let e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 250, n = null, o;
+  ke(() => {
+    clearTimeout(o);
+  });
+  function t(l) {
+    (l || n === null) && (n = l), clearTimeout(o), o = setTimeout(() => {
+      n = null;
+    }, e);
+  }
+  return [() => n, t];
+}
+const No = ue({
+  name: "Selector",
+  inheritAttrs: !1,
+  props: {
+    id: String,
+    prefixCls: String,
+    showSearch: {
+      type: Boolean,
+      default: void 0
+    },
+    open: {
+      type: Boolean,
+      default: void 0
+    },
+    /** Display in the Selector value, it's not same as `value` prop */
+    values: $.array,
+    multiple: {
+      type: Boolean,
+      default: void 0
+    },
+    mode: String,
+    searchValue: String,
+    activeValue: String,
+    inputElement: $.any,
+    autofocus: {
+      type: Boolean,
+      default: void 0
+    },
+    activeDescendantId: String,
+    tabindex: $.oneOfType([$.number, $.string]),
+    disabled: {
+      type: Boolean,
+      default: void 0
+    },
+    placeholder: $.any,
+    removeIcon: $.any,
+    // Tags
+    maxTagCount: $.oneOfType([$.number, $.string]),
+    maxTagTextLength: Number,
+    maxTagPlaceholder: $.any,
+    tagRender: Function,
+    optionLabelRender: Function,
+    /** Check if `tokenSeparators` contains `\n` or `\r\n` */
+    tokenWithEnter: {
+      type: Boolean,
+      default: void 0
+    },
+    // Motion
+    choiceTransitionName: String,
+    onToggleOpen: {
+      type: Function
+    },
+    /** `onSearch` returns go next step boolean to check if need do toggle open */
+    onSearch: Function,
+    onSearchSubmit: Function,
+    onRemove: Function,
+    onInputKeyDown: {
+      type: Function
+    },
+    /**
+     * @private get real dom for trigger align.
+     * This may be removed after React provides replacement of `findDOMNode`
+     */
+    domRef: Function
+  },
+  setup(e, n) {
+    let {
+      expose: o
+    } = n;
+    const t = tt(), l = ve(!1), [a, c] = Xt(0), s = (S) => {
+      const {
+        which: V
+      } = S;
+      (V === z.UP || V === z.DOWN) && S.preventDefault(), e.onInputKeyDown && e.onInputKeyDown(S), V === z.ENTER && e.mode === "tags" && !l.value && !e.open && e.onSearchSubmit(S.target.value), Vo(V) && e.onToggleOpen(!0);
+    }, m = () => {
+      c(!0);
+    };
+    let p = null;
+    const u = (S) => {
+      e.onSearch(S, !0, l.value) !== !1 && e.onToggleOpen(!0);
+    }, g = () => {
+      l.value = !0;
+    }, N = (S) => {
+      l.value = !1, e.mode !== "combobox" && u(S.target.value);
+    }, D = (S) => {
+      let {
+        target: {
+          value: V
+        }
+      } = S;
+      if (e.tokenWithEnter && p && /[\r\n]/.test(p)) {
+        const M = p.replace(/[\r\n]+$/, "").replace(/\r\n/g, " ").replace(/[\r\n]/g, " ");
+        V = V.replace(M, p);
+      }
+      p = null, u(V);
+    }, v = (S) => {
+      const {
+        clipboardData: V
+      } = S;
+      p = V.getData("text");
+    }, h = (S) => {
+      let {
+        target: V
+      } = S;
+      V !== t.current && (document.body.style.msTouchAction !== void 0 ? setTimeout(() => {
+        t.current.focus();
+      }) : t.current.focus());
+    }, y = (S) => {
+      const V = a();
+      S.target !== t.current && !V && S.preventDefault(), (e.mode !== "combobox" && (!e.showSearch || !V) || !e.open) && (e.open && e.onSearch("", !0, !1), e.onToggleOpen());
+    };
+    return o({
+      focus: () => {
+        t.current.focus();
+      },
+      blur: () => {
+        t.current.blur();
+      }
+    }), () => {
+      const {
+        prefixCls: S,
+        domRef: V,
+        mode: M
+      } = e, O = {
+        inputRef: t,
+        onInputKeyDown: s,
+        onInputMouseDown: m,
+        onInputChange: D,
+        onInputPaste: v,
+        compositionStatus: l.value,
+        onInputCompositionStart: g,
+        onInputCompositionEnd: N
+      }, d = M === "multiple" || M === "tags" ? C(Fo, L(L({}, e), O), null) : C(at, L(L({}, e), O), null);
+      return C("div", {
+        ref: V,
+        class: `${S}-selector`,
+        onClick: h,
+        onMousedown: y
+      }, [d]);
+    };
+  }
+});
+function Ro(e, n, o) {
+  function t(l) {
+    var a, c, s;
+    let m = l.target;
+    m.shadowRoot && l.composed && (m = l.composedPath()[0] || m);
+    const p = [(a = e[0]) === null || a === void 0 ? void 0 : a.value, (s = (c = e[1]) === null || c === void 0 ? void 0 : c.value) === null || s === void 0 ? void 0 : s.getPopupElement()];
+    n.value && p.every((u) => u && !u.contains(m) && u !== m) && o(!1);
+  }
+  Ie(() => {
+    window.addEventListener("mousedown", t);
+  }), ke(() => {
+    window.removeEventListener("mousedown", t);
+  });
+}
+function To() {
+  let e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 10;
+  const n = Y(!1);
+  let o;
+  const t = () => {
+    clearTimeout(o);
+  };
+  return Ie(() => {
+    t();
+  }), [n, (a, c) => {
+    t(), o = setTimeout(() => {
+      n.value = a, c && c();
+    }, e);
+  }, t];
+}
+const Yt = Symbol("BaseSelectContextKey");
+function Mo(e) {
+  return _e(Yt, e);
+}
+function _o() {
+  return Fe(Yt, {});
+}
+function Qt(e) {
+  if (!$n(e)) return Qe(e);
+  const n = new Proxy({}, {
+    get(o, t, l) {
+      return Reflect.get(e.value, t, l);
+    },
+    set(o, t, l) {
+      return e.value[t] = l, !0;
+    },
+    deleteProperty(o, t) {
+      return Reflect.deleteProperty(e.value, t);
+    },
+    has(o, t) {
+      return Reflect.has(e.value, t);
+    },
+    ownKeys() {
+      return Object.keys(e.value);
+    },
+    getOwnPropertyDescriptor() {
+      return {
+        enumerable: !0,
+        configurable: !0
+      };
+    }
+  });
+  return Qe(n);
+}
+var Ao = function(e, n) {
+  var o = {};
+  for (var t in e) Object.prototype.hasOwnProperty.call(e, t) && n.indexOf(t) < 0 && (o[t] = e[t]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function") for (var l = 0, t = Object.getOwnPropertySymbols(e); l < t.length; l++)
+    n.indexOf(t[l]) < 0 && Object.prototype.propertyIsEnumerable.call(e, t[l]) && (o[t[l]] = e[t[l]]);
+  return o;
+};
+const Bo = ["value", "onChange", "removeIcon", "placeholder", "autofocus", "maxTagCount", "maxTagTextLength", "maxTagPlaceholder", "choiceTransitionName", "onInputKeyDown", "onPopupScroll", "tabindex", "OptionList", "notFoundContent"], zo = () => ({
+  prefixCls: String,
+  id: String,
+  omitDomProps: Array,
+  // >>> Value
+  displayValues: Array,
+  onDisplayValuesChange: Function,
+  // >>> Active
+  /** Current dropdown list active item string value */
+  activeValue: String,
+  /** Link search input with target element */
+  activeDescendantId: String,
+  onActiveValueChange: Function,
+  // >>> Search
+  searchValue: String,
+  /** Trigger onSearch, return false to prevent trigger open event */
+  onSearch: Function,
+  /** Trigger when search text match the `tokenSeparators`. Will provide split content */
+  onSearchSplit: Function,
+  maxLength: Number,
+  OptionList: $.any,
+  /** Tell if provided `options` is empty */
+  emptyOptions: Boolean
+}), Zt = () => ({
+  showSearch: {
+    type: Boolean,
+    default: void 0
+  },
+  tagRender: {
+    type: Function
+  },
+  optionLabelRender: {
+    type: Function
+  },
+  direction: {
+    type: String
+  },
+  // MISC
+  tabindex: Number,
+  autofocus: Boolean,
+  notFoundContent: $.any,
+  placeholder: $.any,
+  onClear: Function,
+  choiceTransitionName: String,
+  // >>> Mode
+  mode: String,
+  // >>> Status
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  loading: {
+    type: Boolean,
+    default: void 0
+  },
+  // >>> Open
+  open: {
+    type: Boolean,
+    default: void 0
+  },
+  defaultOpen: {
+    type: Boolean,
+    default: void 0
+  },
+  onDropdownVisibleChange: {
+    type: Function
+  },
+  // >>> Customize Input
+  /** @private Internal usage. Do not use in your production. */
+  getInputElement: {
+    type: Function
+  },
+  /** @private Internal usage. Do not use in your production. */
+  getRawInputElement: {
+    type: Function
+  },
+  // >>> Selector
+  maxTagTextLength: Number,
+  maxTagCount: {
+    type: [String, Number]
+  },
+  maxTagPlaceholder: $.any,
+  // >>> Search
+  tokenSeparators: {
+    type: Array
+  },
+  // >>> Icons
+  allowClear: {
+    type: Boolean,
+    default: void 0
+  },
+  showArrow: {
+    type: Boolean,
+    default: void 0
+  },
+  inputIcon: $.any,
+  /** Clear all icon */
+  clearIcon: $.any,
+  /** Selector remove icon */
+  removeIcon: $.any,
+  // >>> Dropdown
+  animation: String,
+  transitionName: String,
+  dropdownStyle: {
+    type: Object
+  },
+  dropdownClassName: String,
+  dropdownMatchSelectWidth: {
+    type: [Boolean, Number],
+    default: void 0
+  },
+  dropdownRender: {
+    type: Function
+  },
+  dropdownAlign: Object,
+  placement: {
+    type: String
+  },
+  getPopupContainer: {
+    type: Function
+  },
+  // >>> Focus
+  showAction: {
+    type: Array
+  },
+  onBlur: {
+    type: Function
+  },
+  onFocus: {
+    type: Function
+  },
+  // >>> Rest Events
+  onKeyup: Function,
+  onKeydown: Function,
+  onMousedown: Function,
+  onPopupScroll: Function,
+  onInputKeyDown: Function,
+  onMouseenter: Function,
+  onMouseleave: Function,
+  onClick: Function
+}), Lo = () => b(b({}, zo()), Zt());
+function it(e) {
+  return e === "tags" || e === "multiple";
+}
+const Ho = ue({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "BaseSelect",
+  inheritAttrs: !1,
+  props: nt(Lo(), {
+    showAction: [],
+    notFoundContent: "Not Found"
+  }),
+  setup(e, n) {
+    let {
+      attrs: o,
+      expose: t,
+      slots: l
+    } = n;
+    const a = F(() => it(e.mode)), c = F(() => e.showSearch !== void 0 ? e.showSearch : a.value || e.mode === "combobox"), s = Y(!1);
+    Ie(() => {
+      s.value = oo();
+    });
+    const m = lt(), p = Y(null), u = tt(), g = Y(null), N = Y(null), D = Y(null), v = ve(!1), [h, y, S] = To();
+    t({
+      focus: () => {
+        var i;
+        (i = N.value) === null || i === void 0 || i.focus();
+      },
+      blur: () => {
+        var i;
+        (i = N.value) === null || i === void 0 || i.blur();
+      },
+      scrollTo: (i) => {
+        var r;
+        return (r = D.value) === null || r === void 0 ? void 0 : r.scrollTo(i);
+      }
+    });
+    const O = F(() => {
+      var i;
+      if (e.mode !== "combobox")
+        return e.searchValue;
+      const r = (i = e.displayValues[0]) === null || i === void 0 ? void 0 : i.value;
+      return typeof r == "string" || typeof r == "number" ? String(r) : "";
+    }), d = e.open !== void 0 ? e.open : e.defaultOpen, P = Y(d), x = Y(d), R = (i) => {
+      P.value = e.open !== void 0 ? e.open : i, x.value = P.value;
+    };
+    pe(() => e.open, () => {
+      R(e.open);
+    });
+    const A = F(() => !e.notFoundContent && e.emptyOptions);
+    Ce(() => {
+      x.value = P.value, (e.disabled || A.value && x.value && e.mode === "combobox") && (x.value = !1);
+    });
+    const X = F(() => A.value ? !1 : x.value), W = (i) => {
+      const r = i !== void 0 ? i : !x.value;
+      x.value !== r && !e.disabled && (R(r), e.onDropdownVisibleChange && e.onDropdownVisibleChange(r), !r && q.value && (q.value = !1, y(!1, () => {
+        ne.value = !1, v.value = !1;
+      })));
+    }, ee = F(() => (e.tokenSeparators || []).some((i) => [`
+`, `\r
+`].includes(i))), Q = (i, r, E) => {
+      var w, B;
+      let H = !0, G = i;
+      (w = e.onActiveValueChange) === null || w === void 0 || w.call(e, null);
+      const k = E ? null : go(i, e.tokenSeparators);
+      return e.mode !== "combobox" && k && (G = "", (B = e.onSearchSplit) === null || B === void 0 || B.call(e, k), W(!1), H = !1), e.onSearch && O.value !== G && e.onSearch(G, {
+        source: r ? "typing" : "effect"
+      }), H;
+    }, U = (i) => {
+      var r;
+      !i || !i.trim() || (r = e.onSearch) === null || r === void 0 || r.call(e, i, {
+        source: "submit"
+      });
+    };
+    pe(x, () => {
+      !x.value && !a.value && e.mode !== "combobox" && Q("", !1, !1);
+    }, {
+      immediate: !0,
+      flush: "post"
+    }), pe(() => e.disabled, () => {
+      P.value && e.disabled && R(!1), e.disabled && !v.value && y(!1);
+    }, {
+      immediate: !0
+    });
+    const [I, T] = Xt(), j = function(i) {
+      var r;
+      const E = I(), {
+        which: w
+      } = i;
+      if (w === z.ENTER && (e.mode !== "combobox" && i.preventDefault(), x.value || W(!0)), T(!!O.value), w === z.BACKSPACE && !E && a.value && !O.value && e.displayValues.length) {
+        const k = [...e.displayValues];
+        let J = null;
+        for (let le = k.length - 1; le >= 0; le -= 1) {
+          const ae = k[le];
+          if (!ae.disabled) {
+            k.splice(le, 1), J = ae;
+            break;
+          }
+        }
+        J && e.onDisplayValuesChange(k, {
+          type: "remove",
+          values: [J]
+        });
+      }
+      for (var B = arguments.length, H = new Array(B > 1 ? B - 1 : 0), G = 1; G < B; G++)
+        H[G - 1] = arguments[G];
+      x.value && D.value && D.value.onKeydown(i, ...H), (r = e.onKeydown) === null || r === void 0 || r.call(e, i, ...H);
+    }, Z = function(i) {
+      for (var r = arguments.length, E = new Array(r > 1 ? r - 1 : 0), w = 1; w < r; w++)
+        E[w - 1] = arguments[w];
+      x.value && D.value && D.value.onKeyup(i, ...E), e.onKeyup && e.onKeyup(i, ...E);
+    }, K = (i) => {
+      const r = e.displayValues.filter((E) => E !== i);
+      e.onDisplayValuesChange(r, {
+        type: "remove",
+        values: [i]
+      });
+    }, ne = Y(!1), _ = function() {
+      y(!0), e.disabled || (e.onFocus && !ne.value && e.onFocus(...arguments), e.showAction && e.showAction.includes("focus") && W(!0)), ne.value = !0;
+    }, q = ve(!1), oe = function() {
+      if (q.value || (v.value = !0, y(!1, () => {
+        ne.value = !1, v.value = !1, W(!1);
+      }), e.disabled))
+        return;
+      const i = O.value;
+      i && (e.mode === "tags" ? e.onSearch(i, {
+        source: "submit"
+      }) : e.mode === "multiple" && e.onSearch("", {
+        source: "blur"
+      })), e.onBlur && e.onBlur(...arguments);
+    }, ie = () => {
+      q.value = !0;
+    }, re = () => {
+      q.value = !1;
+    };
+    _e("VCSelectContainerEvent", {
+      focus: _,
+      blur: oe
+    });
+    const te = [];
+    Ie(() => {
+      te.forEach((i) => clearTimeout(i)), te.splice(0, te.length);
+    }), ke(() => {
+      te.forEach((i) => clearTimeout(i)), te.splice(0, te.length);
+    });
+    const de = function(i) {
+      var r, E;
+      const {
+        target: w
+      } = i, B = (r = g.value) === null || r === void 0 ? void 0 : r.getPopupElement();
+      if (B && B.contains(w)) {
+        const J = setTimeout(() => {
+          var le;
+          const ae = te.indexOf(J);
+          ae !== -1 && te.splice(ae, 1), S(), !s.value && !B.contains(document.activeElement) && ((le = N.value) === null || le === void 0 || le.focus());
+        });
+        te.push(J);
+      }
+      for (var H = arguments.length, G = new Array(H > 1 ? H - 1 : 0), k = 1; k < H; k++)
+        G[k - 1] = arguments[k];
+      (E = e.onMousedown) === null || E === void 0 || E.call(e, i, ...G);
+    }, se = Y(null), f = () => {
+    };
+    return Ie(() => {
+      pe(X, () => {
+        var i;
+        if (X.value) {
+          const r = Math.ceil((i = p.value) === null || i === void 0 ? void 0 : i.offsetWidth);
+          se.value !== r && !Number.isNaN(r) && (se.value = r);
+        }
+      }, {
+        immediate: !0,
+        flush: "post"
+      });
+    }), Ro([p, g], X, W), Mo(Qt(b(b({}, Pn(e)), {
+      open: x,
+      triggerOpen: X,
+      showSearch: c,
+      multiple: a,
+      toggleOpen: W
+    }))), () => {
+      const i = b(b({}, e), o), {
+        prefixCls: r,
+        id: E,
+        open: w,
+        defaultOpen: B,
+        mode: H,
+        // Search related
+        showSearch: G,
+        searchValue: k,
+        onSearch: J,
+        // Icons
+        allowClear: le,
+        clearIcon: ae,
+        showArrow: De,
+        inputIcon: Ve,
+        // Others
+        disabled: Oe,
+        loading: Ne,
+        getInputElement: ft,
+        getPopupContainer: en,
+        placement: tn,
+        // Dropdown
+        animation: nn,
+        transitionName: on,
+        dropdownStyle: ln,
+        dropdownClassName: an,
+        dropdownMatchSelectWidth: rn,
+        dropdownRender: un,
+        dropdownAlign: sn,
+        showAction: wl,
+        direction: cn,
+        // Tags
+        tokenSeparators: Cl,
+        tagRender: dn,
+        optionLabelRender: fn,
+        // Events
+        onPopupScroll: Il,
+        onDropdownVisibleChange: xl,
+        onFocus: Ol,
+        onBlur: $l,
+        onKeyup: Pl,
+        onKeydown: El,
+        onMousedown: Fl,
+        onClear: ze,
+        omitDomProps: Le,
+        getRawInputElement: pt,
+        displayValues: Re,
+        onDisplayValuesChange: pn,
+        emptyOptions: mn,
+        activeDescendantId: vn,
+        activeValue: gn,
+        OptionList: hn
+      } = i, bn = Ao(i, ["prefixCls", "id", "open", "defaultOpen", "mode", "showSearch", "searchValue", "onSearch", "allowClear", "clearIcon", "showArrow", "inputIcon", "disabled", "loading", "getInputElement", "getPopupContainer", "placement", "animation", "transitionName", "dropdownStyle", "dropdownClassName", "dropdownMatchSelectWidth", "dropdownRender", "dropdownAlign", "showAction", "direction", "tokenSeparators", "tagRender", "optionLabelRender", "onPopupScroll", "onDropdownVisibleChange", "onFocus", "onBlur", "onKeyup", "onKeydown", "onMousedown", "onClear", "omitDomProps", "getRawInputElement", "displayValues", "onDisplayValuesChange", "emptyOptions", "activeDescendantId", "activeValue", "OptionList"]), mt = H === "combobox" && ft && ft() || null, $e = typeof pt == "function" && pt(), He = b({}, bn);
+      let vt;
+      $e && (vt = (be) => {
+        W(be);
+      }), Bo.forEach((be) => {
+        delete He[be];
+      }), Le == null || Le.forEach((be) => {
+        delete He[be];
+      });
+      const gt = De !== void 0 ? De : Ne || !a.value && H !== "combobox";
+      let ht;
+      gt && (ht = C(ye, {
+        class: ce(`${r}-arrow`, {
+          [`${r}-arrow-loading`]: Ne
+        }),
+        customizeIcon: Ve,
+        customizeIconProps: {
+          loading: Ne,
+          searchValue: O.value,
+          open: x.value,
+          focused: h.value,
+          showSearch: c.value
+        }
+      }, null));
+      let bt;
+      const yn = () => {
+        ze == null || ze(), pn([], {
+          type: "clear",
+          values: Re
+        }), Q("", !1, !1);
+      };
+      !Oe && le && (Re.length || O.value) && (bt = C(ye, {
+        class: `${r}-clear`,
+        onMousedown: yn,
+        customizeIcon: ae
+      }, {
+        default: () => [Me("×")]
+      }));
+      const Sn = C(hn, {
+        ref: D
+      }, b(b({}, m.customSlots), {
+        option: l.option
+      })), wn = ce(r, o.class, {
+        [`${r}-focused`]: h.value,
+        [`${r}-multiple`]: a.value,
+        [`${r}-single`]: !a.value,
+        [`${r}-allow-clear`]: le,
+        [`${r}-show-arrow`]: gt,
+        [`${r}-disabled`]: Oe,
+        [`${r}-loading`]: Ne,
+        [`${r}-open`]: x.value,
+        [`${r}-customize-input`]: mt,
+        [`${r}-show-search`]: c.value
+      }), yt = C(yo, {
+        ref: g,
+        disabled: Oe,
+        prefixCls: r,
+        visible: X.value,
+        popupElement: Sn,
+        containerWidth: se.value,
+        animation: nn,
+        transitionName: on,
+        dropdownStyle: ln,
+        dropdownClassName: an,
+        direction: cn,
+        dropdownMatchSelectWidth: rn,
+        dropdownRender: un,
+        dropdownAlign: sn,
+        placement: tn,
+        getPopupContainer: en,
+        empty: mn,
+        getTriggerDOMNode: () => u.current,
+        onPopupVisibleChange: vt,
+        onPopupMouseEnter: f,
+        onPopupFocusin: ie,
+        onPopupFocusout: re
+      }, {
+        default: () => $e ? Ee($e) && zt($e, {
+          ref: u
+        }, !1, !0) : C(No, L(L({}, e), {}, {
+          domRef: u,
+          prefixCls: r,
+          inputElement: mt,
+          ref: N,
+          id: E,
+          showSearch: c.value,
+          mode: H,
+          activeDescendantId: vn,
+          tagRender: dn,
+          optionLabelRender: fn,
+          values: Re,
+          open: x.value,
+          onToggleOpen: W,
+          activeValue: gn,
+          searchValue: O.value,
+          onSearch: Q,
+          onSearchSubmit: U,
+          onRemove: K,
+          tokenWithEnter: ee.value
+        }), null)
+      });
+      let We;
+      return $e ? We = yt : We = C("div", L(L({}, He), {}, {
+        class: wn,
+        ref: p,
+        onMousedown: de,
+        onKeydown: j,
+        onKeyup: Z
+      }), [h.value && !x.value && C("span", {
+        style: {
+          width: 0,
+          height: 0,
+          position: "absolute",
+          overflow: "hidden",
+          opacity: 0
+        },
+        "aria-live": "polite"
+      }, [`${Re.map((be) => {
+        let {
+          label: St,
+          value: Cn
+        } = be;
+        return ["number", "string"].includes(typeof St) ? St : Cn;
+      }).join(", ")}`]), yt, ht, bt]), We;
+    };
+  }
+});
+function Wo() {
+  return /(mac\sos|macintosh)/i.test(navigator.appVersion);
+}
+const qt = Symbol("SelectContextKey");
+function Ko(e) {
+  return _e(qt, e);
+}
+function jo() {
+  return Fe(qt, {});
+}
+var Go = function(e, n) {
+  var o = {};
+  for (var t in e) Object.prototype.hasOwnProperty.call(e, t) && n.indexOf(t) < 0 && (o[t] = e[t]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function") for (var l = 0, t = Object.getOwnPropertySymbols(e); l < t.length; l++)
+    n.indexOf(t[l]) < 0 && Object.prototype.propertyIsEnumerable.call(e, t[l]) && (o[t[l]] = e[t[l]]);
+  return o;
+};
+function Rt(e) {
+  return typeof e == "string" || typeof e == "number";
+}
+const Uo = ue({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "OptionList",
+  inheritAttrs: !1,
+  setup(e, n) {
+    let {
+      expose: o,
+      slots: t
+    } = n;
+    const l = _o(), a = jo(), c = F(() => `${l.prefixCls}-item`), s = io(() => a.flattenOptions, [() => l.open, () => a.flattenOptions], (d) => d[0]), m = tt(), p = (d) => {
+      d.preventDefault();
+    }, u = (d) => {
+      m.current && m.current.scrollTo(typeof d == "number" ? {
+        index: d
+      } : d);
+    }, g = function(d) {
+      let P = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1;
+      const x = s.value.length;
+      for (let R = 0; R < x; R += 1) {
+        const A = (d + R * P + x) % x, {
+          group: X,
+          data: W
+        } = s.value[A];
+        if (!X && !W.disabled)
+          return A;
+      }
+      return -1;
+    }, N = Qe({
+      activeIndex: g(0)
+    }), D = function(d) {
+      let P = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
+      N.activeIndex = d;
+      const x = {
+        source: P ? "keyboard" : "mouse"
+      }, R = s.value[d];
+      if (!R) {
+        a.onActiveValue(null, -1, x);
+        return;
+      }
+      a.onActiveValue(R.value, d, x);
+    };
+    pe([() => s.value.length, () => l.searchValue], () => {
+      D(a.defaultActiveFirstOption !== !1 ? g(0) : -1);
+    }, {
+      immediate: !0
+    });
+    const v = (d) => a.rawValues.has(d) && l.mode !== "combobox";
+    pe([() => l.open, () => l.searchValue], () => {
+      if (!l.multiple && l.open && a.rawValues.size === 1) {
+        const d = Array.from(a.rawValues)[0], P = Bt(s.value).findIndex((x) => {
+          let {
+            data: R
+          } = x;
+          return R[a.fieldNames.value] === d;
+        });
+        P !== -1 && (D(P), wt(() => {
+          u(P);
+        }));
+      }
+      l.open && wt(() => {
+        var d;
+        (d = m.current) === null || d === void 0 || d.scrollTo(void 0);
+      });
+    }, {
+      immediate: !0,
+      flush: "post"
+    });
+    const h = (d) => {
+      d !== void 0 && a.onSelect(d, {
+        selected: !a.rawValues.has(d)
+      }), l.multiple || l.toggleOpen(!1);
+    }, y = (d) => typeof d.label == "function" ? d.label() : d.label;
+    function S(d) {
+      const P = s.value[d];
+      if (!P) return null;
+      const x = P.data || {}, {
+        value: R
+      } = x, {
+        group: A
+      } = P, X = et(x, !0), W = y(P);
+      return P ? C("div", L(L({
+        "aria-label": typeof W == "string" && !A ? W : null
+      }, X), {}, {
+        key: d,
+        role: A ? "presentation" : "option",
+        id: `${l.id}_list_${d}`,
+        "aria-selected": v(R)
+      }), [R]) : null;
+    }
+    return o({
+      onKeydown: (d) => {
+        const {
+          which: P,
+          ctrlKey: x
+        } = d;
+        switch (P) {
+          // >>> Arrow keys & ctrl + n/p on Mac
+          case z.N:
+          case z.P:
+          case z.UP:
+          case z.DOWN: {
+            let R = 0;
+            if (P === z.UP ? R = -1 : P === z.DOWN ? R = 1 : Wo() && x && (P === z.N ? R = 1 : P === z.P && (R = -1)), R !== 0) {
+              const A = g(N.activeIndex + R, R);
+              u(A), D(A, !0);
+            }
+            break;
+          }
+          // >>> Select
+          case z.ENTER: {
+            const R = s.value[N.activeIndex];
+            R && !R.data.disabled ? h(R.value) : h(void 0), l.open && d.preventDefault();
+            break;
+          }
+          // >>> Close
+          case z.ESC:
+            l.toggleOpen(!1), l.open && d.stopPropagation();
+        }
+      },
+      onKeyup: () => {
+      },
+      scrollTo: (d) => {
+        u(d);
+      }
+    }), () => {
+      const {
+        id: d,
+        notFoundContent: P,
+        onPopupScroll: x
+      } = l, {
+        menuItemSelectedIcon: R,
+        fieldNames: A,
+        virtual: X,
+        listHeight: W,
+        listItemHeight: ee
+      } = a, Q = t.option, {
+        activeIndex: U
+      } = N, I = Object.keys(A).map((T) => A[T]);
+      return s.value.length === 0 ? C("div", {
+        role: "listbox",
+        id: `${d}_list`,
+        class: `${c.value}-empty`,
+        onMousedown: p
+      }, [P]) : C(xe, null, [C("div", {
+        role: "listbox",
+        id: `${d}_list`,
+        style: {
+          height: 0,
+          width: 0,
+          overflow: "hidden"
+        }
+      }, [S(U - 1), S(U), S(U + 1)]), C(_n, {
+        itemKey: "key",
+        ref: m,
+        data: s.value,
+        height: W,
+        itemHeight: ee,
+        fullHeight: !1,
+        onMousedown: p,
+        onScroll: x,
+        virtual: X
+      }, {
+        default: (T, j) => {
+          var Z;
+          const {
+            group: K,
+            groupOption: ne,
+            data: _,
+            value: q
+          } = T, {
+            key: oe
+          } = _, ie = typeof T.label == "function" ? T.label() : T.label;
+          if (K) {
+            const ae = (Z = _.title) !== null && Z !== void 0 ? Z : Rt(ie) && ie;
+            return C("div", {
+              class: ce(c.value, `${c.value}-group`),
+              title: ae
+            }, [Q ? Q(_) : ie !== void 0 ? ie : oe]);
+          }
+          const {
+            disabled: re,
+            title: te,
+            children: de,
+            style: se,
+            class: f,
+            className: i
+          } = _, r = Go(_, ["disabled", "title", "children", "style", "class", "className"]), E = Ae(r, I), w = v(q), B = `${c.value}-option`, H = ce(c.value, B, f, i, {
+            [`${B}-grouped`]: ne,
+            [`${B}-active`]: U === j && !re,
+            [`${B}-disabled`]: re,
+            [`${B}-selected`]: w
+          }), G = y(T), k = !R || typeof R == "function" || w, J = typeof G == "number" ? G : G || q;
+          let le = Rt(J) ? J.toString() : void 0;
+          return te !== void 0 && (le = te), C("div", L(L({}, E), {}, {
+            "aria-selected": w,
+            class: H,
+            title: le,
+            onMousemove: (ae) => {
+              r.onMousemove && r.onMousemove(ae), !(U === j || re) && D(j);
+            },
+            onClick: (ae) => {
+              re || h(q), r.onClick && r.onClick(ae);
+            },
+            style: se
+          }), [C("div", {
+            class: `${B}-content`
+          }, [Q ? Q(_) : J]), Ee(R) || w, k && C(ye, {
+            class: `${c.value}-option-state`,
+            customizeIcon: R,
+            customizeIconProps: {
+              isSelected: w
+            }
+          }, {
+            default: () => [w ? "✓" : null]
+          })]);
+        }
+      })]);
+    };
+  }
+});
+var Xo = function(e, n) {
+  var o = {};
+  for (var t in e) Object.prototype.hasOwnProperty.call(e, t) && n.indexOf(t) < 0 && (o[t] = e[t]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function") for (var l = 0, t = Object.getOwnPropertySymbols(e); l < t.length; l++)
+    n.indexOf(t[l]) < 0 && Object.prototype.propertyIsEnumerable.call(e, t[l]) && (o[t[l]] = e[t[l]]);
+  return o;
+};
+function Yo(e) {
+  const n = e, {
+    key: o,
+    children: t
+  } = n, l = n.props, {
+    value: a,
+    disabled: c
+  } = l, s = Xo(l, ["value", "disabled"]), m = t == null ? void 0 : t.default;
+  return b({
+    key: o,
+    value: a !== void 0 ? a : o,
+    children: m,
+    disabled: c || c === ""
+  }, s);
+}
+function rt(e) {
+  let n = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
+  return An(e).map((t, l) => {
+    var a;
+    if (!Ee(t) || !t.type)
+      return null;
+    const {
+      type: {
+        isSelectOptGroup: c
+      },
+      key: s,
+      children: m,
+      props: p
+    } = t;
+    if (n || !c)
+      return Yo(t);
+    const u = m && m.default ? m.default() : void 0, g = (p == null ? void 0 : p.label) || ((a = m.label) === null || a === void 0 ? void 0 : a.call(m)) || s;
+    return b(b({
+      key: `__RC_SELECT_GRP__${s === null ? l : String(s)}__`
+    }, p), {
+      label: g,
+      options: rt(u || [])
+    });
+  }).filter((t) => t);
+}
+function Qo(e, n, o) {
+  const t = Y(), l = Y(), a = Y(), c = Y([]);
+  return pe([e, n], () => {
+    e.value ? c.value = Bt(e.value).slice() : c.value = rt(n.value);
+  }, {
+    immediate: !0,
+    deep: !0
+  }), Ce(() => {
+    const s = c.value, m = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map(), u = o.value;
+    function g(N) {
+      let D = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
+      for (let v = 0; v < N.length; v += 1) {
+        const h = N[v];
+        !h[u.options] || D ? (m.set(h[u.value], h), p.set(h[u.label], h)) : g(h[u.options], !0);
+      }
+    }
+    g(s), t.value = s, l.value = m, a.value = p;
+  }), {
+    options: t,
+    valueOptions: l,
+    labelOptions: a
+  };
+}
+let Tt = 0;
+const Zo = process.env.NODE_ENV !== "test" && Bn();
+function qo() {
+  let e;
+  return Zo ? (e = Tt, Tt += 1) : e = "TEST_OR_SSR", e;
+}
+function Jo() {
+  let e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : ve("");
+  const n = `rc_select_${qo()}`;
+  return e.value || n;
+}
+function ut(e) {
+  return Array.isArray(e) ? e : e !== void 0 ? [e] : [];
+}
+const ko = typeof window < "u" && window.document && window.document.documentElement;
+process.env.NODE_ENV;
+function el(e) {
+  const {
+    mode: n,
+    options: o,
+    children: t,
+    backfill: l,
+    allowClear: a,
+    placeholder: c,
+    getInputElement: s,
+    showSearch: m,
+    onSearch: p,
+    defaultOpen: u,
+    autofocus: g,
+    labelInValue: N,
+    value: D,
+    inputValue: v,
+    optionLabelProp: h
+  } = e, y = it(n), S = m !== void 0 ? m : y || n === "combobox", V = o || rt(t);
+  if (me(n !== "tags" || V.every((M) => !M.disabled), "Please avoid setting option to disabled in tags mode since user can always type text as tag."), me(n !== "combobox" || !h, "`combobox` mode not support `optionLabelProp`. Please set `value` on Option directly."), me(n === "combobox" || !l, "`backfill` only works with `combobox` mode."), me(n === "combobox" || !s, "`getInputElement` only work with `combobox` mode."), Ot(n !== "combobox" || !s || !a || !c, "Customize `getInputElement` should customize clear and placeholder logic instead of configuring `allowClear` and `placeholder`."), p && !S && n !== "combobox" && n !== "tags" && me(!1, "`onSearch` should work with `showSearch` instead of use alone."), Ot(!u || g, "`defaultOpen` makes Select open without focus which means it will not close by click outside. You can set `autofocus` if needed."), D != null) {
+    const M = ut(D);
+    me(!N || M.every((O) => typeof O == "object" && ("key" in O || "value" in O)), "`value` should in shape of `{ value: string | number, label?: any }` when you set `labelInValue` to `true`"), me(!y || Array.isArray(D), "`value` should be array when `mode` is `multiple` or `tags`");
+  }
+  if (t) {
+    let M = null;
+    t.some((O) => {
+      var d;
+      if (!Ee(O) || !O.type)
+        return !1;
+      const {
+        type: P
+      } = O;
+      return P.isSelectOption ? !1 : P.isSelectOptGroup ? !(((d = O.children) === null || d === void 0 ? void 0 : d.default()) || []).every((A) => !Ee(A) || !O.type || A.type.isSelectOption ? !0 : (M = A.type, !1)) : (M = P, !0);
+    }), M && me(!1, `\`children\` should be \`Select.Option\` or \`Select.OptGroup\` instead of \`${M.displayName || M.name || M}\`.`), me(v === void 0, "`inputValue` is deprecated, please use `searchValue` instead.");
+  }
+}
+function Ge(e, n) {
+  return ut(e).join("").toUpperCase().includes(n);
+}
+const tl = (e, n, o, t, l) => F(() => {
+  const a = o.value, c = l == null ? void 0 : l.value, s = t == null ? void 0 : t.value;
+  if (!a || s === !1)
+    return e.value;
+  const {
+    options: m,
+    label: p,
+    value: u
+  } = n.value, g = [], N = typeof s == "function", D = a.toUpperCase(), v = N ? s : (y, S) => c ? Ge(S[c], D) : S[m] ? Ge(S[p !== "children" ? p : "label"], D) : Ge(S[u], D), h = N ? (y) => qe(y) : (y) => y;
+  return e.value.forEach((y) => {
+    if (y[m]) {
+      if (v(a, h(y)))
+        g.push(y);
+      else {
+        const V = y[m].filter((M) => v(a, h(M)));
+        V.length && g.push(b(b({}, y), {
+          [m]: V
+        }));
+      }
+      return;
+    }
+    v(a, h(y)) && g.push(y);
+  }), g;
+}), nl = (e, n) => {
+  const o = Y({
+    values: /* @__PURE__ */ new Map(),
+    options: /* @__PURE__ */ new Map()
+  });
+  return [F(() => {
+    const {
+      values: a,
+      options: c
+    } = o.value, s = e.value.map((u) => {
+      var g;
+      return u.label === void 0 ? b(b({}, u), {
+        label: (g = a.get(u.value)) === null || g === void 0 ? void 0 : g.label
+      }) : u;
+    }), m = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map();
+    return s.forEach((u) => {
+      m.set(u.value, u), p.set(u.value, n.value.get(u.value) || c.get(u.value));
+    }), o.value.values = m, o.value.options = p, s;
+  }), (a) => n.value.get(a) || o.value.options.get(a)];
+}, ol = ["inputValue"];
+function Jt() {
+  return b(b({}, Zt()), {
+    prefixCls: String,
+    id: String,
+    backfill: {
+      type: Boolean,
+      default: void 0
+    },
+    // >>> Field Names
+    fieldNames: Object,
+    // >>> Search
+    /** @deprecated Use `searchValue` instead */
+    inputValue: String,
+    searchValue: String,
+    onSearch: Function,
+    autoClearSearchValue: {
+      type: Boolean,
+      default: void 0
+    },
+    // >>> Select
+    onSelect: Function,
+    onDeselect: Function,
+    // >>> Options
+    /**
+     * In Select, `false` means do nothing.
+     * In TreeSelect, `false` will highlight match item.
+     * It's by design.
+     */
+    filterOption: {
+      type: [Boolean, Function],
+      default: void 0
+    },
+    filterSort: Function,
+    optionFilterProp: String,
+    optionLabelProp: String,
+    options: Array,
+    defaultActiveFirstOption: {
+      type: Boolean,
+      default: void 0
+    },
+    virtual: {
+      type: Boolean,
+      default: void 0
+    },
+    listHeight: Number,
+    listItemHeight: Number,
+    // >>> Icon
+    menuItemSelectedIcon: $.any,
+    mode: String,
+    labelInValue: {
+      type: Boolean,
+      default: void 0
+    },
+    value: $.any,
+    defaultValue: $.any,
+    onChange: Function,
+    children: Array
+  });
+}
+function ll(e) {
+  return !e || typeof e != "object";
+}
+const al = ue({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "VcSelect",
+  inheritAttrs: !1,
+  props: nt(Jt(), {
+    prefixCls: "vc-select",
+    autoClearSearchValue: !0,
+    listHeight: 200,
+    listItemHeight: 20,
+    dropdownMatchSelectWidth: !0
+  }),
+  setup(e, n) {
+    let {
+      expose: o,
+      attrs: t,
+      slots: l
+    } = n;
+    const a = Jo(ge(e, "id")), c = F(() => it(e.mode)), s = F(() => !!(!e.options && e.children)), m = F(() => e.filterOption === void 0 && e.mode === "combobox" ? !1 : e.filterOption), p = F(() => Wt(e.fieldNames, s.value)), [u, g] = Et("", {
+      value: F(() => e.searchValue !== void 0 ? e.searchValue : e.inputValue),
+      postState: (f) => f || ""
+    }), N = Qo(ge(e, "options"), ge(e, "children"), p), {
+      valueOptions: D,
+      labelOptions: v,
+      options: h
+    } = N, y = (f) => ut(f).map((r) => {
+      var E, w;
+      let B, H, G, k;
+      ll(r) ? B = r : (G = r.key, H = r.label, B = (E = r.value) !== null && E !== void 0 ? E : G);
+      const J = D.value.get(B);
+      return J && (H === void 0 && (H = J == null ? void 0 : J[e.optionLabelProp || p.value.label]), G === void 0 && (G = (w = J == null ? void 0 : J.key) !== null && w !== void 0 ? w : B), k = J == null ? void 0 : J.disabled), {
+        label: H,
+        value: B,
+        key: G,
+        disabled: k,
+        option: J
+      };
+    }), [S, V] = Et(e.defaultValue, {
+      value: ge(e, "value")
+    }), M = F(() => {
+      var f;
+      const i = y(S.value);
+      return e.mode === "combobox" && !(!((f = i[0]) === null || f === void 0) && f.value) ? [] : i;
+    }), [O, d] = nl(M, D), P = F(() => {
+      if (!e.mode && O.value.length === 1) {
+        const f = O.value[0];
+        if (f.value === null && (f.label === null || f.label === void 0))
+          return [];
+      }
+      return O.value.map((f) => {
+        var i;
+        return b(b({}, f), {
+          label: (i = typeof f.label == "function" ? f.label() : f.label) !== null && i !== void 0 ? i : f.value
+        });
+      });
+    }), x = F(() => new Set(O.value.map((f) => f.value)));
+    Ce(() => {
+      var f;
+      if (e.mode === "combobox") {
+        const i = (f = O.value[0]) === null || f === void 0 ? void 0 : f.value;
+        i != null && g(String(i));
+      }
+    }, {
+      flush: "post"
+    });
+    const R = (f, i) => {
+      const r = i ?? f;
+      return {
+        [p.value.value]: f,
+        [p.value.label]: r
+      };
+    }, A = Y();
+    Ce(() => {
+      if (e.mode !== "tags") {
+        A.value = h.value;
+        return;
+      }
+      const f = h.value.slice(), i = (r) => D.value.has(r);
+      [...O.value].sort((r, E) => r.value < E.value ? -1 : 1).forEach((r) => {
+        const E = r.value;
+        i(E) || f.push(R(E, r.label));
+      }), A.value = f;
+    });
+    const X = tl(A, p, u, m, ge(e, "optionFilterProp")), W = F(() => e.mode !== "tags" || !u.value || X.value.some((f) => f[e.optionFilterProp || "value"] === u.value) ? X.value : [R(u.value), ...X.value]), ee = F(() => e.filterSort ? [...W.value].sort((f, i) => e.filterSort(f, i)) : W.value), Q = F(() => vo(ee.value, {
+      fieldNames: p.value,
+      childrenAsData: s.value
+    })), U = (f) => {
+      const i = y(f);
+      if (V(i), e.onChange && // Trigger event only when value changed
+      (i.length !== O.value.length || i.some((r, E) => {
+        var w;
+        return ((w = O.value[E]) === null || w === void 0 ? void 0 : w.value) !== (r == null ? void 0 : r.value);
+      }))) {
+        const r = e.labelInValue ? i.map((w) => b(b({}, w), {
+          originLabel: w.label,
+          label: typeof w.label == "function" ? w.label() : w.label
+        })) : i.map((w) => w.value), E = i.map((w) => qe(d(w.value)));
+        e.onChange(
+          // Value
+          c.value ? r : r[0],
+          // Option
+          c.value ? E : E[0]
+        );
+      }
+    }, [I, T] = $t(null), [j, Z] = $t(0), K = F(() => e.defaultActiveFirstOption !== void 0 ? e.defaultActiveFirstOption : e.mode !== "combobox"), ne = function(f, i) {
+      let {
+        source: r = "keyboard"
+      } = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+      Z(i), e.backfill && e.mode === "combobox" && f !== null && r === "keyboard" && T(String(f));
+    }, _ = (f, i) => {
+      const r = () => {
+        var E;
+        const w = d(f), B = w == null ? void 0 : w[p.value.label];
+        return [e.labelInValue ? {
+          label: typeof B == "function" ? B() : B,
+          originLabel: B,
+          value: f,
+          key: (E = w == null ? void 0 : w.key) !== null && E !== void 0 ? E : f
+        } : f, qe(w)];
+      };
+      if (i && e.onSelect) {
+        const [E, w] = r();
+        e.onSelect(E, w);
+      } else if (!i && e.onDeselect) {
+        const [E, w] = r();
+        e.onDeselect(E, w);
+      }
+    }, q = (f, i) => {
+      let r;
+      const E = c.value ? i.selected : !0;
+      E ? r = c.value ? [...O.value, f] : [f] : r = O.value.filter((w) => w.value !== f), U(r), _(f, E), e.mode === "combobox" ? T("") : (!c.value || e.autoClearSearchValue) && (g(""), T(""));
+    }, oe = (f, i) => {
+      U(f), (i.type === "remove" || i.type === "clear") && i.values.forEach((r) => {
+        _(r.value, !1);
+      });
+    }, ie = (f, i) => {
+      var r;
+      if (g(f), T(null), i.source === "submit") {
+        const E = (f || "").trim();
+        if (E) {
+          const w = Array.from(/* @__PURE__ */ new Set([...x.value, E]));
+          U(w), _(E, !0), g("");
+        }
+        return;
+      }
+      i.source !== "blur" && (e.mode === "combobox" && U(f), (r = e.onSearch) === null || r === void 0 || r.call(e, f));
+    }, re = (f) => {
+      let i = f;
+      e.mode !== "tags" && (i = f.map((E) => {
+        const w = v.value.get(E);
+        return w == null ? void 0 : w.value;
+      }).filter((E) => E !== void 0));
+      const r = Array.from(/* @__PURE__ */ new Set([...x.value, ...i]));
+      U(r), r.forEach((E) => {
+        _(E, !0);
+      });
+    }, te = F(() => e.virtual !== !1 && e.dropdownMatchSelectWidth !== !1);
+    Ko(Qt(b(b({}, N), {
+      flattenOptions: Q,
+      onActiveValue: ne,
+      defaultActiveFirstOption: K,
+      onSelect: q,
+      menuItemSelectedIcon: ge(e, "menuItemSelectedIcon"),
+      rawValues: x,
+      fieldNames: p,
+      virtual: te,
+      listHeight: ge(e, "listHeight"),
+      listItemHeight: ge(e, "listItemHeight"),
+      childrenAsData: s
+    }))), process.env.NODE_ENV !== "production" && Ce(() => {
+      el(e);
+    }, {
+      flush: "post"
+    });
+    const de = ve();
+    o({
+      focus() {
+        var f;
+        (f = de.value) === null || f === void 0 || f.focus();
+      },
+      blur() {
+        var f;
+        (f = de.value) === null || f === void 0 || f.blur();
+      },
+      scrollTo(f) {
+        var i;
+        (i = de.value) === null || i === void 0 || i.scrollTo(f);
+      }
+    });
+    const se = F(() => Ae(e, [
+      "id",
+      "mode",
+      "prefixCls",
+      "backfill",
+      "fieldNames",
+      // Search
+      "inputValue",
+      "searchValue",
+      "onSearch",
+      "autoClearSearchValue",
+      // Select
+      "onSelect",
+      "onDeselect",
+      "dropdownMatchSelectWidth",
+      // Options
+      "filterOption",
+      "filterSort",
+      "optionFilterProp",
+      "optionLabelProp",
+      "options",
+      "children",
+      "defaultActiveFirstOption",
+      "menuItemSelectedIcon",
+      "virtual",
+      "listHeight",
+      "listItemHeight",
+      // Value
+      "value",
+      "defaultValue",
+      "labelInValue",
+      "onChange"
+    ]));
+    return () => C(Ho, L(L(L({}, se.value), t), {}, {
+      id: a,
+      prefixCls: e.prefixCls,
+      ref: de,
+      omitDomProps: ol,
+      mode: e.mode,
+      displayValues: P.value,
+      onDisplayValuesChange: oe,
+      searchValue: u.value,
+      onSearch: ie,
+      onSearchSplit: re,
+      dropdownMatchSelectWidth: e.dropdownMatchSelectWidth,
+      OptionList: Uo,
+      emptyOptions: !Q.value.length,
+      activeValue: I.value,
+      activeDescendantId: `${a}_list_${j.value}`
+    }), l);
+  }
+}), st = () => null;
+st.isSelectOption = !0;
+st.displayName = "ASelectOption";
+const ct = () => null;
+ct.isSelectOptGroup = !0;
+ct.displayName = "ASelectOptGroup";
+var il = { icon: { tag: "svg", attrs: { viewBox: "64 64 896 896", focusable: "false" }, children: [{ tag: "path", attrs: { d: "M912 190h-69.9c-9.8 0-19.1 4.5-25.1 12.2L404.7 724.5 207 474a32 32 0 00-25.1-12.2H112c-6.7 0-10.4 7.7-6.3 12.9l273.9 347c12.8 16.2 37.4 16.2 50.3 0l488.4-618.9c4.1-5.1.4-12.8-6.3-12.8z" } }] }, name: "check", theme: "outlined" };
+function Mt(e) {
+  for (var n = 1; n < arguments.length; n++) {
+    var o = arguments[n] != null ? Object(arguments[n]) : {}, t = Object.keys(o);
+    typeof Object.getOwnPropertySymbols == "function" && (t = t.concat(Object.getOwnPropertySymbols(o).filter(function(l) {
+      return Object.getOwnPropertyDescriptor(o, l).enumerable;
+    }))), t.forEach(function(l) {
+      rl(e, l, o[l]);
+    });
+  }
+  return e;
+}
+function rl(e, n, o) {
+  return n in e ? Object.defineProperty(e, n, { value: o, enumerable: !0, configurable: !0, writable: !0 }) : e[n] = o, e;
+}
+var dt = function(n, o) {
+  var t = Mt({}, n, o.attrs);
+  return C(zn, Mt({}, t, {
+    icon: il
+  }), null);
+};
+dt.displayName = "CheckOutlined";
+dt.inheritAttrs = !1;
+function ul(e) {
+  let n = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  const {
+    loading: o,
+    multiple: t,
+    prefixCls: l,
+    hasFeedback: a,
+    feedbackIcon: c,
+    showArrow: s
+  } = e, m = e.suffixIcon || n.suffixIcon && n.suffixIcon(), p = e.clearIcon || n.clearIcon && n.clearIcon(), u = e.menuItemSelectedIcon || n.menuItemSelectedIcon && n.menuItemSelectedIcon(), g = e.removeIcon || n.removeIcon && n.removeIcon(), N = p ?? C(Ln, null, null), D = (S) => C(xe, null, [s !== !1 && S, a && c]);
+  let v = null;
+  if (m !== void 0)
+    v = D(m);
+  else if (o)
+    v = D(C(Hn, {
+      spin: !0
+    }, null));
+  else {
+    const S = `${l}-suffix`;
+    v = (V) => {
+      let {
+        open: M,
+        showSearch: O
+      } = V;
+      return D(M && O ? C(lo, {
+        class: S
+      }, null) : C(ao, {
+        class: S
+      }, null));
+    };
+  }
+  let h = null;
+  u !== void 0 ? h = u : t ? h = C(dt, null, null) : h = null;
+  let y = null;
+  return g !== void 0 ? y = g : y = C(ro, null, null), {
+    clearIcon: N,
+    suffixIcon: v,
+    itemIcon: h,
+    removeIcon: y
+  };
+}
+const _t = (e) => {
+  const {
+    controlPaddingHorizontal: n
+  } = e;
+  return {
+    position: "relative",
+    display: "block",
+    minHeight: e.controlHeight,
+    padding: `${(e.controlHeight - e.fontSize * e.lineHeight) / 2}px ${n}px`,
+    color: e.colorText,
+    fontWeight: "normal",
+    fontSize: e.fontSize,
+    lineHeight: e.lineHeight,
+    boxSizing: "border-box"
+  };
+}, sl = (e) => {
+  const {
+    antCls: n,
+    componentCls: o
+  } = e, t = `${o}-item`;
+  return [
+    {
+      [`${o}-dropdown`]: b(b({}, ot(e)), {
+        position: "absolute",
+        top: -9999,
+        zIndex: e.zIndexPopup,
+        boxSizing: "border-box",
+        padding: e.paddingXXS,
+        overflow: "hidden",
+        fontSize: e.fontSize,
+        // Fix select render lag of long text in chrome
+        // https://github.com/ant-design/ant-design/issues/11456
+        // https://github.com/ant-design/ant-design/issues/11843
+        fontVariant: "initial",
+        backgroundColor: e.colorBgElevated,
+        borderRadius: e.borderRadiusLG,
+        outline: "none",
+        boxShadow: e.boxShadowSecondary,
+        [`
+            &${n}-slide-up-enter${n}-slide-up-enter-active${o}-dropdown-placement-bottomLeft,
+            &${n}-slide-up-appear${n}-slide-up-appear-active${o}-dropdown-placement-bottomLeft
+          `]: {
+          animationName: fo
+        },
+        [`
+            &${n}-slide-up-enter${n}-slide-up-enter-active${o}-dropdown-placement-topLeft,
+            &${n}-slide-up-appear${n}-slide-up-appear-active${o}-dropdown-placement-topLeft
+          `]: {
+          animationName: co
+        },
+        [`&${n}-slide-up-leave${n}-slide-up-leave-active${o}-dropdown-placement-bottomLeft`]: {
+          animationName: so
+        },
+        [`&${n}-slide-up-leave${n}-slide-up-leave-active${o}-dropdown-placement-topLeft`]: {
+          animationName: uo
+        },
+        "&-hidden": {
+          display: "none"
+        },
+        "&-empty": {
+          color: e.colorTextDisabled
+        },
+        // ========================= Options =========================
+        [`${t}-empty`]: b(b({}, _t(e)), {
+          color: e.colorTextDisabled
+        }),
+        [`${t}`]: b(b({}, _t(e)), {
+          cursor: "pointer",
+          transition: `background ${e.motionDurationSlow} ease`,
+          borderRadius: e.borderRadiusSM,
+          // =========== Group ============
+          "&-group": {
+            color: e.colorTextDescription,
+            fontSize: e.fontSizeSM,
+            cursor: "default"
+          },
+          // =========== Option ===========
+          "&-option": {
+            display: "flex",
+            "&-content": b({
+              flex: "auto"
+            }, Ze),
+            "&-state": {
+              flex: "none"
+            },
+            [`&-active:not(${t}-option-disabled)`]: {
+              backgroundColor: e.controlItemBgHover
+            },
+            [`&-selected:not(${t}-option-disabled)`]: {
+              color: e.colorText,
+              fontWeight: e.fontWeightStrong,
+              backgroundColor: e.controlItemBgActive,
+              [`${t}-option-state`]: {
+                color: e.colorPrimary
+              }
+            },
+            "&-disabled": {
+              [`&${t}-option-selected`]: {
+                backgroundColor: e.colorBgContainerDisabled
+              },
+              color: e.colorTextDisabled,
+              cursor: "not-allowed"
+            },
+            "&-grouped": {
+              paddingInlineStart: e.controlPaddingHorizontal * 2
+            }
+          }
+        }),
+        // =========================== RTL ===========================
+        "&-rtl": {
+          direction: "rtl"
+        }
+      })
+    },
+    // Follow code may reuse in other components
+    Ft(e, "slide-up"),
+    Ft(e, "slide-down"),
+    Dt(e, "move-up"),
+    Dt(e, "move-down")
+  ];
+}, we = 2;
+function kt(e) {
+  let {
+    controlHeightSM: n,
+    controlHeight: o,
+    lineWidth: t
+  } = e;
+  const l = (o - n) / 2 - t, a = Math.ceil(l / 2);
+  return [l, a];
+}
+function Ue(e, n) {
+  const {
+    componentCls: o,
+    iconCls: t
+  } = e, l = `${o}-selection-overflow`, a = e.controlHeightSM, [c] = kt(e), s = n ? `${o}-${n}` : "";
+  return {
+    [`${o}-multiple${s}`]: {
+      fontSize: e.fontSize,
+      /**
+       * Do not merge `height` & `line-height` under style with `selection` & `search`, since chrome
+       * may update to redesign with its align logic.
+       */
+      // =========================== Overflow ===========================
+      [l]: {
+        position: "relative",
+        display: "flex",
+        flex: "auto",
+        flexWrap: "wrap",
+        maxWidth: "100%",
+        "&-item": {
+          flex: "none",
+          alignSelf: "center",
+          maxWidth: "100%",
+          display: "inline-flex"
+        }
+      },
+      // ========================= Selector =========================
+      [`${o}-selector`]: {
+        display: "flex",
+        flexWrap: "wrap",
+        alignItems: "center",
+        // Multiple is little different that horizontal is follow the vertical
+        padding: `${c - we}px ${we * 2}px`,
+        borderRadius: e.borderRadius,
+        [`${o}-show-search&`]: {
+          cursor: "text"
+        },
+        [`${o}-disabled&`]: {
+          background: e.colorBgContainerDisabled,
+          cursor: "not-allowed"
+        },
+        "&:after": {
+          display: "inline-block",
+          width: 0,
+          margin: `${we}px 0`,
+          lineHeight: `${a}px`,
+          content: '"\\a0"'
+        }
+      },
+      [`
+        &${o}-show-arrow ${o}-selector,
+        &${o}-allow-clear ${o}-selector
+      `]: {
+        paddingInlineEnd: e.fontSizeIcon + e.controlPaddingHorizontal
+      },
+      // ======================== Selections ========================
+      [`${o}-selection-item`]: {
+        position: "relative",
+        display: "flex",
+        flex: "none",
+        boxSizing: "border-box",
+        maxWidth: "100%",
+        height: a,
+        marginTop: we,
+        marginBottom: we,
+        lineHeight: `${a - e.lineWidth * 2}px`,
+        background: e.colorFillSecondary,
+        border: `${e.lineWidth}px solid ${e.colorSplit}`,
+        borderRadius: e.borderRadiusSM,
+        cursor: "default",
+        transition: `font-size ${e.motionDurationSlow}, line-height ${e.motionDurationSlow}, height ${e.motionDurationSlow}`,
+        userSelect: "none",
+        marginInlineEnd: we * 2,
+        paddingInlineStart: e.paddingXS,
+        paddingInlineEnd: e.paddingXS / 2,
+        [`${o}-disabled&`]: {
+          color: e.colorTextDisabled,
+          borderColor: e.colorBorder,
+          cursor: "not-allowed"
+        },
+        // It's ok not to do this, but 24px makes bottom narrow in view should adjust
+        "&-content": {
+          display: "inline-block",
+          marginInlineEnd: e.paddingXS / 2,
+          overflow: "hidden",
+          whiteSpace: "pre",
+          textOverflow: "ellipsis"
+        },
+        "&-remove": b(b({}, Ht()), {
+          display: "inline-block",
+          color: e.colorIcon,
+          fontWeight: "bold",
+          fontSize: 10,
+          lineHeight: "inherit",
+          cursor: "pointer",
+          [`> ${t}`]: {
+            verticalAlign: "-0.2em"
+          },
+          "&:hover": {
+            color: e.colorIconHover
+          }
+        })
+      },
+      // ========================== Input ==========================
+      [`${l}-item + ${l}-item`]: {
+        [`${o}-selection-search`]: {
+          marginInlineStart: 0
+        }
+      },
+      [`${o}-selection-search`]: {
+        display: "inline-flex",
+        position: "relative",
+        maxWidth: "100%",
+        marginInlineStart: e.inputPaddingHorizontalBase - c,
+        "\n          &-input,\n          &-mirror\n        ": {
+          height: a,
+          fontFamily: e.fontFamily,
+          lineHeight: `${a}px`,
+          transition: `all ${e.motionDurationSlow}`
+        },
+        "&-input": {
+          width: "100%",
+          minWidth: 4.1
+          // fix search cursor missing
+        },
+        "&-mirror": {
+          position: "absolute",
+          top: 0,
+          insetInlineStart: 0,
+          insetInlineEnd: "auto",
+          zIndex: 999,
+          whiteSpace: "pre",
+          visibility: "hidden"
+        }
+      },
+      // ======================= Placeholder =======================
+      [`${o}-selection-placeholder `]: {
+        position: "absolute",
+        top: "50%",
+        insetInlineStart: e.inputPaddingHorizontalBase,
+        insetInlineEnd: e.inputPaddingHorizontalBase,
+        transform: "translateY(-50%)",
+        transition: `all ${e.motionDurationSlow}`
+      }
+    }
+  };
+}
+function cl(e) {
+  const {
+    componentCls: n
+  } = e, o = he(e, {
+    controlHeight: e.controlHeightSM,
+    controlHeightSM: e.controlHeightXS,
+    borderRadius: e.borderRadiusSM,
+    borderRadiusSM: e.borderRadiusXS
+  }), [, t] = kt(e);
+  return [
+    Ue(e),
+    // ======================== Small ========================
+    // Shared
+    Ue(o, "sm"),
+    // Padding
+    {
+      [`${n}-multiple${n}-sm`]: {
+        [`${n}-selection-placeholder`]: {
+          insetInlineStart: e.controlPaddingHorizontalSM - e.lineWidth,
+          insetInlineEnd: "auto"
+        },
+        // https://github.com/ant-design/ant-design/issues/29559
+        [`${n}-selection-search`]: {
+          marginInlineStart: t
+        }
+      }
+    },
+    // ======================== Large ========================
+    // Shared
+    Ue(he(e, {
+      fontSize: e.fontSizeLG,
+      controlHeight: e.controlHeightLG,
+      controlHeightSM: e.controlHeight,
+      borderRadius: e.borderRadiusLG,
+      borderRadiusSM: e.borderRadius
+    }), "lg")
+  ];
+}
+function Xe(e, n) {
+  const {
+    componentCls: o,
+    inputPaddingHorizontalBase: t,
+    borderRadius: l
+  } = e, a = e.controlHeight - e.lineWidth * 2, c = Math.ceil(e.fontSize * 1.25), s = n ? `${o}-${n}` : "";
+  return {
+    [`${o}-single${s}`]: {
+      fontSize: e.fontSize,
+      // ========================= Selector =========================
+      [`${o}-selector`]: b(b({}, ot(e)), {
+        display: "flex",
+        borderRadius: l,
+        [`${o}-selection-search`]: {
+          position: "absolute",
+          top: 0,
+          insetInlineStart: t,
+          insetInlineEnd: t,
+          bottom: 0,
+          "&-input": {
+            width: "100%"
+          }
+        },
+        [`
+          ${o}-selection-item,
+          ${o}-selection-placeholder
+        `]: {
+          padding: 0,
+          lineHeight: `${a}px`,
+          transition: `all ${e.motionDurationSlow}`,
+          // Firefox inline-block position calculation is not same as Chrome & Safari. Patch this:
+          "@supports (-moz-appearance: meterbar)": {
+            lineHeight: `${a}px`
+          }
+        },
+        [`${o}-selection-item`]: {
+          position: "relative",
+          userSelect: "none"
+        },
+        [`${o}-selection-placeholder`]: {
+          transition: "none",
+          pointerEvents: "none"
+        },
+        // For common baseline align
+        [[
+          "&:after",
+          /* For '' value baseline align */
+          `${o}-selection-item:after`,
+          /* For undefined value baseline align */
+          `${o}-selection-placeholder:after`
+        ].join(",")]: {
+          display: "inline-block",
+          width: 0,
+          visibility: "hidden",
+          content: '"\\a0"'
+        }
+      }),
+      [`
+        &${o}-show-arrow ${o}-selection-item,
+        &${o}-show-arrow ${o}-selection-placeholder
+      `]: {
+        paddingInlineEnd: c
+      },
+      // Opacity selection if open
+      [`&${o}-open ${o}-selection-item`]: {
+        color: e.colorTextPlaceholder
+      },
+      // ========================== Input ==========================
+      // We only change the style of non-customize input which is only support by `combobox` mode.
+      // Not customize
+      [`&:not(${o}-customize-input)`]: {
+        [`${o}-selector`]: {
+          width: "100%",
+          height: e.controlHeight,
+          padding: `0 ${t}px`,
+          [`${o}-selection-search-input`]: {
+            height: a
+          },
+          "&:after": {
+            lineHeight: `${a}px`
+          }
+        }
+      },
+      [`&${o}-customize-input`]: {
+        [`${o}-selector`]: {
+          "&:after": {
+            display: "none"
+          },
+          [`${o}-selection-search`]: {
+            position: "static",
+            width: "100%"
+          },
+          [`${o}-selection-placeholder`]: {
+            position: "absolute",
+            insetInlineStart: 0,
+            insetInlineEnd: 0,
+            padding: `0 ${t}px`,
+            "&:after": {
+              display: "none"
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function dl(e) {
+  const {
+    componentCls: n
+  } = e, o = e.controlPaddingHorizontalSM - e.lineWidth;
+  return [
+    Xe(e),
+    // ======================== Small ========================
+    // Shared
+    Xe(he(e, {
+      controlHeight: e.controlHeightSM,
+      borderRadius: e.borderRadiusSM
+    }), "sm"),
+    // padding
+    {
+      [`${n}-single${n}-sm`]: {
+        [`&:not(${n}-customize-input)`]: {
+          [`${n}-selection-search`]: {
+            insetInlineStart: o,
+            insetInlineEnd: o
+          },
+          [`${n}-selector`]: {
+            padding: `0 ${o}px`
+          },
+          // With arrow should provides `padding-right` to show the arrow
+          [`&${n}-show-arrow ${n}-selection-search`]: {
+            insetInlineEnd: o + e.fontSize * 1.5
+          },
+          [`
+            &${n}-show-arrow ${n}-selection-item,
+            &${n}-show-arrow ${n}-selection-placeholder
+          `]: {
+            paddingInlineEnd: e.fontSize * 1.5
+          }
+        }
+      }
+    },
+    // ======================== Large ========================
+    // Shared
+    Xe(he(e, {
+      controlHeight: e.controlHeightLG,
+      fontSize: e.fontSizeLG,
+      borderRadius: e.borderRadiusLG
+    }), "lg")
+  ];
+}
+const fl = (e) => {
+  const {
+    componentCls: n
+  } = e;
+  return {
+    position: "relative",
+    backgroundColor: e.colorBgContainer,
+    border: `${e.lineWidth}px ${e.lineType} ${e.colorBorder}`,
+    transition: `all ${e.motionDurationMid} ${e.motionEaseInOut}`,
+    input: {
+      cursor: "pointer"
+    },
+    [`${n}-show-search&`]: {
+      cursor: "text",
+      input: {
+        cursor: "auto",
+        color: "inherit"
+      }
+    },
+    [`${n}-disabled&`]: {
+      color: e.colorTextDisabled,
+      background: e.colorBgContainerDisabled,
+      cursor: "not-allowed",
+      [`${n}-multiple&`]: {
+        background: e.colorBgContainerDisabled
+      },
+      input: {
+        cursor: "not-allowed"
+      }
+    }
+  };
+}, Ye = function(e, n) {
+  let o = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : !1;
+  const {
+    componentCls: t,
+    borderHoverColor: l,
+    outlineColor: a,
+    antCls: c
+  } = n, s = o ? {
+    [`${t}-selector`]: {
+      borderColor: l
+    }
+  } : {};
+  return {
+    [e]: {
+      [`&:not(${t}-disabled):not(${t}-customize-input):not(${c}-pagination-size-changer)`]: b(b({}, s), {
+        [`${t}-focused& ${t}-selector`]: {
+          borderColor: l,
+          boxShadow: `0 0 0 ${n.controlOutlineWidth}px ${a}`,
+          borderInlineEndWidth: `${n.controlLineWidth}px !important`,
+          outline: 0
+        },
+        [`&:hover ${t}-selector`]: {
+          borderColor: l,
+          borderInlineEndWidth: `${n.controlLineWidth}px !important`
+        }
+      })
+    }
+  };
+}, pl = (e) => {
+  const {
+    componentCls: n
+  } = e;
+  return {
+    [`${n}-selection-search-input`]: {
+      margin: 0,
+      padding: 0,
+      background: "transparent",
+      border: "none",
+      outline: "none",
+      appearance: "none",
+      "&::-webkit-search-cancel-button": {
+        display: "none",
+        "-webkit-appearance": "none"
+      }
+    }
+  };
+}, ml = (e) => {
+  const {
+    componentCls: n,
+    inputPaddingHorizontalBase: o,
+    iconCls: t
+  } = e;
+  return {
+    [n]: b(b({}, ot(e)), {
+      position: "relative",
+      display: "inline-block",
+      cursor: "pointer",
+      [`&:not(${n}-customize-input) ${n}-selector`]: b(b({}, fl(e)), pl(e)),
+      // [`&:not(&-disabled):hover ${selectCls}-selector`]: {
+      //   ...genHoverStyle(token),
+      // },
+      // ======================== Selection ========================
+      [`${n}-selection-item`]: b({
+        flex: 1,
+        fontWeight: "normal"
+      }, Ze),
+      // ======================= Placeholder =======================
+      [`${n}-selection-placeholder`]: b(b({}, Ze), {
+        flex: 1,
+        color: e.colorTextPlaceholder,
+        pointerEvents: "none"
+      }),
+      // ========================== Arrow ==========================
+      [`${n}-arrow`]: b(b({}, Ht()), {
+        position: "absolute",
+        top: "50%",
+        insetInlineStart: "auto",
+        insetInlineEnd: o,
+        height: e.fontSizeIcon,
+        marginTop: -e.fontSizeIcon / 2,
+        color: e.colorTextQuaternary,
+        fontSize: e.fontSizeIcon,
+        lineHeight: 1,
+        textAlign: "center",
+        pointerEvents: "none",
+        display: "flex",
+        alignItems: "center",
+        [t]: {
+          verticalAlign: "top",
+          transition: `transform ${e.motionDurationSlow}`,
+          "> svg": {
+            verticalAlign: "top"
+          },
+          [`&:not(${n}-suffix)`]: {
+            pointerEvents: "auto"
+          }
+        },
+        [`${n}-disabled &`]: {
+          cursor: "not-allowed"
+        },
+        "> *:not(:last-child)": {
+          marginInlineEnd: 8
+          // FIXME: magic
+        }
+      }),
+      // ========================== Clear ==========================
+      [`${n}-clear`]: {
+        position: "absolute",
+        top: "50%",
+        insetInlineStart: "auto",
+        insetInlineEnd: o,
+        zIndex: 1,
+        display: "inline-block",
+        width: e.fontSizeIcon,
+        height: e.fontSizeIcon,
+        marginTop: -e.fontSizeIcon / 2,
+        color: e.colorTextQuaternary,
+        fontSize: e.fontSizeIcon,
+        fontStyle: "normal",
+        lineHeight: 1,
+        textAlign: "center",
+        textTransform: "none",
+        background: e.colorBgContainer,
+        cursor: "pointer",
+        opacity: 0,
+        transition: `color ${e.motionDurationMid} ease, opacity ${e.motionDurationSlow} ease`,
+        textRendering: "auto",
+        "&:before": {
+          display: "block"
+        },
+        "&:hover": {
+          color: e.colorTextTertiary
+        }
+      },
+      "&:hover": {
+        [`${n}-clear`]: {
+          opacity: 1
+        }
+      }
+    }),
+    // ========================= Feedback ==========================
+    [`${n}-has-feedback`]: {
+      [`${n}-clear`]: {
+        insetInlineEnd: o + e.fontSize + e.paddingXXS
+      }
+    }
+  };
+}, vl = (e) => {
+  const {
+    componentCls: n
+  } = e;
+  return [
+    {
+      [n]: {
+        // ==================== BorderLess ====================
+        [`&-borderless ${n}-selector`]: {
+          backgroundColor: "transparent !important",
+          borderColor: "transparent !important",
+          boxShadow: "none !important"
+        },
+        // ==================== In Form ====================
+        [`&${n}-in-form-item`]: {
+          width: "100%"
+        }
+      }
+    },
+    // =====================================================
+    // ==                       LTR                       ==
+    // =====================================================
+    // Base
+    ml(e),
+    // Single
+    dl(e),
+    // Multiple
+    cl(e),
+    // Dropdown
+    sl(e),
+    // =====================================================
+    // ==                       RTL                       ==
+    // =====================================================
+    {
+      [`${n}-rtl`]: {
+        direction: "rtl"
+      }
+    },
+    // =====================================================
+    // ==                     Status                      ==
+    // =====================================================
+    Ye(n, he(e, {
+      borderHoverColor: e.colorPrimaryHover,
+      outlineColor: e.controlOutline
+    })),
+    Ye(`${n}-status-error`, he(e, {
+      borderHoverColor: e.colorErrorHover,
+      outlineColor: e.colorErrorOutline
+    }), !0),
+    Ye(`${n}-status-warning`, he(e, {
+      borderHoverColor: e.colorWarningHover,
+      outlineColor: e.colorWarningOutline
+    }), !0),
+    // =====================================================
+    // ==             Space Compact                       ==
+    // =====================================================
+    Kn(e, {
+      borderElCls: `${n}-selector`,
+      focusElCls: `${n}-focused`
+    })
+  ];
+}, gl = Wn("Select", (e, n) => {
+  let {
+    rootPrefixCls: o
+  } = n;
+  const t = he(e, {
+    rootPrefixCls: o,
+    inputPaddingHorizontalBase: e.paddingSM - 1
+  });
+  return [vl(t)];
+}, (e) => ({
+  zIndexPopup: e.zIndexPopupBase + 50
+})), hl = () => b(b({}, Ae(Jt(), ["inputIcon", "mode", "getInputElement", "getRawInputElement", "backfill"])), {
+  value: Pt([Array, Object, String, Number]),
+  defaultValue: Pt([Array, Object, String, Number]),
+  notFoundContent: $.any,
+  suffixIcon: $.any,
+  itemIcon: $.any,
+  size: Pe(),
+  mode: Pe(),
+  bordered: eo(!0),
+  transitionName: String,
+  choiceTransitionName: Pe(""),
+  popupClassName: String,
+  /** @deprecated Please use `popupClassName` instead */
+  dropdownClassName: String,
+  placement: Pe(),
+  status: Pe(),
+  "onUpdate:value": kn()
+}), At = "SECRET_COMBOBOX_MODE_DO_NOT_USE", fe = ue({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "ASelect",
+  Option: st,
+  OptGroup: ct,
+  inheritAttrs: !1,
+  props: nt(hl(), {
+    listHeight: 256,
+    listItemHeight: 24
+  }),
+  SECRET_COMBOBOX_MODE_DO_NOT_USE: At,
+  slots: Object,
+  setup(e, n) {
+    let {
+      attrs: o,
+      emit: t,
+      slots: l,
+      expose: a
+    } = n;
+    const c = ve(), s = jn(), m = Gn.useInject(), p = F(() => po(m.status, e.status)), u = () => {
+      var _;
+      (_ = c.value) === null || _ === void 0 || _.focus();
+    }, g = () => {
+      var _;
+      (_ = c.value) === null || _ === void 0 || _.blur();
+    }, N = (_) => {
+      var q;
+      (q = c.value) === null || q === void 0 || q.scrollTo(_);
+    }, D = F(() => {
+      const {
+        mode: _
+      } = e;
+      if (_ !== "combobox")
+        return _ === At ? "combobox" : _;
+    });
+    process.env.NODE_ENV !== "production" && Un(!e.dropdownClassName, "Select", "`dropdownClassName` is deprecated. Please use `popupClassName` instead.");
+    const {
+      prefixCls: v,
+      direction: h,
+      renderEmpty: y,
+      size: S,
+      getPrefixCls: V,
+      getPopupContainer: M,
+      disabled: O,
+      select: d
+    } = Xn("select", e), {
+      compactSize: P,
+      compactItemClassnames: x
+    } = Yn(v, h), R = F(() => P.value || S.value), A = Qn(), X = F(() => {
+      var _;
+      return (_ = O.value) !== null && _ !== void 0 ? _ : A.value;
+    }), [W, ee] = gl(v), Q = F(() => V()), U = F(() => e.placement !== void 0 ? e.placement : h.value === "rtl" ? "bottomRight" : "bottomLeft"), I = F(() => Zn(Q.value, qn(U.value), e.transitionName)), T = F(() => ce({
+      [`${v.value}-lg`]: R.value === "large",
+      [`${v.value}-sm`]: R.value === "small",
+      [`${v.value}-rtl`]: h.value === "rtl",
+      [`${v.value}-borderless`]: !e.bordered,
+      [`${v.value}-in-form-item`]: m.isFormItemInput
+    }, mo(v.value, p.value, m.hasFeedback), x.value, ee.value)), j = function() {
+      for (var _ = arguments.length, q = new Array(_), oe = 0; oe < _; oe++)
+        q[oe] = arguments[oe];
+      t("update:value", q[0]), t("change", ...q), s.onFieldChange();
+    }, Z = (_) => {
+      t("blur", _), s.onFieldBlur();
+    };
+    a({
+      blur: g,
+      focus: u,
+      scrollTo: N
+    });
+    const K = F(() => D.value === "multiple" || D.value === "tags"), ne = F(() => e.showArrow !== void 0 ? e.showArrow : e.loading || !(K.value || D.value === "combobox"));
+    return () => {
+      var _, q, oe, ie;
+      const {
+        notFoundContent: re,
+        listHeight: te = 256,
+        listItemHeight: de = 24,
+        popupClassName: se,
+        dropdownClassName: f,
+        virtual: i,
+        dropdownMatchSelectWidth: r,
+        id: E = s.id.value,
+        placeholder: w = (_ = l.placeholder) === null || _ === void 0 ? void 0 : _.call(l),
+        showArrow: B
+      } = e, {
+        hasFeedback: H,
+        feedbackIcon: G
+      } = m;
+      let k;
+      re !== void 0 ? k = re : l.notFoundContent ? k = l.notFoundContent() : D.value === "combobox" ? k = null : k = (y == null ? void 0 : y("Select")) || C(Jn, {
+        componentName: "Select"
+      }, null);
+      const {
+        suffixIcon: J,
+        itemIcon: le,
+        removeIcon: ae,
+        clearIcon: De
+      } = ul(b(b({}, e), {
+        multiple: K.value,
+        prefixCls: v.value,
+        hasFeedback: H,
+        feedbackIcon: G,
+        showArrow: ne.value
+      }), l), Ve = Ae(e, ["prefixCls", "suffixIcon", "itemIcon", "removeIcon", "clearIcon", "size", "bordered", "status"]), Oe = ce(se || f, {
+        [`${v.value}-dropdown-${h.value}`]: h.value === "rtl"
+      }, ee.value);
+      return W(C(al, L(L(L({
+        ref: c,
+        virtual: i,
+        dropdownMatchSelectWidth: r
+      }, Ve), o), {}, {
+        showSearch: (q = e.showSearch) !== null && q !== void 0 ? q : (oe = d == null ? void 0 : d.value) === null || oe === void 0 ? void 0 : oe.showSearch,
+        placeholder: w,
+        listHeight: te,
+        listItemHeight: de,
+        mode: D.value,
+        prefixCls: v.value,
+        direction: h.value,
+        inputIcon: J,
+        menuItemSelectedIcon: le,
+        removeIcon: ae,
+        clearIcon: De,
+        notFoundContent: k,
+        class: [T.value, o.class],
+        getPopupContainer: M == null ? void 0 : M.value,
+        dropdownClassName: Oe,
+        onChange: j,
+        onBlur: Z,
+        id: E,
+        dropdownRender: Ve.dropdownRender || l.dropdownRender,
+        transitionName: I.value,
+        children: (ie = l.default) === null || ie === void 0 ? void 0 : ie.call(l),
+        tagRender: e.tagRender || l.tagRender,
+        optionLabelRender: l.optionLabel,
+        maxTagPlaceholder: e.maxTagPlaceholder || l.maxTagPlaceholder,
+        showArrow: H || B,
+        disabled: X.value
+      }), {
+        option: l.option
+      }));
+    };
+  }
+});
+fe.install = function(e) {
+  return e.component(fe.name, fe), e.component(fe.Option.displayName, fe.Option), e.component(fe.OptGroup.displayName, fe.OptGroup), e;
+};
+const bl = fe.Option;
+fe.OptGroup;
+const yl = {
+  name: "ZSelect",
+  components: {
+    ASelect: fe,
+    ASelectOption: bl
+  }
+}, Sl = /* @__PURE__ */ Object.assign(yl, {
+  props: /* @__PURE__ */ En({
+    data: {
+      type: Array,
+      default: () => []
+    }
+  }, {
+    modelValue: {},
+    modelModifiers: {}
+  }),
+  emits: ["update:modelValue"],
+  setup(e) {
+    const n = Fn(e, "modelValue"), o = e;
+    return (t, l) => {
+      const a = Ct("a-select-option"), c = Ct("a-select");
+      return Ke(), It(c, Dn({
+        value: n.value,
+        "onUpdate:value": l[0] || (l[0] = (s) => n.value = s),
+        class: "z-select"
+      }, t.$attrs), {
+        default: xt(() => [
+          (Ke(!0), Vn(xe, null, Nn(o == null ? void 0 : o.data, (s) => (Ke(), It(a, {
+            key: s == null ? void 0 : s.value,
+            value: s.value
+          }, {
+            default: xt(() => [
+              Me(Rn(s.label), 1)
+            ]),
+            _: 2
+          }, 1032, ["value"]))), 128))
+        ]),
+        _: 1
+      }, 16, ["value"]);
+    };
+  }
+}), Ml = /* @__PURE__ */ to(Sl, [["__scopeId", "data-v-562fa124"]]);
+export {
+  Ml as default
+};