@duxweb/dvha-naiveui 1.2.5 → 1.2.7

package/dist/esm/node_modules/.pnpm/naive-ui@2.44.1_vue@3.5.31_typescript@6.0.2_/node_modules/naive-ui/es/tree/src/Tree.js

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