@duxweb/dvha-naiveui 1.0.11 → 1.0.13

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

@@ -0,0 +1,726 @@
+import "../../../../../../vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import je, { treeSharedProps as ze, createTreeMateOptions as $e } from "../../tree/src/Tree.js";
+import { useMergedCheckStrategy as We } from "../../tree/src/utils.js";
+import { treeSelectInjectionKey as He } from "./interface.js";
+import qe from "./styles/index.cssr.js";
+import { treeOption2SelectOptionWithPath as te, treeOption2SelectOption as ne } from "./utils.js";
+import Ge from "../../../../../../vueuc@0.4.64_vue@3.5.17_typescript@5.8.3_/node_modules/vueuc/es/binder/src/Binder.js";
+import Je from "../../_internal/selection/src/Selection.js";
+import Qe from "../../../../../../vdirs@0.1.8_vue@3.5.17_typescript@5.8.3_/node_modules/vdirs/es/clickoutside.js";
+import { resolveWrappedSlot as le, resolveSlot as Xe } from "../../_utils/vue/resolve-slot.js";
+import Ye from "../../_internal/focus-detector/src/FocusDetector.js";
+import Ze from "../../_mixins/use-config.js";
+import et from "../../_mixins/use-locale.js";
+import tt from "../../_mixins/use-form-item.js";
+import L from "../../../../../../vooks@0.2.12_vue@3.5.17_typescript@5.8.3_/node_modules/vooks/es/use-merged-state.js";
+import re from "../../_mixins/use-theme.js";
+import { useThemeClass as nt } from "../../_mixins/use-css-vars-class.js";
+import lt from "../../../../../../vooks@0.2.12_vue@3.5.17_typescript@5.8.3_/node_modules/vooks/es/life-cycle/use-is-mounted.js";
+import at from "../../empty/src/Empty.js";
+import { call as y } from "../../_utils/vue/call.js";
+import { getPreciseEventTarget as rt } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/dom/get-precise-event-target.js";
+import { markEventEffectPerformed as ot } from "../../_utils/event/index.js";
+import { happensIn as ae } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/dom/happens-in.js";
+import { createTreeMate as it } from "../../../../../../treemate@0.3.11/node_modules/treemate/es/create.js";
+import { warnOnce as dt } from "../../_utils/naive/warn.js";
+import st from "../styles/light.js";
+import { defineComponent as ut, h as s, withDirectives as ct, watchEffect as ft, computed as u, provide as ht } from "../../../../../../@vue_runtime-core@3.5.17/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+import mt from "../../../../../../vueuc@0.4.64_vue@3.5.17_typescript@5.8.3_/node_modules/vueuc/es/binder/src/Target.js";
+import gt from "../../../../../../vueuc@0.4.64_vue@3.5.17_typescript@5.8.3_/node_modules/vueuc/es/binder/src/Follower.js";
+import { useAdjustedTo as D } from "../../_utils/composable/use-adjusted-to.js";
+import { Transition as vt } from "../../../../../../@vue_runtime-dom@3.5.17/node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js";
+import { ref as m, toRef as V } from "../../../../../../@vue_reactivity@3.5.17/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js";
+import { useOnResize as yt } from "../../_utils/composable/use-resize.js";
+const pt = Object.assign(Object.assign(Object.assign(Object.assign({}, re.props), {
+  bordered: {
+    type: Boolean,
+    default: !0
+  },
+  cascade: Boolean,
+  checkable: Boolean,
+  clearable: Boolean,
+  clearFilterAfterSelect: {
+    type: Boolean,
+    default: !0
+  },
+  consistentMenuWidth: {
+    type: Boolean,
+    default: !0
+  },
+  defaultShow: Boolean,
+  defaultValue: {
+    type: [String, Number, Array],
+    default: null
+  },
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  filterable: Boolean,
+  checkStrategy: {
+    type: String,
+    default: "all"
+  },
+  loading: Boolean,
+  maxTagCount: [String, Number],
+  multiple: Boolean,
+  showPath: Boolean,
+  separator: {
+    type: String,
+    default: " / "
+  },
+  options: {
+    type: Array,
+    default: () => []
+  },
+  placeholder: String,
+  placement: {
+    type: String,
+    default: "bottom-start"
+  },
+  show: {
+    type: Boolean,
+    default: void 0
+  },
+  size: String,
+  value: [String, Number, Array],
+  to: D.propTo,
+  menuProps: Object,
+  virtualScroll: {
+    type: Boolean,
+    default: !0
+  },
+  status: String,
+  renderTag: Function,
+  ellipsisTagPopoverProps: Object
+}), ze), {
+  renderLabel: Function,
+  renderPrefix: Function,
+  renderSuffix: Function,
+  nodeProps: Function,
+  watchProps: Array,
+  getChildren: Function,
+  onBlur: Function,
+  onFocus: Function,
+  onLoad: Function,
+  onUpdateShow: [Function, Array],
+  onUpdateValue: [Function, Array],
+  "onUpdate:value": [Function, Array],
+  "onUpdate:show": [Function, Array],
+  /**
+   * @deprecated
+   */
+  leafOnly: Boolean
+}), Yt = ut({
+  name: "TreeSelect",
+  props: pt,
+  slots: Object,
+  setup(t) {
+    process.env.NODE_ENV !== "production" && ft(() => {
+      t.leafOnly && dt("tree-select", '`leaf-only` is deprecated, please use `check-strategy="child"` instead.');
+    });
+    const K = m(null), d = m(null), g = m(null), i = m(null), {
+      mergedClsPrefixRef: x,
+      namespaceRef: A,
+      inlineThemeDisabled: f
+    } = Ze(t), {
+      localeRef: B
+    } = et("Select"), {
+      mergedSizeRef: p,
+      mergedDisabledRef: E,
+      mergedStatusRef: oe,
+      nTriggerFormBlur: ie,
+      nTriggerFormChange: de,
+      nTriggerFormFocus: se,
+      nTriggerFormInput: ue
+    } = tt(t), j = m(t.defaultValue), ce = V(t, "value"), b = L(ce, j), z = m(t.defaultShow), fe = V(t, "show"), S = L(fe, z), R = m(""), he = u(() => {
+      const {
+        filter: e
+      } = t;
+      if (e) return e;
+      const {
+        labelField: n
+      } = t;
+      return (a, l) => a.length ? l[n].toLowerCase().includes(a.toLowerCase()) : !0;
+    }), w = u(() => it(t.options, $e(t.keyField, t.childrenField, t.disabledField, void 0))), {
+      value: O
+    } = b, $ = m(t.checkable ? null : Array.isArray(O) && O.length ? O[O.length - 1] : null), I = u(() => t.multiple && t.cascade && t.checkable), W = m(t.defaultExpandAll ? void 0 : t.defaultExpandedKeys || t.expandedKeys), me = V(t, "expandedKeys"), ge = L(me, W), F = m(!1), ve = u(() => {
+      const {
+        placeholder: e
+      } = t;
+      return e !== void 0 ? e : B.value.placeholder;
+    }), H = u(() => {
+      const {
+        value: e
+      } = b;
+      return t.multiple ? Array.isArray(e) ? e : [] : e === null || Array.isArray(e) ? [] : [e];
+    }), ye = u(() => t.checkable ? [] : H.value), pe = u(() => {
+      const {
+        multiple: e,
+        showPath: n,
+        separator: a,
+        labelField: l
+      } = t;
+      if (e) return null;
+      const {
+        value: r
+      } = b;
+      if (!Array.isArray(r) && r !== null) {
+        const {
+          value: o
+        } = w, h = o.getNode(r);
+        if (h !== null)
+          return n ? te(h, o.getPath(r).treeNodePath, a, l) : ne(h, l);
+      }
+      return null;
+    }), be = u(() => {
+      const {
+        multiple: e,
+        showPath: n,
+        separator: a
+      } = t;
+      if (!e) return null;
+      const {
+        value: l
+      } = b;
+      if (Array.isArray(l)) {
+        const r = [], {
+          value: o
+        } = w, {
+          checkedKeys: h
+        } = o.getCheckedKeys(l, {
+          checkStrategy: t.checkStrategy,
+          cascade: I.value,
+          allowNotLoaded: t.allowCheckingNotLoaded
+        }), {
+          labelField: c
+        } = t;
+        return h.forEach((N) => {
+          const P = o.getNode(N);
+          P !== null && r.push(n ? te(P, o.getPath(N).treeNodePath, a, c) : ne(P, c));
+        }), r;
+      }
+      return [];
+    });
+    function M() {
+      var e;
+      (e = d.value) === null || e === void 0 || e.focus();
+    }
+    function q() {
+      var e;
+      (e = d.value) === null || e === void 0 || e.focusInput();
+    }
+    function G(e) {
+      const {
+        onUpdateShow: n,
+        "onUpdate:show": a
+      } = t;
+      n && y(n, e), a && y(a, e), z.value = e;
+    }
+    function k(e, n, a) {
+      const {
+        onUpdateValue: l,
+        "onUpdate:value": r
+      } = t;
+      l && y(l, e, n, a), r && y(r, e, n, a), j.value = e, ue(), de();
+    }
+    function Se(e, n) {
+      const {
+        onUpdateIndeterminateKeys: a,
+        "onUpdate:indeterminateKeys": l
+      } = t;
+      a && y(a, e, n), l && y(l, e, n);
+    }
+    function we(e, n, a) {
+      const {
+        onUpdateExpandedKeys: l,
+        "onUpdate:expandedKeys": r
+      } = t;
+      l && y(l, e, n, a), r && y(r, e, n, a), W.value = e;
+    }
+    function J(e) {
+      const {
+        onFocus: n
+      } = t;
+      n && n(e), se();
+    }
+    function Q(e) {
+      v();
+      const {
+        onBlur: n
+      } = t;
+      n && n(e), ie();
+    }
+    function v() {
+      G(!1);
+    }
+    function _() {
+      E.value || (R.value = "", G(!0), t.filterable && q());
+    }
+    function ke() {
+      R.value = "";
+    }
+    function Te(e) {
+      var n;
+      S.value && (!((n = d.value) === null || n === void 0) && n.$el.contains(rt(e)) || v());
+    }
+    function Ce() {
+      E.value || (S.value ? t.filterable || v() : _());
+    }
+    function T(e) {
+      const {
+        value: {
+          getNode: n
+        }
+      } = w;
+      return e.map((a) => {
+        var l;
+        return ((l = n(a)) === null || l === void 0 ? void 0 : l.rawNode) || null;
+      });
+    }
+    function Ke(e, n, a) {
+      const l = T(e), r = a.action === "check" ? "select" : "unselect", o = a.node;
+      t.multiple ? (k(e, l, {
+        node: o,
+        action: r
+      }), t.filterable && (q(), t.clearFilterAfterSelect && (R.value = ""))) : (e.length ? k(e[0], l[0] || null, {
+        node: o,
+        action: r
+      }) : k(null, null, {
+        node: o,
+        action: r
+      }), v(), M());
+    }
+    function Re(e) {
+      t.checkable && Se(e, T(e));
+    }
+    function Fe(e) {
+      var n;
+      !((n = i.value) === null || n === void 0) && n.contains(e.relatedTarget) || (F.value = !0, J(e));
+    }
+    function Pe(e) {
+      var n;
+      !((n = i.value) === null || n === void 0) && n.contains(e.relatedTarget) || (F.value = !1, Q(e));
+    }
+    function xe(e) {
+      var n, a, l;
+      !((n = i.value) === null || n === void 0) && n.contains(e.relatedTarget) || !((l = (a = d.value) === null || a === void 0 ? void 0 : a.$el) === null || l === void 0) && l.contains(e.relatedTarget) || (F.value = !0, J(e));
+    }
+    function Oe(e) {
+      var n, a, l;
+      !((n = i.value) === null || n === void 0) && n.contains(e.relatedTarget) || !((l = (a = d.value) === null || a === void 0 ? void 0 : a.$el) === null || l === void 0) && l.contains(e.relatedTarget) || (F.value = !1, Q(e));
+    }
+    function Ie(e) {
+      e.stopPropagation();
+      const {
+        multiple: n
+      } = t;
+      !n && t.filterable && v(), n ? k([], [], {
+        node: null,
+        action: "clear"
+      }) : k(null, null, {
+        node: null,
+        action: "clear"
+      });
+    }
+    function Me(e) {
+      const {
+        value: n
+      } = b;
+      if (Array.isArray(n)) {
+        const {
+          value: a
+        } = w, {
+          checkedKeys: l
+        } = a.getCheckedKeys(n, {
+          cascade: I.value,
+          allowNotLoaded: t.allowCheckingNotLoaded
+        }), r = l.findIndex((o) => o === e.value);
+        if (~r) {
+          const o = l[r], h = T([o])[0];
+          if (t.checkable) {
+            const {
+              checkedKeys: c
+            } = a.uncheck(e.value, l, {
+              checkStrategy: t.checkStrategy,
+              cascade: I.value,
+              allowNotLoaded: t.allowCheckingNotLoaded
+            });
+            k(c, T(c), {
+              node: h,
+              action: "delete"
+            });
+          } else {
+            const c = Array.from(l);
+            c.splice(r, 1), k(c, T(c), {
+              node: h,
+              action: "delete"
+            });
+          }
+        }
+      }
+    }
+    function Ne(e) {
+      const {
+        value: n
+      } = e.target;
+      R.value = n;
+    }
+    function X(e) {
+      const {
+        value: n
+      } = g;
+      return n ? n.handleKeydown(e) : {
+        enterBehavior: null
+      };
+    }
+    function Ae(e) {
+      if (e.key === "Enter") {
+        if (S.value) {
+          const {
+            enterBehavior: n
+          } = X(e);
+          if (!t.multiple)
+            switch (n) {
+              case "default":
+              case "toggleSelect":
+                v(), M();
+                break;
+            }
+        } else
+          _();
+        e.preventDefault();
+      } else e.key === "Escape" ? S.value && (ot(e), v(), M()) : S.value ? X(e) : e.key === "ArrowDown" && _();
+    }
+    function Be() {
+      v(), M();
+    }
+    function Ee(e) {
+      !ae(e, "action") && !ae(e, "header") && e.preventDefault();
+    }
+    const _e = u(() => {
+      const {
+        renderTag: e
+      } = t;
+      if (e)
+        return function({
+          option: a,
+          handleClose: l
+        }) {
+          const {
+            value: r
+          } = a;
+          if (r !== void 0) {
+            const o = w.value.getNode(r);
+            if (o)
+              return e({
+                option: o.rawNode,
+                handleClose: l
+              });
+          }
+          return r;
+        };
+    });
+    ht(He, {
+      pendingNodeKeyRef: $,
+      dataTreeMate: w
+    });
+    function Y() {
+      var e;
+      S.value && ((e = K.value) === null || e === void 0 || e.syncPosition());
+    }
+    yt(i, Y);
+    const Ue = We(t), Z = u(() => {
+      if (t.checkable) {
+        const e = b.value;
+        return t.multiple && Array.isArray(e) ? w.value.getCheckedKeys(e, {
+          cascade: t.cascade,
+          checkStrategy: Ue.value,
+          allowNotLoaded: t.allowCheckingNotLoaded
+        }) : {
+          checkedKeys: Array.isArray(e) || e === null ? [] : [e],
+          indeterminateKeys: []
+        };
+      }
+      return {
+        checkedKeys: [],
+        indeterminateKeys: []
+      };
+    }), Le = {
+      getCheckedData: () => {
+        const {
+          checkedKeys: e
+        } = Z.value;
+        return {
+          keys: e,
+          options: T(e)
+        };
+      },
+      getIndeterminateData: () => {
+        const {
+          indeterminateKeys: e
+        } = Z.value;
+        return {
+          keys: e,
+          options: T(e)
+        };
+      },
+      focus: () => {
+        var e;
+        return (e = d.value) === null || e === void 0 ? void 0 : e.focus();
+      },
+      focusInput: () => {
+        var e;
+        return (e = d.value) === null || e === void 0 ? void 0 : e.focusInput();
+      },
+      blur: () => {
+        var e;
+        return (e = d.value) === null || e === void 0 ? void 0 : e.blur();
+      },
+      blurInput: () => {
+        var e;
+        return (e = d.value) === null || e === void 0 ? void 0 : e.blurInput();
+      }
+    }, U = re("TreeSelect", "-tree-select", qe, st, t, x), ee = u(() => {
+      const {
+        common: {
+          cubicBezierEaseInOut: e
+        },
+        self: {
+          menuBoxShadow: n,
+          menuBorderRadius: a,
+          menuColor: l,
+          menuHeight: r,
+          actionPadding: o,
+          actionDividerColor: h,
+          actionTextColor: c,
+          headerDividerColor: N,
+          headerPadding: P,
+          headerTextColor: De
+        }
+      } = U.value;
+      return {
+        "--n-menu-box-shadow": n,
+        "--n-menu-border-radius": a,
+        "--n-menu-color": l,
+        "--n-menu-height": r,
+        "--n-bezier": e,
+        "--n-action-padding": o,
+        "--n-action-text-color": c,
+        "--n-action-divider-color": h,
+        "--n-header-padding": P,
+        "--n-header-text-color": De,
+        "--n-header-divider-color": N
+      };
+    }), C = f ? nt("tree-select", void 0, ee, t) : void 0, Ve = u(() => {
+      const {
+        self: {
+          menuPadding: e
+        }
+      } = U.value;
+      return e;
+    });
+    return Object.assign(Object.assign({}, Le), {
+      menuElRef: i,
+      mergedStatus: oe,
+      triggerInstRef: d,
+      followerInstRef: K,
+      treeInstRef: g,
+      mergedClsPrefix: x,
+      mergedValue: b,
+      mergedShow: S,
+      namespace: A,
+      adjustedTo: D(t),
+      isMounted: lt(),
+      focused: F,
+      menuPadding: Ve,
+      mergedPlaceholder: ve,
+      mergedExpandedKeys: ge,
+      treeSelectedKeys: ye,
+      treeCheckedKeys: H,
+      mergedSize: p,
+      mergedDisabled: E,
+      selectedOption: pe,
+      selectedOptions: be,
+      pattern: R,
+      pendingNodeKey: $,
+      mergedCascade: I,
+      mergedFilter: he,
+      selectionRenderTag: _e,
+      handleTriggerOrMenuResize: Y,
+      doUpdateExpandedKeys: we,
+      handleMenuLeave: ke,
+      handleTriggerClick: Ce,
+      handleMenuClickoutside: Te,
+      handleUpdateCheckedKeys: Ke,
+      handleUpdateIndeterminateKeys: Re,
+      handleTriggerFocus: Fe,
+      handleTriggerBlur: Pe,
+      handleMenuFocusin: xe,
+      handleMenuFocusout: Oe,
+      handleClear: Ie,
+      handleDeleteOption: Me,
+      handlePatternInput: Ne,
+      handleKeydown: Ae,
+      handleTabOut: Be,
+      handleMenuMousedown: Ee,
+      mergedTheme: U,
+      cssVars: f ? void 0 : ee,
+      themeClass: C == null ? void 0 : C.themeClass,
+      onRender: C == null ? void 0 : C.onRender
+    });
+  },
+  render() {
+    const {
+      mergedTheme: t,
+      mergedClsPrefix: K,
+      $slots: d
+    } = this;
+    return s("div", {
+      class: `${K}-tree-select`
+    }, s(Ge, null, {
+      default: () => [s(mt, null, {
+        default: () => s(Je, {
+          ref: "triggerInstRef",
+          onResize: this.handleTriggerOrMenuResize,
+          status: this.mergedStatus,
+          focused: this.focused,
+          clsPrefix: K,
+          theme: t.peers.InternalSelection,
+          themeOverrides: t.peerOverrides.InternalSelection,
+          ellipsisTagPopoverProps: this.ellipsisTagPopoverProps,
+          renderTag: this.selectionRenderTag,
+          selectedOption: this.selectedOption,
+          selectedOptions: this.selectedOptions,
+          size: this.mergedSize,
+          bordered: this.bordered,
+          placeholder: this.mergedPlaceholder,
+          disabled: this.mergedDisabled,
+          active: this.mergedShow,
+          loading: this.loading,
+          multiple: this.multiple,
+          maxTagCount: this.maxTagCount,
+          showArrow: !0,
+          filterable: this.filterable,
+          clearable: this.clearable,
+          pattern: this.pattern,
+          onPatternInput: this.handlePatternInput,
+          onClear: this.handleClear,
+          onClick: this.handleTriggerClick,
+          onFocus: this.handleTriggerFocus,
+          onBlur: this.handleTriggerBlur,
+          onDeleteOption: this.handleDeleteOption,
+          onKeydown: this.handleKeydown
+        }, {
+          arrow: () => {
+            var g, i;
+            return [(i = (g = this.$slots).arrow) === null || i === void 0 ? void 0 : i.call(g)];
+          }
+        })
+      }), s(gt, {
+        ref: "followerInstRef",
+        show: this.mergedShow,
+        placement: this.placement,
+        to: this.adjustedTo,
+        teleportDisabled: this.adjustedTo === D.tdkey,
+        containerClass: this.namespace,
+        width: this.consistentMenuWidth ? "target" : void 0,
+        minWidth: "target"
+      }, {
+        default: () => s(vt, {
+          name: "fade-in-scale-up-transition",
+          appear: this.isMounted,
+          onLeave: this.handleMenuLeave
+        }, {
+          default: () => {
+            var g;
+            if (!this.mergedShow) return null;
+            const {
+              mergedClsPrefix: i,
+              checkable: x,
+              multiple: A,
+              menuProps: f,
+              options: B
+            } = this;
+            return (g = this.onRender) === null || g === void 0 || g.call(this), ct(s("div", Object.assign({}, f, {
+              class: [`${i}-tree-select-menu`, f == null ? void 0 : f.class, this.themeClass],
+              ref: "menuElRef",
+              style: [(f == null ? void 0 : f.style) || "", this.cssVars],
+              tabindex: 0,
+              onMousedown: this.handleMenuMousedown,
+              onKeydown: this.handleKeydown,
+              onFocusin: this.handleMenuFocusin,
+              onFocusout: this.handleMenuFocusout
+            }), le(d.header, (p) => p ? s("div", {
+              class: `${i}-tree-select-menu__header`,
+              "data-header": !0
+            }, p) : null), s(je, {
+              ref: "treeInstRef",
+              blockLine: !0,
+              allowCheckingNotLoaded: this.allowCheckingNotLoaded,
+              showIrrelevantNodes: !1,
+              animated: !1,
+              pattern: this.pattern,
+              getChildren: this.getChildren,
+              filter: this.mergedFilter,
+              data: B,
+              cancelable: A,
+              labelField: this.labelField,
+              keyField: this.keyField,
+              disabledField: this.disabledField,
+              childrenField: this.childrenField,
+              theme: t.peers.Tree,
+              themeOverrides: t.peerOverrides.Tree,
+              defaultExpandAll: this.defaultExpandAll,
+              defaultExpandedKeys: this.defaultExpandedKeys,
+              indent: this.indent,
+              expandedKeys: this.mergedExpandedKeys,
+              checkedKeys: this.treeCheckedKeys,
+              selectedKeys: this.treeSelectedKeys,
+              checkable: x,
+              checkStrategy: this.checkStrategy,
+              cascade: this.mergedCascade,
+              leafOnly: this.leafOnly,
+              multiple: this.multiple,
+              renderLabel: this.renderLabel,
+              renderPrefix: this.renderPrefix,
+              renderSuffix: this.renderSuffix,
+              renderSwitcherIcon: this.renderSwitcherIcon,
+              nodeProps: this.nodeProps,
+              watchProps: this.watchProps,
+              virtualScroll: this.consistentMenuWidth && this.virtualScroll,
+              overrideDefaultNodeClickBehavior: this.overrideDefaultNodeClickBehavior,
+              internalTreeSelect: !0,
+              internalUnifySelectCheck: !0,
+              internalScrollable: !0,
+              internalScrollablePadding: this.menuPadding,
+              internalFocusable: !1,
+              internalCheckboxFocusable: !1,
+              internalRenderEmpty: () => s("div", {
+                class: `${i}-tree-select-menu__empty`
+              }, Xe(d.empty, () => [s(at, {
+                theme: t.peers.Empty,
+                themeOverrides: t.peerOverrides.Empty
+              })])),
+              onLoad: this.onLoad,
+              onUpdateCheckedKeys: this.handleUpdateCheckedKeys,
+              onUpdateIndeterminateKeys: this.handleUpdateIndeterminateKeys,
+              onUpdateExpandedKeys: this.doUpdateExpandedKeys
+            }), le(d.action, (p) => p ? s("div", {
+              class: `${i}-tree-select-menu__action`,
+              "data-action": !0
+            }, p) : null), s(Ye, {
+              onFocus: this.handleTabOut
+            })), [[Qe, this.handleMenuClickoutside, void 0, {
+              capture: !0
+            }]]);
+          }
+        })
+      })]
+    }));
+  }
+});
+export {
+  Yt as default,
+  pt as treeSelectProps
+};