@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/src/Tree.js

@@ -0,0 +1,1123 @@
+import "../../../../../../vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { treeSelectInjectionKey as Nn } from "../../tree-select/src/interface.js";
+import { defaultAllowDrop as Fn } from "./dnd.js";
+import { treeInjectionKey as Dn } from "./interface.js";
+import { useKeyboard as Tn } from "./keyboard.js";
+import En from "./MotionWrapper.js";
+import Ln from "./styles/index.cssr.js";
+import On from "./TreeNode.js";
+import { useMergedCheckStrategy as In, keysWithFilter as An, filterTree as Bn, isNodeDisabled as z } from "./utils.js";
+import { getMargin as Le, depx as oe, pxfy as Pn } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/css/index.js";
+import { XScrollbar as Me } from "../../_internal/scrollbar/src/Scrollbar.js";
+import { resolveSlot as je } from "../../_utils/vue/resolve-slot.js";
+import _n from "../../_mixins/use-config.js";
+import { useRtl as Un } from "../../_mixins/use-rtl.js";
+import Xe from "../../_mixins/use-theme.js";
+import me from "../../../../../../vooks@0.2.12_vue@3.5.17_typescript@5.8.3_/node_modules/vooks/es/use-merged-state.js";
+import { useThemeClass as pn } from "../../_mixins/use-css-vars-class.js";
+import $e from "../../empty/src/Empty.js";
+import Hn from "../../../../../../vueuc@0.4.64_vue@3.5.17_typescript@5.8.3_/node_modules/vueuc/es/virtual-list/src/VirtualList.js";
+import { flatten as ze } from "../../../../../../treemate@0.3.11/node_modules/treemate/es/flatten.js";
+import { call as v } from "../../_utils/vue/call.js";
+import { createDataKey as Mn } from "../../_utils/vue/create-data-key.js";
+import { createTreeMate as Ve } from "../../../../../../treemate@0.3.11/node_modules/treemate/es/create.js";
+import { warnOnce as jn, warn as $n } from "../../_utils/naive/warn.js";
+import zn from "../styles/light.js";
+import { createIndexGetter as Vn } from "../../../../../../treemate@0.3.11/node_modules/treemate/es/utils.js";
+import { defineComponent as Gn, h as I, watchEffect as le, computed as m, inject as Xn, watch as be, provide as Wn, nextTick as ke } from "../../../../../../@vue_runtime-core@3.5.17/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+import { ref as h, toRef as r } from "../../../../../../@vue_reactivity@3.5.17/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js";
+var Yn = function(n, x, R, f) {
+  function V(s) {
+    return s instanceof R ? s : new R(function(w) {
+      w(s);
+    });
+  }
+  return new (R || (R = Promise))(function(s, w) {
+    function A(b) {
+      try {
+        p(f.next(b));
+      } catch (E) {
+        w(E);
+      }
+    }
+    function F(b) {
+      try {
+        p(f.throw(b));
+      } catch (E) {
+        w(E);
+      }
+    }
+    function p(b) {
+      b.done ? s(b.value) : V(b.value).then(A, F);
+    }
+    p((f = f.apply(n, x || [])).next());
+  });
+};
+function Ge(n, x, R, f) {
+  return {
+    getIsGroup() {
+      return !1;
+    },
+    getKey(s) {
+      return s[n];
+    },
+    getChildren: f || ((s) => s[x]),
+    getDisabled(s) {
+      return !!(s[R] || s.checkboxDisabled);
+    }
+  };
+}
+const qn = {
+  allowCheckingNotLoaded: Boolean,
+  filter: Function,
+  defaultExpandAll: Boolean,
+  expandedKeys: Array,
+  keyField: {
+    type: String,
+    default: "key"
+  },
+  labelField: {
+    type: String,
+    default: "label"
+  },
+  childrenField: {
+    type: String,
+    default: "children"
+  },
+  disabledField: {
+    type: String,
+    default: "disabled"
+  },
+  defaultExpandedKeys: {
+    type: Array,
+    default: () => []
+  },
+  indent: {
+    type: Number,
+    default: 24
+  },
+  indeterminateKeys: Array,
+  renderSwitcherIcon: Function,
+  onUpdateIndeterminateKeys: [Function, Array],
+  "onUpdate:indeterminateKeys": [Function, Array],
+  onUpdateExpandedKeys: [Function, Array],
+  "onUpdate:expandedKeys": [Function, Array],
+  overrideDefaultNodeClickBehavior: Function
+}, Jn = Object.assign(Object.assign(Object.assign(Object.assign({}, Xe.props), {
+  accordion: Boolean,
+  showIrrelevantNodes: {
+    type: Boolean,
+    default: !0
+  },
+  data: {
+    type: Array,
+    default: () => []
+  },
+  expandOnDragenter: {
+    type: Boolean,
+    default: !0
+  },
+  expandOnClick: Boolean,
+  checkOnClick: {
+    type: [Boolean, Function],
+    default: !1
+  },
+  cancelable: {
+    type: Boolean,
+    default: !0
+  },
+  checkable: Boolean,
+  draggable: Boolean,
+  blockNode: Boolean,
+  blockLine: Boolean,
+  showLine: Boolean,
+  disabled: Boolean,
+  checkedKeys: Array,
+  defaultCheckedKeys: {
+    type: Array,
+    default: () => []
+  },
+  selectedKeys: Array,
+  defaultSelectedKeys: {
+    type: Array,
+    default: () => []
+  },
+  multiple: Boolean,
+  pattern: {
+    type: String,
+    default: ""
+  },
+  onLoad: Function,
+  cascade: Boolean,
+  selectable: {
+    type: Boolean,
+    default: !0
+  },
+  scrollbarProps: Object,
+  allowDrop: {
+    type: Function,
+    default: Fn
+  },
+  animated: {
+    type: Boolean,
+    default: !0
+  },
+  checkboxPlacement: {
+    type: String,
+    default: "left"
+  },
+  virtualScroll: Boolean,
+  watchProps: Array,
+  renderLabel: Function,
+  renderPrefix: Function,
+  renderSuffix: Function,
+  nodeProps: Function,
+  keyboard: {
+    type: Boolean,
+    default: !0
+  },
+  getChildren: Function,
+  onDragenter: [Function, Array],
+  onDragleave: [Function, Array],
+  onDragend: [Function, Array],
+  onDragstart: [Function, Array],
+  onDragover: [Function, Array],
+  onDrop: [Function, Array],
+  onUpdateCheckedKeys: [Function, Array],
+  "onUpdate:checkedKeys": [Function, Array],
+  onUpdateSelectedKeys: [Function, Array],
+  "onUpdate:selectedKeys": [Function, Array]
+}), qn), {
+  // internal props for tree-select
+  internalTreeSelect: Boolean,
+  internalScrollable: Boolean,
+  internalScrollablePadding: String,
+  // use it to display
+  internalRenderEmpty: Function,
+  internalHighlightKeySet: Object,
+  internalUnifySelectCheck: Boolean,
+  internalCheckboxFocusable: {
+    type: Boolean,
+    default: !0
+  },
+  internalFocusable: {
+    // Make tree-select take over keyboard operations
+    type: Boolean,
+    default: !0
+  },
+  checkStrategy: {
+    type: String,
+    default: "all"
+  },
+  /**
+   * @deprecated
+   */
+  leafOnly: Boolean
+}), Nt = Gn({
+  name: "Tree",
+  props: Jn,
+  slots: Object,
+  setup(n) {
+    process.env.NODE_ENV !== "production" && le(() => {
+      n.leafOnly && jn("tree", '`leaf-only` is deprecated, please use `check-strategy="child"` instead');
+    });
+    const {
+      mergedClsPrefixRef: x,
+      inlineThemeDisabled: R,
+      mergedRtlRef: f
+    } = _n(n), V = Un("Tree", f, x), s = Xe("Tree", "-tree", Ln, zn, n, x), w = h(null), A = h(null), F = h(null);
+    function p() {
+      var e;
+      return (e = F.value) === null || e === void 0 ? void 0 : e.listElRef;
+    }
+    function b() {
+      var e;
+      return (e = F.value) === null || e === void 0 ? void 0 : e.itemsElRef;
+    }
+    const E = m(() => {
+      const {
+        filter: e
+      } = n;
+      if (e) return e;
+      const {
+        labelField: t
+      } = n;
+      return (l, a) => {
+        if (!l.length) return !0;
+        const i = a[t];
+        return typeof i == "string" ? i.toLowerCase().includes(l.toLowerCase()) : !1;
+      };
+    }), H = m(() => {
+      const {
+        pattern: e
+      } = n;
+      return e ? !e.length || !E.value ? {
+        filteredTree: n.data,
+        highlightKeySet: null,
+        expandedKeys: void 0
+      } : Bn(n.data, E.value, e, n.keyField, n.childrenField) : {
+        filteredTree: n.data,
+        highlightKeySet: null,
+        expandedKeys: void 0
+      };
+    }), B = m(() => Ve(n.showIrrelevantNodes ? n.data : H.value.filteredTree, Ge(n.keyField, n.childrenField, n.disabledField, n.getChildren))), L = Xn(Nn, null), P = n.internalTreeSelect ? L.dataTreeMate : m(() => n.showIrrelevantNodes ? B.value : Ve(n.data, Ge(n.keyField, n.childrenField, n.disabledField, n.getChildren))), {
+      watchProps: y
+    } = n, _ = h([]);
+    y != null && y.includes("defaultCheckedKeys") ? le(() => {
+      _.value = n.defaultCheckedKeys;
+    }) : _.value = n.defaultCheckedKeys;
+    const Ke = r(n, "checkedKeys"), k = me(Ke, _), M = m(() => P.value.getCheckedKeys(k.value, {
+      cascade: n.cascade,
+      allowNotLoaded: n.allowCheckingNotLoaded
+    })), j = In(n), G = m(() => M.value.checkedKeys), Se = m(() => {
+      const {
+        indeterminateKeys: e
+      } = n;
+      return e !== void 0 ? e : M.value.indeterminateKeys;
+    }), re = h([]);
+    y != null && y.includes("defaultSelectedKeys") ? le(() => {
+      re.value = n.defaultSelectedKeys;
+    }) : re.value = n.defaultSelectedKeys;
+    const We = r(n, "selectedKeys"), ce = me(We, re), xe = h([]), Oe = (e) => {
+      xe.value = n.defaultExpandAll ? P.value.getNonLeafKeys() : e === void 0 ? n.defaultExpandedKeys : e;
+    };
+    y != null && y.includes("defaultExpandedKeys") ? le(() => {
+      Oe(void 0);
+    }) : le(() => {
+      Oe(n.defaultExpandedKeys);
+    });
+    const Ye = r(n, "expandedKeys"), T = me(Ye, xe), X = m(() => B.value.getFlattenedNodes(T.value)), {
+      pendingNodeKeyRef: W,
+      handleKeydown: qe
+    } = Tn({
+      props: n,
+      mergedCheckedKeysRef: k,
+      mergedSelectedKeysRef: ce,
+      fNodesRef: X,
+      mergedExpandedKeysRef: T,
+      handleCheck: De,
+      handleSelect: Te,
+      handleSwitcherClick: Pe
+    });
+    let O = null, Y = null;
+    const Re = h(/* @__PURE__ */ new Set()), Je = m(() => n.internalHighlightKeySet || H.value.highlightKeySet), Qe = me(Je, Re), se = h(/* @__PURE__ */ new Set()), Ze = m(() => T.value.filter((e) => !se.value.has(e)));
+    let Ie = 0;
+    const ae = h(null), fe = h(null), ue = h(null), he = h(null), ye = h(0), en = m(() => {
+      const {
+        value: e
+      } = fe;
+      return e ? e.parent : null;
+    });
+    let we = !1;
+    be(r(n, "data"), () => {
+      we = !0, ke(() => {
+        we = !1;
+      }), se.value.clear(), W.value = null, de();
+    }, {
+      deep: !1
+    });
+    let Ce = !1;
+    const Ne = () => {
+      Ce = !0, ke(() => {
+        Ce = !1;
+      });
+    };
+    let ie;
+    be(r(n, "pattern"), (e, t) => {
+      if (n.showIrrelevantNodes)
+        if (ie = void 0, e) {
+          const {
+            expandedKeys: l,
+            highlightKeySet: a
+          } = An(n.data, n.pattern, n.keyField, n.childrenField, E.value);
+          Re.value = a, Ne(), J(l, K(l), {
+            node: null,
+            action: "filter"
+          });
+        } else
+          Re.value = /* @__PURE__ */ new Set();
+      else if (!e.length)
+        ie !== void 0 && (Ne(), J(ie, K(ie), {
+          node: null,
+          action: "filter"
+        }));
+      else {
+        t.length || (ie = T.value);
+        const {
+          expandedKeys: l
+        } = H.value;
+        l !== void 0 && (Ne(), J(l, K(l), {
+          node: null,
+          action: "filter"
+        }));
+      }
+    });
+    function Ae(e) {
+      return Yn(this, void 0, void 0, function* () {
+        const {
+          onLoad: t
+        } = n;
+        if (!t) {
+          process.env.NODE_ENV !== "production" && $n("tree", "There is unloaded node in data but props.onLoad is not specified."), yield Promise.resolve();
+          return;
+        }
+        const {
+          value: l
+        } = se;
+        if (!l.has(e.key)) {
+          l.add(e.key);
+          try {
+            (yield t(e.rawNode)) === !1 && Q();
+          } catch (a) {
+            console.error(a), Q();
+          }
+          l.delete(e.key);
+        }
+      });
+    }
+    le(() => {
+      var e;
+      const {
+        value: t
+      } = B;
+      if (!t) return;
+      const {
+        getNode: l
+      } = t;
+      (e = T.value) === null || e === void 0 || e.forEach((a) => {
+        const i = l(a);
+        i && !i.shallowLoaded && Ae(i);
+      });
+    });
+    const q = h(!1), U = h([]);
+    be(Ze, (e, t) => {
+      if (!n.animated || Ce) {
+        ke(ge);
+        return;
+      }
+      if (we)
+        return;
+      const l = oe(s.value.self.nodeHeight), a = new Set(t);
+      let i = null, c = null;
+      for (const o of e)
+        if (!a.has(o)) {
+          if (i !== null) return;
+          i = o;
+        }
+      const g = new Set(e);
+      for (const o of t)
+        if (!g.has(o)) {
+          if (c !== null) return;
+          c = o;
+        }
+      if (i === null && c === null)
+        return;
+      const {
+        virtualScroll: S
+      } = n, ee = (S ? F.value.listElRef : w.value).offsetHeight, ne = Math.ceil(ee / l) + 1;
+      let C;
+      if (i !== null && (C = t), c !== null && (C === void 0 ? C = e : C = C.filter((o) => o !== c)), q.value = !0, U.value = B.value.getFlattenedNodes(C), i !== null) {
+        const o = U.value.findIndex((N) => N.key === i);
+        if (~o) {
+          const N = U.value[o].children;
+          if (N) {
+            const D = ze(N, e);
+            U.value.splice(o + 1, 0, {
+              __motion: !0,
+              mode: "expand",
+              height: S ? D.length * l : void 0,
+              nodes: S ? D.slice(0, ne) : D
+            });
+          }
+        }
+      }
+      if (c !== null) {
+        const o = U.value.findIndex((N) => N.key === c);
+        if (~o) {
+          const N = U.value[o].children;
+          if (!N) return;
+          q.value = !0;
+          const D = ze(N, e);
+          U.value.splice(o + 1, 0, {
+            __motion: !0,
+            mode: "collapse",
+            height: S ? D.length * l : void 0,
+            nodes: S ? D.slice(0, ne) : D
+          });
+        }
+      }
+    });
+    const nn = m(() => Vn(X.value)), tn = m(() => q.value ? U.value : X.value);
+    function ge() {
+      const {
+        value: e
+      } = A;
+      e && e.sync();
+    }
+    function ln() {
+      q.value = !1, n.virtualScroll && ke(ge);
+    }
+    function K(e) {
+      const {
+        getNode: t
+      } = P.value;
+      return e.map((l) => {
+        var a;
+        return ((a = t(l)) === null || a === void 0 ? void 0 : a.rawNode) || null;
+      });
+    }
+    function J(e, t, l) {
+      const {
+        "onUpdate:expandedKeys": a,
+        onUpdateExpandedKeys: i
+      } = n;
+      xe.value = e, a && v(a, e, t, l), i && v(i, e, t, l);
+    }
+    function Be(e, t, l) {
+      const {
+        "onUpdate:checkedKeys": a,
+        onUpdateCheckedKeys: i
+      } = n;
+      _.value = e, i && v(i, e, t, l), a && v(a, e, t, l);
+    }
+    function an(e, t) {
+      const {
+        "onUpdate:indeterminateKeys": l,
+        onUpdateIndeterminateKeys: a
+      } = n;
+      l && v(l, e, t), a && v(a, e, t);
+    }
+    function Fe(e, t, l) {
+      const {
+        "onUpdate:selectedKeys": a,
+        onUpdateSelectedKeys: i
+      } = n;
+      re.value = e, i && v(i, e, t, l), a && v(a, e, t, l);
+    }
+    function dn(e) {
+      const {
+        onDragenter: t
+      } = n;
+      t && v(t, e);
+    }
+    function on(e) {
+      const {
+        onDragleave: t
+      } = n;
+      t && v(t, e);
+    }
+    function rn(e) {
+      const {
+        onDragend: t
+      } = n;
+      t && v(t, e);
+    }
+    function cn(e) {
+      const {
+        onDragstart: t
+      } = n;
+      t && v(t, e);
+    }
+    function sn(e) {
+      const {
+        onDragover: t
+      } = n;
+      t && v(t, e);
+    }
+    function fn(e) {
+      const {
+        onDrop: t
+      } = n;
+      t && v(t, e);
+    }
+    function de() {
+      un(), $();
+    }
+    function un() {
+      ae.value = null;
+    }
+    function $() {
+      ye.value = 0, fe.value = null, ue.value = null, he.value = null, Q();
+    }
+    function Q() {
+      O && (window.clearTimeout(O), O = null), Y = null;
+    }
+    function De(e, t) {
+      if (n.disabled || z(e, n.disabledField))
+        return;
+      if (n.internalUnifySelectCheck && !n.multiple) {
+        Te(e);
+        return;
+      }
+      const l = t ? "check" : "uncheck", {
+        checkedKeys: a,
+        indeterminateKeys: i
+      } = P.value[l](e.key, G.value, {
+        cascade: n.cascade,
+        checkStrategy: j.value,
+        allowNotLoaded: n.allowCheckingNotLoaded
+      });
+      Be(a, K(a), {
+        node: e.rawNode,
+        action: l
+      }), an(i, K(i));
+    }
+    function hn(e) {
+      if (n.disabled) return;
+      const {
+        key: t
+      } = e, {
+        value: l
+      } = T, a = l.findIndex((i) => i === t);
+      if (~a) {
+        const i = Array.from(l);
+        i.splice(a, 1), J(i, K(i), {
+          node: e.rawNode,
+          action: "collapse"
+        });
+      } else {
+        const i = B.value.getNode(t);
+        if (!i || i.isLeaf)
+          return;
+        let c;
+        if (n.accordion) {
+          const g = new Set(e.siblings.map(({
+            key: S
+          }) => S));
+          c = l.filter((S) => !g.has(S)), c.push(t);
+        } else
+          c = l.concat(t);
+        J(c, K(c), {
+          node: e.rawNode,
+          action: "expand"
+        });
+      }
+    }
+    function Pe(e) {
+      n.disabled || q.value || hn(e);
+    }
+    function Te(e) {
+      if (!(n.disabled || !n.selectable)) {
+        if (W.value = e.key, n.internalUnifySelectCheck) {
+          const {
+            value: {
+              checkedKeys: t,
+              indeterminateKeys: l
+            }
+          } = M;
+          n.multiple ? De(e, !(t.includes(e.key) || l.includes(e.key))) : Be([e.key], K([e.key]), {
+            node: e.rawNode,
+            action: "check"
+          });
+        }
+        if (n.multiple) {
+          const t = Array.from(ce.value), l = t.findIndex((a) => a === e.key);
+          ~l ? n.cancelable && t.splice(l, 1) : ~l || t.push(e.key), Fe(t, K(t), {
+            node: e.rawNode,
+            action: ~l ? "unselect" : "select"
+          });
+        } else
+          ce.value.includes(e.key) ? n.cancelable && Fe([], [], {
+            node: e.rawNode,
+            action: "unselect"
+          }) : Fe([e.key], K([e.key]), {
+            node: e.rawNode,
+            action: "select"
+          });
+      }
+    }
+    function yn(e) {
+      if (O && (window.clearTimeout(O), O = null), e.isLeaf) return;
+      Y = e.key;
+      const t = () => {
+        if (Y !== e.key) return;
+        const {
+          value: l
+        } = ue;
+        if (l && l.key === e.key && !T.value.includes(e.key)) {
+          const a = T.value.concat(e.key);
+          J(a, K(a), {
+            node: e.rawNode,
+            action: "expand"
+          });
+        }
+        O = null, Y = null;
+      };
+      e.shallowLoaded ? O = window.setTimeout(() => {
+        t();
+      }, 1e3) : O = window.setTimeout(() => {
+        Ae(e).then(() => {
+          t();
+        });
+      }, 1e3);
+    }
+    function gn({
+      event: e,
+      node: t
+    }) {
+      !n.draggable || n.disabled || z(t, n.disabledField) || (_e({
+        event: e,
+        node: t
+      }, !1), dn({
+        event: e,
+        node: t.rawNode
+      }));
+    }
+    function vn({
+      event: e,
+      node: t
+    }) {
+      !n.draggable || n.disabled || z(t, n.disabledField) || on({
+        event: e,
+        node: t.rawNode
+      });
+    }
+    function mn(e) {
+      e.target === e.currentTarget && $();
+    }
+    function bn({
+      event: e,
+      node: t
+    }) {
+      de(), !(!n.draggable || n.disabled || z(t, n.disabledField)) && rn({
+        event: e,
+        node: t.rawNode
+      });
+    }
+    function kn({
+      event: e,
+      node: t
+    }) {
+      !n.draggable || n.disabled || z(t, n.disabledField) || (Ie = e.clientX, ae.value = t, cn({
+        event: e,
+        node: t.rawNode
+      }));
+    }
+    function _e({
+      event: e,
+      node: t
+    }, l = !0) {
+      var a;
+      if (!n.draggable || n.disabled || z(t, n.disabledField))
+        return;
+      const {
+        value: i
+      } = ae;
+      if (!i) return;
+      const {
+        allowDrop: c,
+        indent: g
+      } = n;
+      l && sn({
+        event: e,
+        node: t.rawNode
+      });
+      const S = e.currentTarget, {
+        height: ee,
+        top: ne
+      } = S.getBoundingClientRect(), C = e.clientY - ne;
+      let o;
+      c({
+        node: t.rawNode,
+        dropPosition: "inside",
+        phase: "drag"
+      }) ? C <= 8 ? o = "before" : C >= ee - 8 ? o = "after" : o = "inside" : C <= ee / 2 ? o = "before" : o = "after";
+      const {
+        value: D
+      } = nn;
+      let d, u;
+      const te = D(t.key);
+      if (te === null) {
+        $();
+        return;
+      }
+      let ve = !1;
+      o === "inside" ? (d = t, u = "inside") : o === "before" ? t.isFirstChild ? (d = t, u = "before") : (d = X.value[te - 1], u = "after") : (d = t, u = "after"), !d.isLeaf && T.value.includes(d.key) && (ve = !0, u === "after" && (d = X.value[te + 1], d ? u = "before" : (d = t, u = "inside")));
+      const pe = d;
+      if (ue.value = pe, !ve && i.isLastChild && i.key === d.key && (u = "after"), u === "after") {
+        let He = Ie - e.clientX, Ee = 0;
+        for (; He >= g / 2 && d.parent !== null && d.isLastChild && Ee < 1; )
+          He -= g, Ee += 1, d = d.parent;
+        ye.value = Ee;
+      } else
+        ye.value = 0;
+      if ((i.contains(d) || u === "inside" && ((a = i.parent) === null || a === void 0 ? void 0 : a.key) === d.key) && !(i.key === pe.key && i.key === d.key)) {
+        $();
+        return;
+      }
+      if (!c({
+        node: d.rawNode,
+        dropPosition: u,
+        phase: "drag"
+      })) {
+        $();
+        return;
+      }
+      if (i.key === d.key)
+        Q();
+      else if (Y !== d.key)
+        if (u === "inside") {
+          if (n.expandOnDragenter) {
+            if (yn(d), !d.shallowLoaded && Y !== d.key) {
+              de();
+              return;
+            }
+          } else if (!d.shallowLoaded) {
+            de();
+            return;
+          }
+        } else
+          Q();
+      else
+        u !== "inside" && Q();
+      he.value = u, fe.value = d;
+    }
+    function Kn({
+      event: e,
+      node: t,
+      dropPosition: l
+    }) {
+      if (!n.draggable || n.disabled || z(t, n.disabledField))
+        return;
+      const {
+        value: a
+      } = ae, {
+        value: i
+      } = fe, {
+        value: c
+      } = he;
+      if (!(!a || !i || !c) && n.allowDrop({
+        node: i.rawNode,
+        dropPosition: c,
+        phase: "drag"
+      }) && a.key !== i.key) {
+        if (c === "before") {
+          const g = a.getNext({
+            includeDisabled: !0
+          });
+          if (g && g.key === i.key) {
+            $();
+            return;
+          }
+        }
+        if (c === "after") {
+          const g = a.getPrev({
+            includeDisabled: !0
+          });
+          if (g && g.key === i.key) {
+            $();
+            return;
+          }
+        }
+        fn({
+          event: e,
+          node: i.rawNode,
+          dragNode: a.rawNode,
+          dropPosition: l
+        }), de();
+      }
+    }
+    function Sn() {
+      ge();
+    }
+    function xn() {
+      ge();
+    }
+    function Rn(e) {
+      var t;
+      if (n.virtualScroll || n.internalScrollable) {
+        const {
+          value: l
+        } = A;
+        if (!((t = l == null ? void 0 : l.containerRef) === null || t === void 0) && t.contains(e.relatedTarget))
+          return;
+        W.value = null;
+      } else {
+        const {
+          value: l
+        } = w;
+        if (l != null && l.contains(e.relatedTarget)) return;
+        W.value = null;
+      }
+    }
+    be(W, (e) => {
+      var t, l;
+      if (e !== null) {
+        if (n.virtualScroll)
+          (t = F.value) === null || t === void 0 || t.scrollTo({
+            key: e
+          });
+        else if (n.internalScrollable) {
+          const {
+            value: a
+          } = A;
+          if (a === null) return;
+          const i = (l = a.contentRef) === null || l === void 0 ? void 0 : l.querySelector(`[data-key="${Mn(e)}"]`);
+          if (!i) return;
+          a.scrollTo({
+            el: i
+          });
+        }
+      }
+    }), Wn(Dn, {
+      loadingKeysRef: se,
+      highlightKeySetRef: Qe,
+      displayedCheckedKeysRef: G,
+      displayedIndeterminateKeysRef: Se,
+      mergedSelectedKeysRef: ce,
+      mergedExpandedKeysRef: T,
+      mergedThemeRef: s,
+      mergedCheckStrategyRef: j,
+      nodePropsRef: r(n, "nodeProps"),
+      disabledRef: r(n, "disabled"),
+      checkableRef: r(n, "checkable"),
+      selectableRef: r(n, "selectable"),
+      expandOnClickRef: r(n, "expandOnClick"),
+      onLoadRef: r(n, "onLoad"),
+      draggableRef: r(n, "draggable"),
+      blockLineRef: r(n, "blockLine"),
+      indentRef: r(n, "indent"),
+      cascadeRef: r(n, "cascade"),
+      checkOnClickRef: r(n, "checkOnClick"),
+      checkboxPlacementRef: n.checkboxPlacement,
+      droppingMouseNodeRef: ue,
+      droppingNodeParentRef: en,
+      draggingNodeRef: ae,
+      droppingPositionRef: he,
+      droppingOffsetLevelRef: ye,
+      fNodesRef: X,
+      pendingNodeKeyRef: W,
+      showLineRef: r(n, "showLine"),
+      disabledFieldRef: r(n, "disabledField"),
+      internalScrollableRef: r(n, "internalScrollable"),
+      internalCheckboxFocusableRef: r(n, "internalCheckboxFocusable"),
+      internalTreeSelect: n.internalTreeSelect,
+      renderLabelRef: r(n, "renderLabel"),
+      renderPrefixRef: r(n, "renderPrefix"),
+      renderSuffixRef: r(n, "renderSuffix"),
+      renderSwitcherIconRef: r(n, "renderSwitcherIcon"),
+      labelFieldRef: r(n, "labelField"),
+      multipleRef: r(n, "multiple"),
+      overrideDefaultNodeClickBehaviorRef: r(n, "overrideDefaultNodeClickBehavior"),
+      handleSwitcherClick: Pe,
+      handleDragEnd: bn,
+      handleDragEnter: gn,
+      handleDragLeave: vn,
+      handleDragStart: kn,
+      handleDrop: Kn,
+      handleDragOver: _e,
+      handleSelect: Te,
+      handleCheck: De
+    });
+    function wn(e, t) {
+      var l, a;
+      typeof e == "number" ? (l = F.value) === null || l === void 0 || l.scrollTo(e, t || 0) : (a = F.value) === null || a === void 0 || a.scrollTo(e);
+    }
+    const Cn = {
+      handleKeydown: qe,
+      scrollTo: wn,
+      getCheckedData: () => {
+        if (!n.checkable) return {
+          keys: [],
+          options: []
+        };
+        const {
+          checkedKeys: e
+        } = M.value;
+        return {
+          keys: e,
+          options: K(e)
+        };
+      },
+      getIndeterminateData: () => {
+        if (!n.checkable) return {
+          keys: [],
+          options: []
+        };
+        const {
+          indeterminateKeys: e
+        } = M.value;
+        return {
+          keys: e,
+          options: K(e)
+        };
+      }
+    }, Ue = m(() => {
+      const {
+        common: {
+          cubicBezierEaseInOut: e
+        },
+        self: {
+          fontSize: t,
+          nodeBorderRadius: l,
+          nodeColorHover: a,
+          nodeColorPressed: i,
+          nodeColorActive: c,
+          arrowColor: g,
+          loadingColor: S,
+          nodeTextColor: ee,
+          nodeTextColorDisabled: ne,
+          dropMarkColor: C,
+          nodeWrapperPadding: o,
+          nodeHeight: N,
+          lineHeight: D,
+          lineColor: d
+        }
+      } = s.value, u = Le(o, "top"), te = Le(o, "bottom"), ve = Pn(oe(N) - oe(u) - oe(te));
+      return {
+        "--n-arrow-color": g,
+        "--n-loading-color": S,
+        "--n-bezier": e,
+        "--n-font-size": t,
+        "--n-node-border-radius": l,
+        "--n-node-color-active": c,
+        "--n-node-color-hover": a,
+        "--n-node-color-pressed": i,
+        "--n-node-text-color": ee,
+        "--n-node-text-color-disabled": ne,
+        "--n-drop-mark-color": C,
+        "--n-node-wrapper-padding": o,
+        "--n-line-offset-top": `-${u}`,
+        "--n-line-offset-bottom": `-${te}`,
+        "--n-node-content-height": ve,
+        "--n-line-height": D,
+        "--n-line-color": d
+      };
+    }), Z = R ? pn("tree", void 0, Ue, n) : void 0;
+    return Object.assign(Object.assign({}, Cn), {
+      mergedClsPrefix: x,
+      mergedTheme: s,
+      rtlEnabled: V,
+      fNodes: tn,
+      aip: q,
+      selfElRef: w,
+      virtualListInstRef: F,
+      scrollbarInstRef: A,
+      handleFocusout: Rn,
+      handleDragLeaveTree: mn,
+      handleScroll: Sn,
+      getScrollContainer: p,
+      getScrollContent: b,
+      handleAfterEnter: ln,
+      handleResize: xn,
+      cssVars: R ? void 0 : Ue,
+      themeClass: Z == null ? void 0 : Z.themeClass,
+      onRender: Z == null ? void 0 : Z.onRender
+    });
+  },
+  render() {
+    var n;
+    const {
+      fNodes: x,
+      internalRenderEmpty: R
+    } = this;
+    if (!x.length && R)
+      return R();
+    const {
+      mergedClsPrefix: f,
+      blockNode: V,
+      blockLine: s,
+      draggable: w,
+      disabled: A,
+      internalFocusable: F,
+      checkable: p,
+      handleKeydown: b,
+      rtlEnabled: E,
+      handleFocusout: H,
+      scrollbarProps: B
+    } = this, L = F && !A, P = L ? "0" : void 0, y = [`${f}-tree`, E && `${f}-tree--rtl`, p && `${f}-tree--checkable`, (s || V) && `${f}-tree--block-node`, s && `${f}-tree--block-line`], _ = (k) => "__motion" in k ? I(En, {
+      height: k.height,
+      nodes: k.nodes,
+      clsPrefix: f,
+      mode: k.mode,
+      onAfterEnter: this.handleAfterEnter
+    }) : I(On, {
+      key: k.key,
+      tmNode: k,
+      clsPrefix: f
+    });
+    if (this.virtualScroll) {
+      const {
+        mergedTheme: k,
+        internalScrollablePadding: M
+      } = this, j = Le(M || "0");
+      return I(Me, Object.assign({}, B, {
+        ref: "scrollbarInstRef",
+        onDragleave: w ? this.handleDragLeaveTree : void 0,
+        container: this.getScrollContainer,
+        content: this.getScrollContent,
+        class: y,
+        theme: k.peers.Scrollbar,
+        themeOverrides: k.peerOverrides.Scrollbar,
+        tabindex: P,
+        onKeydown: L ? b : void 0,
+        onFocusout: L ? H : void 0
+      }), {
+        default: () => {
+          var G;
+          return (G = this.onRender) === null || G === void 0 || G.call(this), x.length ? I(Hn, {
+            ref: "virtualListInstRef",
+            items: this.fNodes,
+            itemSize: oe(k.self.nodeHeight),
+            ignoreItemResize: this.aip,
+            paddingTop: j.top,
+            paddingBottom: j.bottom,
+            class: this.themeClass,
+            style: [this.cssVars, {
+              paddingLeft: j.left,
+              paddingRight: j.right
+            }],
+            onScroll: this.handleScroll,
+            onResize: this.handleResize,
+            showScrollbar: !1,
+            itemResizable: !0
+          }, {
+            default: ({
+              item: Se
+            }) => _(Se)
+          }) : je(this.$slots.empty, () => [I($e, {
+            class: `${f}-tree__empty`,
+            theme: this.mergedTheme.peers.Empty,
+            themeOverrides: this.mergedTheme.peerOverrides.Empty
+          })]);
+        }
+      });
+    }
+    const {
+      internalScrollable: Ke
+    } = this;
+    return y.push(this.themeClass), (n = this.onRender) === null || n === void 0 || n.call(this), Ke ? I(Me, Object.assign({}, B, {
+      class: y,
+      tabindex: P,
+      onKeydown: L ? b : void 0,
+      onFocusout: L ? H : void 0,
+      style: this.cssVars,
+      contentStyle: {
+        padding: this.internalScrollablePadding
+      }
+    }), {
+      default: () => I("div", {
+        onDragleave: w ? this.handleDragLeaveTree : void 0,
+        ref: "selfElRef"
+      }, this.fNodes.map(_))
+    }) : I("div", {
+      class: y,
+      tabindex: P,
+      ref: "selfElRef",
+      style: this.cssVars,
+      onKeydown: L ? b : void 0,
+      onFocusout: L ? H : void 0,
+      onDragleave: w ? this.handleDragLeaveTree : void 0
+    }, x.length ? x.map(_) : je(this.$slots.empty, () => [I($e, {
+      class: `${f}-tree__empty`,
+      theme: this.mergedTheme.peers.Empty,
+      themeOverrides: this.mergedTheme.peerOverrides.Empty
+    })]));
+  }
+});
+export {
+  Ge as createTreeMateOptions,
+  Nt as default,
+  Jn as treeProps,
+  qn as treeSharedProps
+};