@duxweb/dvha-naiveui 1.0.11 → 1.0.12

package/dist/esm/node_modules/.pnpm/naive-ui@2.42.0_vue@3.5.17_typescript@5.8.3_/node_modules/naive-ui/es/cascader/src/Cascader.js

@@ -0,0 +1,878 @@
+import "../../../../../../vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import lt from "./CascaderMenu.js";
+import nt from "./CascaderSelectMenu.js";
+import { cascaderInjectionKey as ot } from "./interface.js";
+import at from "./styles/index.cssr.js";
+import { getRawNodePath as W, getPathLabel as be } from "./utils.js";
+import rt from "../../../../../../vueuc@0.4.64_vue@3.5.17_typescript@5.8.3_/node_modules/vueuc/es/binder/src/Binder.js";
+import it from "../../_internal/selection/src/Selection.js";
+import ut from "../../_mixins/use-config.js";
+import Me from "../../_mixins/use-theme.js";
+import dt from "../../_mixins/use-locale.js";
+import we from "../../../../../../vooks@0.2.12_vue@3.5.17_typescript@5.8.3_/node_modules/vooks/es/use-merged-state.js";
+import st from "../../_mixins/use-form-item.js";
+import ct from "../../../../../../vooks@0.2.12_vue@3.5.17_typescript@5.8.3_/node_modules/vooks/es/life-cycle/use-is-mounted.js";
+import { useThemeClass as ft } from "../../_mixins/use-css-vars-class.js";
+import { happensIn as Se } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/dom/happens-in.js";
+import { markEventEffectPerformed as vt } from "../../_utils/event/index.js";
+import { call as N } from "../../_utils/vue/call.js";
+import { SubtreeNotLoadedError as ht } from "../../../../../../treemate@0.3.11/node_modules/treemate/es/check.js";
+import { depx as q } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/css/index.js";
+import { warnOnce as Re } from "../../_utils/naive/warn.js";
+import mt from "../styles/light.js";
+import { createTreeMate as gt } from "../../../../../../treemate@0.3.11/node_modules/treemate/es/create.js";
+import { changeColor as yt } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/color/index.js";
+import { getPreciseEventTarget as pt } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/dom/get-precise-event-target.js";
+import { defineComponent as bt, h as M, watchEffect as wt, computed as c, watch as Ce, provide as St, nextTick as Rt } from "../../../../../../@vue_runtime-core@3.5.17/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+import Ct from "../../../../../../vueuc@0.4.64_vue@3.5.17_typescript@5.8.3_/node_modules/vueuc/es/binder/src/Target.js";
+import ke from "../../../../../../vueuc@0.4.64_vue@3.5.17_typescript@5.8.3_/node_modules/vueuc/es/binder/src/Follower.js";
+import { useAdjustedTo as G } from "../../_utils/composable/use-adjusted-to.js";
+import { ref as m, isReactive as kt, toRef as g } from "../../../../../../@vue_reactivity@3.5.17/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js";
+const Mt = Object.assign(Object.assign({}, Me.props), {
+  allowCheckingNotLoaded: Boolean,
+  to: G.propTo,
+  bordered: {
+    type: Boolean,
+    default: void 0
+  },
+  options: {
+    type: Array,
+    default: () => []
+  },
+  value: [String, Number, Array],
+  defaultValue: {
+    type: [String, Number, Array],
+    default: null
+  },
+  placeholder: String,
+  multiple: Boolean,
+  size: String,
+  filterable: Boolean,
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  disabledField: {
+    type: String,
+    default: "disabled"
+  },
+  expandTrigger: {
+    type: String,
+    default: "click"
+  },
+  clearable: Boolean,
+  clearFilterAfterSelect: {
+    type: Boolean,
+    default: !0
+  },
+  remote: Boolean,
+  onLoad: Function,
+  separator: {
+    type: String,
+    default: " / "
+  },
+  filter: Function,
+  placement: {
+    type: String,
+    default: "bottom-start"
+  },
+  cascade: {
+    type: Boolean,
+    default: !0
+  },
+  leafOnly: Boolean,
+  showPath: {
+    type: Boolean,
+    default: !0
+  },
+  show: {
+    type: Boolean,
+    default: void 0
+  },
+  maxTagCount: [String, Number],
+  ellipsisTagPopoverProps: Object,
+  menuProps: Object,
+  filterMenuProps: Object,
+  virtualScroll: {
+    type: Boolean,
+    default: !0
+  },
+  checkStrategy: {
+    type: String,
+    default: "all"
+  },
+  valueField: {
+    type: String,
+    default: "value"
+  },
+  labelField: {
+    type: String,
+    default: "label"
+  },
+  childrenField: {
+    type: String,
+    default: "children"
+  },
+  renderLabel: Function,
+  status: String,
+  "onUpdate:value": [Function, Array],
+  onUpdateValue: [Function, Array],
+  "onUpdate:show": [Function, Array],
+  onUpdateShow: [Function, Array],
+  onBlur: Function,
+  onFocus: Function,
+  getColumnStyle: Function,
+  renderPrefix: Function,
+  renderSuffix: Function,
+  // deprecated
+  onChange: [Function, Array]
+}), ll = bt({
+  name: "Cascader",
+  props: Mt,
+  slots: Object,
+  setup(l, {
+    slots: v
+  }) {
+    process.env.NODE_ENV !== "production" && wt(() => {
+      l.leafOnly && Re("cascader", '`leaf-only` is deprecated, please use `check-strategy="child"` instead'), l.onChange !== void 0 && Re("cascader", "`on-change` is deprecated, please use `on-update:value` instead.");
+    });
+    const {
+      mergedBorderedRef: s,
+      mergedClsPrefixRef: p,
+      namespaceRef: b,
+      inlineThemeDisabled: te
+    } = ut(l), j = Me("Cascader", "-cascader", at, mt, l, p), {
+      localeRef: le
+    } = dt("Cascader"), ne = m(l.defaultValue), Fe = c(() => l.value), C = we(Fe, ne), P = c(() => l.leafOnly ? "child" : l.checkStrategy), K = m(""), z = st(l), {
+      mergedSizeRef: Te,
+      mergedDisabledRef: oe,
+      mergedStatusRef: Ne
+    } = z, w = m(null), A = m(null), k = m(null), S = m(null), y = m(null), L = m(/* @__PURE__ */ new Set()), ae = m(null), re = m(null), Pe = G(l), D = m(!1), ie = (e) => {
+      L.value.add(e);
+    }, J = (e) => {
+      L.value.delete(e);
+    }, h = c(() => {
+      const {
+        valueField: e,
+        childrenField: t,
+        disabledField: n
+      } = l;
+      return gt(l.options, {
+        getDisabled(r) {
+          return r[n];
+        },
+        getKey(r) {
+          return r[e];
+        },
+        getChildren(r) {
+          return r[t];
+        }
+      });
+    }), U = c(() => {
+      const {
+        cascade: e,
+        multiple: t
+      } = l;
+      return t && Array.isArray(C.value) ? h.value.getCheckedKeys(C.value, {
+        cascade: e,
+        allowNotLoaded: l.allowCheckingNotLoaded
+      }) : {
+        checkedKeys: [],
+        indeterminateKeys: []
+      };
+    }), E = c(() => U.value.checkedKeys), Q = c(() => U.value.indeterminateKeys), Ke = c(() => {
+      const {
+        treeNodePath: e,
+        treeNode: t
+      } = h.value.getPath(y.value);
+      let n;
+      return t === null ? n = [h.value.treeNodes] : (n = e.map((r) => r.siblings), !t.isLeaf && !L.value.has(t.key) && t.children && n.push(t.children)), n;
+    }), xe = c(() => {
+      const {
+        keyPath: e
+      } = h.value.getPath(y.value);
+      return e;
+    }), x = c(() => j.value.self.optionHeight);
+    kt(l.options) && Ce(l.options, (e, t) => {
+      e !== t && (y.value = null, S.value = null);
+    });
+    const ue = m(!1);
+    function de(e) {
+      const {
+        onUpdateShow: t,
+        "onUpdate:show": n
+      } = l;
+      t && N(t, e), n && N(n, e), ue.value = e;
+    }
+    function F(e, t, n) {
+      const {
+        onUpdateValue: r,
+        "onUpdate:value": o,
+        onChange: u
+      } = l, {
+        nTriggerFormInput: a,
+        nTriggerFormChange: d
+      } = z;
+      r && N(r, e, t, n), o && N(o, e, t, n), u && N(u, e, t, n), ne.value = e, a(), d();
+    }
+    function O(e) {
+      S.value = e;
+    }
+    function I(e) {
+      y.value = e;
+    }
+    function X(e) {
+      const {
+        value: {
+          getNode: t
+        }
+      } = h;
+      return e.map((n) => {
+        var r;
+        return ((r = t(n)) === null || r === void 0 ? void 0 : r.rawNode) || null;
+      });
+    }
+    function se(e) {
+      var t;
+      const {
+        cascade: n,
+        multiple: r,
+        filterable: o
+      } = l, {
+        value: {
+          check: u,
+          getNode: a,
+          getPath: d
+        }
+      } = h;
+      if (r)
+        try {
+          const {
+            checkedKeys: i
+          } = u(e, U.value.checkedKeys, {
+            cascade: n,
+            checkStrategy: P.value,
+            allowNotLoaded: l.allowCheckingNotLoaded
+          });
+          F(i, X(i), i.map((B) => {
+            var V;
+            return W((V = d(B)) === null || V === void 0 ? void 0 : V.treeNodePath);
+          })), o && Z(), S.value = e, y.value = e;
+        } catch (i) {
+          if (i instanceof ht) {
+            if (w.value) {
+              const B = a(e);
+              B !== null && w.value.showErrorMessage(B.rawNode[l.labelField]);
+            }
+          } else
+            throw i;
+        }
+      else if (P.value === "child") {
+        const i = a(e);
+        if (i != null && i.isLeaf)
+          F(e, i.rawNode, W(d(e).treeNodePath));
+        else
+          return !1;
+      } else {
+        const i = a(e);
+        F(e, (i == null ? void 0 : i.rawNode) || null, W((t = d(e)) === null || t === void 0 ? void 0 : t.treeNodePath));
+      }
+      return !0;
+    }
+    function Y(e) {
+      const {
+        cascade: t,
+        multiple: n
+      } = l;
+      if (n) {
+        const {
+          value: {
+            uncheck: r,
+            getNode: o,
+            getPath: u
+          }
+        } = h, {
+          checkedKeys: a
+        } = r(e, U.value.checkedKeys, {
+          cascade: t,
+          checkStrategy: P.value,
+          allowNotLoaded: l.allowCheckingNotLoaded
+        });
+        F(a, a.map((d) => {
+          var i;
+          return ((i = o(d)) === null || i === void 0 ? void 0 : i.rawNode) || null;
+        }), a.map((d) => {
+          var i;
+          return W((i = u(d)) === null || i === void 0 ? void 0 : i.treeNodePath);
+        })), S.value = e, y.value = e;
+      }
+    }
+    const Oe = c(() => {
+      if (l.multiple) {
+        const {
+          showPath: e,
+          separator: t,
+          labelField: n,
+          cascade: r
+        } = l, {
+          getCheckedKeys: o,
+          getNode: u
+        } = h.value;
+        return o(E.value, {
+          cascade: r,
+          checkStrategy: P.value,
+          allowNotLoaded: l.allowCheckingNotLoaded
+        }).checkedKeys.map((d) => {
+          const i = u(d);
+          return i === null ? {
+            label: String(d),
+            value: d
+          } : {
+            label: e ? be(i, t, n) : i.rawNode[n],
+            value: i.key
+          };
+        });
+      } else
+        return [];
+    }), _e = c(() => {
+      const {
+        multiple: e,
+        showPath: t,
+        separator: n,
+        labelField: r
+      } = l, {
+        value: o
+      } = C;
+      if (!e && !Array.isArray(o)) {
+        const {
+          getNode: u
+        } = h.value;
+        if (o === null)
+          return null;
+        const a = u(o);
+        return a === null ? {
+          label: String(o),
+          value: o
+        } : {
+          label: t ? be(a, n, r) : a.rawNode[r],
+          value: a.key
+        };
+      } else
+        return null;
+    }), Be = g(l, "show"), f = we(Be, ue), Ae = c(() => {
+      const {
+        placeholder: e
+      } = l;
+      return e !== void 0 ? e : le.value.placeholder;
+    }), R = c(() => !!(l.filterable && K.value));
+    Ce(f, (e) => {
+      if (!e || l.multiple) return;
+      const {
+        value: t
+      } = C;
+      !Array.isArray(t) && t !== null ? (S.value = t, y.value = t, Rt(() => {
+        var n;
+        if (!f.value) return;
+        const {
+          value: r
+        } = y;
+        if (C.value !== null) {
+          const o = h.value.getNode(r);
+          o && ((n = w.value) === null || n === void 0 || n.scroll(o.level, o.index, q(x.value)));
+        }
+      })) : (S.value = null, y.value = null);
+    }, {
+      immediate: !0
+    });
+    function ce(e) {
+      const {
+        onBlur: t
+      } = l, {
+        nTriggerFormBlur: n
+      } = z;
+      t && N(t, e), n();
+    }
+    function fe(e) {
+      const {
+        onFocus: t
+      } = l, {
+        nTriggerFormFocus: n
+      } = z;
+      t && N(t, e), n();
+    }
+    function Z() {
+      var e;
+      (e = k.value) === null || e === void 0 || e.focusInput();
+    }
+    function Le() {
+      var e;
+      (e = k.value) === null || e === void 0 || e.focus();
+    }
+    function $() {
+      oe.value || (K.value = "", de(!0), l.filterable && Z());
+    }
+    function T(e = !1) {
+      e && Le(), de(!1), K.value = "";
+    }
+    function ve(e) {
+      var t;
+      R.value || f.value && (!((t = k.value) === null || t === void 0) && t.$el.contains(pt(e)) || T());
+    }
+    function De(e) {
+      R.value && ve(e);
+    }
+    function he() {
+      l.clearFilterAfterSelect && (K.value = "");
+    }
+    function H(e) {
+      var t, n, r;
+      const {
+        value: o
+      } = S, {
+        value: u
+      } = h;
+      switch (e) {
+        case "prev":
+          if (o !== null) {
+            const a = u.getPrev(o, {
+              loop: !0
+            });
+            a !== null && (O(a.key), (t = w.value) === null || t === void 0 || t.scroll(a.level, a.index, q(x.value)));
+          }
+          break;
+        case "next":
+          if (o === null) {
+            const a = u.getFirstAvailableNode();
+            a !== null && (O(a.key), (n = w.value) === null || n === void 0 || n.scroll(a.level, a.index, q(x.value)));
+          } else {
+            const a = u.getNext(o, {
+              loop: !0
+            });
+            a !== null && (O(a.key), (r = w.value) === null || r === void 0 || r.scroll(a.level, a.index, q(x.value)));
+          }
+          break;
+        case "child":
+          if (o !== null) {
+            const a = u.getNode(o);
+            if (a !== null)
+              if (a.shallowLoaded) {
+                const d = u.getChild(o);
+                d !== null && (I(o), O(d.key));
+              } else {
+                const {
+                  value: d
+                } = L;
+                if (!d.has(o)) {
+                  ie(o), I(o);
+                  const {
+                    onLoad: i
+                  } = l;
+                  i && i(a.rawNode).then(() => {
+                    J(o);
+                  }).catch(() => {
+                    J(o);
+                  });
+                }
+              }
+          }
+          break;
+        case "parent":
+          if (o !== null) {
+            const a = u.getParent(o);
+            if (a !== null) {
+              O(a.key);
+              const d = a.getParent();
+              I(d === null ? null : d.key);
+            }
+          }
+          break;
+      }
+    }
+    function me(e) {
+      var t, n;
+      switch (e.key) {
+        case " ":
+        case "ArrowDown":
+        case "ArrowUp":
+          if (l.filterable && f.value)
+            break;
+          e.preventDefault();
+          break;
+      }
+      if (!Se(e, "action"))
+        switch (e.key) {
+          case " ":
+            if (l.filterable) return;
+          // eslint-disable-next-line no-fallthrough
+          case "Enter":
+            if (!f.value)
+              $();
+            else {
+              const {
+                value: r
+              } = R, {
+                value: o
+              } = S;
+              if (r)
+                A.value && A.value.enter() && he();
+              else if (o !== null)
+                if (E.value.includes(o) || Q.value.includes(o))
+                  Y(o);
+                else {
+                  const u = se(o);
+                  !l.multiple && u && T(!0);
+                }
+            }
+            break;
+          case "ArrowUp":
+            e.preventDefault(), f.value && (R.value ? (t = A.value) === null || t === void 0 || t.prev() : H("prev"));
+            break;
+          case "ArrowDown":
+            e.preventDefault(), f.value ? R.value ? (n = A.value) === null || n === void 0 || n.next() : H("next") : $();
+            break;
+          case "ArrowLeft":
+            e.preventDefault(), f.value && !R.value && H("parent");
+            break;
+          case "ArrowRight":
+            e.preventDefault(), f.value && !R.value && H("child");
+            break;
+          case "Escape":
+            f.value && (vt(e), T(!0));
+        }
+    }
+    function Ie(e) {
+      me(e);
+    }
+    function Ve(e) {
+      e.stopPropagation(), l.multiple ? F([], [], []) : F(null, null, null);
+    }
+    function je(e) {
+      var t;
+      !((t = w.value) === null || t === void 0) && t.$el.contains(e.relatedTarget) || (D.value = !0, fe(e));
+    }
+    function ze(e) {
+      var t;
+      !((t = w.value) === null || t === void 0) && t.$el.contains(e.relatedTarget) || (D.value = !1, ce(e), T());
+    }
+    function Ue(e) {
+      var t;
+      !((t = k.value) === null || t === void 0) && t.$el.contains(e.relatedTarget) || (D.value = !0, fe(e));
+    }
+    function Ee(e) {
+      var t;
+      !((t = k.value) === null || t === void 0) && t.$el.contains(e.relatedTarget) || (D.value = !1, ce(e));
+    }
+    function $e(e) {
+      Se(e, "action") || l.multiple && l.filter && (e.preventDefault(), Z());
+    }
+    function He() {
+      T(!0);
+    }
+    function We() {
+      l.filterable ? $() : f.value ? T(!0) : $();
+    }
+    function qe(e) {
+      K.value = e.target.value;
+    }
+    function Ge(e) {
+      const {
+        multiple: t
+      } = l, {
+        value: n
+      } = C;
+      t && Array.isArray(n) && e.value !== void 0 ? Y(e.value) : F(null, null, null);
+    }
+    function ge() {
+      var e;
+      (e = ae.value) === null || e === void 0 || e.syncPosition();
+    }
+    function ye() {
+      var e;
+      (e = re.value) === null || e === void 0 || e.syncPosition();
+    }
+    function Je() {
+      f.value && (R.value ? ge() : ye());
+    }
+    const ee = c(() => !!(l.multiple && l.cascade || P.value !== "child"));
+    St(ot, {
+      slots: v,
+      mergedClsPrefixRef: p,
+      mergedThemeRef: j,
+      mergedValueRef: C,
+      checkedKeysRef: E,
+      indeterminateKeysRef: Q,
+      hoverKeyPathRef: xe,
+      mergedCheckStrategyRef: P,
+      showCheckboxRef: ee,
+      cascadeRef: g(l, "cascade"),
+      multipleRef: g(l, "multiple"),
+      keyboardKeyRef: S,
+      hoverKeyRef: y,
+      remoteRef: g(l, "remote"),
+      loadingKeySetRef: L,
+      expandTriggerRef: g(l, "expandTrigger"),
+      isMountedRef: ct(),
+      onLoadRef: g(l, "onLoad"),
+      virtualScrollRef: g(l, "virtualScroll"),
+      optionHeightRef: x,
+      localeRef: le,
+      labelFieldRef: g(l, "labelField"),
+      renderLabelRef: g(l, "renderLabel"),
+      getColumnStyleRef: g(l, "getColumnStyle"),
+      renderPrefixRef: g(l, "renderPrefix"),
+      renderSuffixRef: g(l, "renderSuffix"),
+      syncCascaderMenuPosition: ye,
+      syncSelectMenuPosition: ge,
+      updateKeyboardKey: O,
+      updateHoverKey: I,
+      addLoadingKey: ie,
+      deleteLoadingKey: J,
+      doCheck: se,
+      doUncheck: Y,
+      closeMenu: T,
+      handleSelectMenuClickOutside: De,
+      handleCascaderMenuClickOutside: ve,
+      clearPattern: he
+    });
+    const Qe = {
+      focus: () => {
+        var e;
+        (e = k.value) === null || e === void 0 || e.focus();
+      },
+      blur: () => {
+        var e;
+        (e = k.value) === null || e === void 0 || e.blur();
+      },
+      getCheckedData: () => {
+        if (ee.value) {
+          const e = E.value;
+          return {
+            keys: e,
+            options: X(e)
+          };
+        }
+        return {
+          keys: [],
+          options: []
+        };
+      },
+      getIndeterminateData: () => {
+        if (ee.value) {
+          const e = Q.value;
+          return {
+            keys: e,
+            options: X(e)
+          };
+        }
+        return {
+          keys: [],
+          options: []
+        };
+      }
+    }, pe = c(() => {
+      const {
+        self: {
+          optionArrowColor: e,
+          optionTextColor: t,
+          optionTextColorActive: n,
+          optionTextColorDisabled: r,
+          optionCheckMarkColor: o,
+          menuColor: u,
+          menuBoxShadow: a,
+          menuDividerColor: d,
+          menuBorderRadius: i,
+          menuHeight: B,
+          optionColorHover: V,
+          optionHeight: Xe,
+          optionFontSize: Ye,
+          loadingColor: Ze,
+          columnWidth: et
+        },
+        common: {
+          cubicBezierEaseInOut: tt
+        }
+      } = j.value;
+      return {
+        "--n-bezier": tt,
+        "--n-menu-border-radius": i,
+        "--n-menu-box-shadow": a,
+        "--n-menu-height": B,
+        "--n-column-width": et,
+        "--n-menu-color": u,
+        "--n-menu-divider-color": d,
+        "--n-option-height": Xe,
+        "--n-option-font-size": Ye,
+        "--n-option-text-color": t,
+        "--n-option-text-color-disabled": r,
+        "--n-option-text-color-active": n,
+        "--n-option-color-hover": V,
+        "--n-option-check-mark-color": o,
+        "--n-option-arrow-color": e,
+        "--n-menu-mask-color": yt(u, {
+          alpha: 0.75
+        }),
+        "--n-loading-color": Ze
+      };
+    }), _ = te ? ft("cascader", void 0, pe, l) : void 0;
+    return Object.assign(Object.assign({}, Qe), {
+      handleTriggerResize: Je,
+      mergedStatus: Ne,
+      selectMenuFollowerRef: ae,
+      cascaderMenuFollowerRef: re,
+      triggerInstRef: k,
+      selectMenuInstRef: A,
+      cascaderMenuInstRef: w,
+      mergedBordered: s,
+      mergedClsPrefix: p,
+      namespace: b,
+      mergedValue: C,
+      mergedShow: f,
+      showSelectMenu: R,
+      pattern: K,
+      treeMate: h,
+      mergedSize: Te,
+      mergedDisabled: oe,
+      localizedPlaceholder: Ae,
+      selectedOption: _e,
+      selectedOptions: Oe,
+      adjustedTo: Pe,
+      menuModel: Ke,
+      handleMenuTabout: He,
+      handleMenuFocus: Ue,
+      handleMenuBlur: Ee,
+      handleMenuKeydown: Ie,
+      handleMenuMousedown: $e,
+      handleTriggerFocus: je,
+      handleTriggerBlur: ze,
+      handleTriggerClick: We,
+      handleClear: Ve,
+      handleDeleteOption: Ge,
+      handlePatternInput: qe,
+      handleKeydown: me,
+      focused: D,
+      optionHeight: x,
+      mergedTheme: j,
+      cssVars: te ? void 0 : pe,
+      themeClass: _ == null ? void 0 : _.themeClass,
+      onRender: _ == null ? void 0 : _.onRender
+    });
+  },
+  render() {
+    const {
+      mergedClsPrefix: l
+    } = this;
+    return M("div", {
+      class: `${l}-cascader`
+    }, M(rt, null, {
+      default: () => [M(Ct, null, {
+        default: () => M(it, {
+          onResize: this.handleTriggerResize,
+          ref: "triggerInstRef",
+          status: this.mergedStatus,
+          clsPrefix: l,
+          maxTagCount: this.maxTagCount,
+          ellipsisTagPopoverProps: this.ellipsisTagPopoverProps,
+          bordered: this.mergedBordered,
+          size: this.mergedSize,
+          theme: this.mergedTheme.peers.InternalSelection,
+          themeOverrides: this.mergedTheme.peerOverrides.InternalSelection,
+          active: this.mergedShow,
+          pattern: this.pattern,
+          placeholder: this.localizedPlaceholder,
+          selectedOption: this.selectedOption,
+          selectedOptions: this.selectedOptions,
+          multiple: this.multiple,
+          filterable: this.filterable,
+          clearable: this.clearable,
+          disabled: this.mergedDisabled,
+          focused: this.focused,
+          onFocus: this.handleTriggerFocus,
+          onBlur: this.handleTriggerBlur,
+          onClick: this.handleTriggerClick,
+          onClear: this.handleClear,
+          onDeleteOption: this.handleDeleteOption,
+          onPatternInput: this.handlePatternInput,
+          onKeydown: this.handleKeydown
+        }, {
+          arrow: () => {
+            var v, s;
+            return (s = (v = this.$slots).arrow) === null || s === void 0 ? void 0 : s.call(v);
+          }
+        })
+      }), M(ke, {
+        key: "cascaderMenu",
+        ref: "cascaderMenuFollowerRef",
+        show: this.mergedShow && !this.showSelectMenu,
+        containerClass: this.namespace,
+        placement: this.placement,
+        width: this.options.length ? void 0 : "target",
+        teleportDisabled: this.adjustedTo === G.tdkey,
+        to: this.adjustedTo
+      }, {
+        default: () => {
+          var v;
+          (v = this.onRender) === null || v === void 0 || v.call(this);
+          const {
+            menuProps: s
+          } = this;
+          return M(lt, Object.assign({}, s, {
+            ref: "cascaderMenuInstRef",
+            class: [this.themeClass, s == null ? void 0 : s.class],
+            value: this.mergedValue,
+            show: this.mergedShow && !this.showSelectMenu,
+            menuModel: this.menuModel,
+            style: [this.cssVars, s == null ? void 0 : s.style],
+            onFocus: this.handleMenuFocus,
+            onBlur: this.handleMenuBlur,
+            onKeydown: this.handleMenuKeydown,
+            onMousedown: this.handleMenuMousedown,
+            onTabout: this.handleMenuTabout
+          }), {
+            action: () => {
+              var p, b;
+              return (b = (p = this.$slots).action) === null || b === void 0 ? void 0 : b.call(p);
+            },
+            empty: () => {
+              var p, b;
+              return (b = (p = this.$slots).empty) === null || b === void 0 ? void 0 : b.call(p);
+            }
+          });
+        }
+      }), M(ke, {
+        key: "selectMenu",
+        ref: "selectMenuFollowerRef",
+        show: this.mergedShow && this.showSelectMenu,
+        containerClass: this.namespace,
+        width: "target",
+        placement: this.placement,
+        to: this.adjustedTo,
+        teleportDisabled: this.adjustedTo === G.tdkey
+      }, {
+        default: () => {
+          var v;
+          (v = this.onRender) === null || v === void 0 || v.call(this);
+          const {
+            filterMenuProps: s
+          } = this;
+          return M(nt, Object.assign({}, s, {
+            ref: "selectMenuInstRef",
+            class: [this.themeClass, s == null ? void 0 : s.class],
+            value: this.mergedValue,
+            show: this.mergedShow && this.showSelectMenu,
+            pattern: this.pattern,
+            multiple: this.multiple,
+            tmNodes: this.treeMate.treeNodes,
+            filter: this.filter,
+            labelField: this.labelField,
+            separator: this.separator,
+            style: [this.cssVars, s == null ? void 0 : s.style]
+          }));
+        }
+      })]
+    }));
+  }
+});
+export {
+  Mt as cascaderProps,
+  ll as default
+};