@feugene/granularity 0.13.0 → 0.18.0

package/dist/components/GrTree/chunks/GrTree-CaYK8dGZ.js

@@ -0,0 +1,1371 @@
+import { o as useGrComponentSize } from "../../../chunks/context-BSYR7RZs.js";
+import { n as useGranularityTranslations } from "../../../chunks/granularityI18n-BC5zsj_d.js";
+import { useVirtualList } from "../../../composables/useVirtualList.js";
+import { t as _plugin_vue_export_helper_default } from "../../../chunks/_plugin-vue_export-helper-BOaGB7Aw.js";
+import { useAnnouncer } from "../../../composables/useAnnouncer.js";
+import { t as useDragSort } from "../../../chunks/useDragSort-0l47h4yb.js";
+import { useRovingFocus } from "../../../composables/useRovingFocus.js";
+import { Fragment, computed, createCommentVNode, createElementBlock, createElementVNode, defineComponent, nextTick, normalizeClass, normalizeStyle, onBeforeUnmount, onUnmounted, openBlock, ref, renderList, renderSlot, shallowRef, toDisplayString, toValue, unref, watch, withModifiers } from "vue";
+import '../styles.css';//#region src/components/GrTree/grTreeDataAdapter.ts
+var DEFAULT_CHILDREN_KEY = "children";
+var DEFAULT_LABEL_KEY = "label";
+var DEFAULT_IS_LEAF_KEY = "isLeaf";
+function isTreeKey(value) {
+	return typeof value === "string" || typeof value === "number";
+}
+function resolveMapValue(map, key, fallback) {
+	return map?.[key] ?? fallback;
+}
+function createGrTreeDataAdapter(options) {
+	function hasNodeKey() {
+		return options.nodeKey != null;
+	}
+	function getChildrenKey() {
+		return resolveMapValue(options.props, "children", DEFAULT_CHILDREN_KEY);
+	}
+	function getLabelKey() {
+		return resolveMapValue(options.props, "label", DEFAULT_LABEL_KEY);
+	}
+	function getLabel(data) {
+		const value = data[getLabelKey()];
+		return value == null ? "" : String(value);
+	}
+	function getIsLeaf(data) {
+		const value = data[resolveMapValue(options.props, "isLeaf", DEFAULT_IS_LEAF_KEY)];
+		return typeof value === "boolean" ? value : void 0;
+	}
+	function getChildren(data) {
+		const value = data[getChildrenKey()];
+		return Array.isArray(value) ? value : [];
+	}
+	function ensureChildren(data) {
+		const key = getChildrenKey();
+		const value = data[key];
+		if (Array.isArray(value)) return value;
+		data[key] = [];
+		return data[key];
+	}
+	function getExplicitNodeKey(data) {
+		if (options.nodeKey == null) return void 0;
+		const value = data[options.nodeKey];
+		return isTreeKey(value) ? value : void 0;
+	}
+	function getNodeKey(data, index, parentKey) {
+		const explicitKey = getExplicitNodeKey(data);
+		if (explicitKey != null) return explicitKey;
+		return parentKey == null ? index : `${String(parentKey)}:${index}`;
+	}
+	return {
+		hasNodeKey,
+		getChildrenKey,
+		getLabelKey,
+		getLabel,
+		getIsLeaf,
+		getChildren,
+		ensureChildren,
+		getNodeKey,
+		getExplicitNodeKey
+	};
+}
+//#endregion
+//#region src/components/GrTree/grTreeInteractionContext.ts
+function createGrTreeInteractionContext(options, emitters) {
+	const hoveredKey = ref(void 0);
+	const draggingNode = shallowRef(null);
+	const dropTarget = shallowRef(null);
+	const nodeEls = /* @__PURE__ */ new Map();
+	function registerNodeEl(key, el) {
+		if (el) {
+			nodeEls.set(key, el);
+			return;
+		}
+		const previous = nodeEls.get(key);
+		if (previous && !previous.isConnected) nodeEls.delete(key);
+	}
+	function canDrag(node) {
+		if (!options.draggable) return false;
+		if (options.allowDrag) return options.allowDrag(node);
+		return true;
+	}
+	function canDrop(drag, target, type) {
+		if (!options.allowDrop) return true;
+		return options.allowDrop(drag, target, type);
+	}
+	function resetDragState() {
+		draggingNode.value = null;
+		dropTarget.value = null;
+	}
+	return {
+		hoveredKey,
+		nodeEls,
+		registerNodeEl,
+		draggingNode,
+		dropTarget,
+		canDrag,
+		canDrop,
+		resetDragState,
+		...emitters
+	};
+}
+//#endregion
+//#region src/components/GrTree/grTreeChecking.ts
+/**
+* Раскладывает отмеченные ключи по всему дереву: родитель отмечен, когда
+* отмечены все дети, и наполовину — когда часть.
+*
+* Считается от листьев вверх, поэтому `checkedKeys` снаружи может содержать
+* только листья (типовой формат ответа сервера) — родители посчитаются сами.
+* При `strict` дерево не связывает узлы вовсе: каждый отвечает сам за себя.
+*/
+function resolveCheckStates(roots, checkedKeys, strict) {
+	const states = /* @__PURE__ */ new Map();
+	const walk = (node) => {
+		if (strict || node.childNodes.length === 0) {
+			const state = checkedKeys.has(node.key) ? "checked" : "unchecked";
+			if (strict) node.childNodes.forEach(walk);
+			states.set(node.key, state);
+			return state;
+		}
+		const childStates = node.childNodes.map(walk);
+		const allChecked = childStates.every((s) => s === "checked");
+		const someMarked = childStates.some((s) => s !== "unchecked");
+		const state = allChecked ? "checked" : someMarked || checkedKeys.has(node.key) ? "half" : "unchecked";
+		states.set(node.key, state);
+		return state;
+	};
+	roots.forEach(walk);
+	return states;
+}
+/**
+* Новый набор отмеченных ключей после переключения узла.
+*
+* Каскад идёт вниз (все потомки повторяют решение) и вверх (родитель отмечен,
+* только если отмечены все его дети). Возвращается набор с родителями —
+* `getCheckedKeys({ leafOnly: true })` при необходимости отбросит их обратно.
+*/
+function toggleCheckedKeys(roots, checkedKeys, node, checked, strict) {
+	const next = new Set(checkedKeys);
+	if (strict) {
+		if (checked) next.add(node.key);
+		else next.delete(node.key);
+		return next;
+	}
+	const applyDown = (target) => {
+		if (checked) next.add(target.key);
+		else next.delete(target.key);
+		target.childNodes.forEach(applyDown);
+	};
+	applyDown(node);
+	for (let parent = node.parent; parent; parent = parent.parent) if (parent.childNodes.every((child) => next.has(child.key))) next.add(parent.key);
+	else next.delete(parent.key);
+	return pruneToTree(roots, next);
+}
+/** Отбрасывает ключи, которых нет в текущей модели (данные могли смениться). */
+function pruneToTree(roots, keys) {
+	const known = /* @__PURE__ */ new Set();
+	const walk = (node) => {
+		known.add(node.key);
+		node.childNodes.forEach(walk);
+	};
+	roots.forEach(walk);
+	const next = /* @__PURE__ */ new Set();
+	for (const key of keys) if (known.has(key)) next.add(key);
+	return next;
+}
+/** Ключи в состоянии `checked`; `leafOnly` оставляет только листья. */
+function collectCheckedKeys(roots, states, leafOnly) {
+	const out = [];
+	const walk = (node) => {
+		const isLeaf = node.childNodes.length === 0;
+		if (states.get(node.key) === "checked" && (!leafOnly || isLeaf)) out.push(node.key);
+		node.childNodes.forEach(walk);
+	};
+	roots.forEach(walk);
+	return out;
+}
+/** Ключи в состоянии `half` — родители с частично отмеченными потомками. */
+function collectHalfCheckedKeys(states) {
+	const out = [];
+	for (const [key, state] of states) if (state === "half") out.push(key);
+	return out;
+}
+//#endregion
+//#region src/components/GrTree/grTreeStore.ts
+function createGrTreeStore(options) {
+	const filterValue = ref("");
+	const expandedKeys = shallowRef(/* @__PURE__ */ new Set());
+	const checkedKeys = shallowRef(new Set(toValue(options.defaultCheckedKeys) ?? []));
+	const loadingKeys = shallowRef(/* @__PURE__ */ new Set());
+	const loadedKeys = shallowRef(/* @__PURE__ */ new Set());
+	const loadedChildren = shallowRef(/* @__PURE__ */ new Map());
+	const currentKey = ref(void 0);
+	const getData = () => toValue(options.data) ?? [];
+	const getFilterNodeMethod = () => toValue(options.filterNodeMethod);
+	watch(() => toValue(options.defaultExpandedKeys), (keys) => {
+		expandedKeys.value = new Set(keys ?? []);
+	}, { immediate: true });
+	watch(() => toValue(options.checkedKeys), (keys) => {
+		if (keys) checkedKeys.value = new Set(keys);
+	}, { immediate: true });
+	const treeModel = computed(() => {
+		const byKey = /* @__PURE__ */ new Map();
+		const byData = /* @__PURE__ */ new WeakMap();
+		const build = (items, parent, level) => {
+			return items.map((item, index) => {
+				const node = {
+					key: options.adapter.getNodeKey(item, index, parent?.key),
+					label: options.adapter.getLabel(item),
+					data: item,
+					level,
+					parent,
+					childNodes: []
+				};
+				byKey.set(node.key, node);
+				byData.set(item, node);
+				const ownChildren = options.adapter.getChildren(item);
+				const lazyChildren = loadedChildren.value.get(node.key) ?? [];
+				node.childNodes = build([...ownChildren, ...lazyChildren], node, level + 1);
+				return node;
+			});
+		};
+		return {
+			roots: build(getData(), void 0, 1),
+			byKey,
+			byData
+		};
+	});
+	const autoExpandedKeys = /* @__PURE__ */ new Set();
+	watch(treeModel, (model) => {
+		if (!toValue(options.defaultExpandAll)) return;
+		const next = new Set(expandedKeys.value);
+		let changed = false;
+		for (const key of model.byKey.keys()) {
+			if (autoExpandedKeys.has(key)) continue;
+			autoExpandedKeys.add(key);
+			next.add(key);
+			changed = true;
+		}
+		if (changed) expandedKeys.value = next;
+	}, { immediate: true });
+	const filterInfo = computed(() => {
+		const value = filterValue.value;
+		const isActive = value.trim().length > 0;
+		const valueLower = value.toLowerCase();
+		const subtreeHasMatch = /* @__PURE__ */ new Map();
+		const matchedKeys = /* @__PURE__ */ new Set();
+		const autoExpandKeys = /* @__PURE__ */ new Set();
+		if (!isActive) return {
+			isActive,
+			subtreeHasMatch,
+			matchedKeys,
+			autoExpandKeys
+		};
+		const match = (node) => {
+			const filterNodeMethod = getFilterNodeMethod();
+			if (filterNodeMethod) return filterNodeMethod(value, node.data, node);
+			return node.label.toLowerCase().includes(valueLower);
+		};
+		const walk = (nodes) => {
+			let any = false;
+			for (const node of nodes) {
+				const self = match(node);
+				const childAny = walk(node.childNodes);
+				const has = self || childAny;
+				subtreeHasMatch.set(node.key, has);
+				if (self) matchedKeys.add(node.key);
+				if (childAny) autoExpandKeys.add(node.key);
+				any ||= has;
+			}
+			return any;
+		};
+		walk(treeModel.value.roots);
+		return {
+			isActive,
+			subtreeHasMatch,
+			matchedKeys,
+			autoExpandKeys
+		};
+	});
+	function getNode(key) {
+		return treeModel.value.byKey.get(key);
+	}
+	function findNodeByData(data) {
+		return treeModel.value.byData.get(data);
+	}
+	function isTreeNode(target) {
+		return typeof target === "object" && target !== null && "key" in target && "data" in target && "childNodes" in target;
+	}
+	function resolveNodeTarget(target) {
+		if (target == null) return void 0;
+		if (typeof target === "string" || typeof target === "number") return getNode(target);
+		if (isTreeNode(target)) return getNode(target.key) ?? target;
+		const key = options.adapter.getExplicitNodeKey(target);
+		if (key != null) return getNode(key);
+		return findNodeByData(target);
+	}
+	function getNodeContainer(node) {
+		const items = node.parent ? options.adapter.ensureChildren(node.parent.data) : getData();
+		let index = items.findIndex((item) => item === node.data);
+		if (index >= 0) return {
+			items,
+			index
+		};
+		const key = options.adapter.getExplicitNodeKey(node.data);
+		if (key == null) return void 0;
+		index = items.findIndex((item) => options.adapter.getExplicitNodeKey(item) === key);
+		if (index < 0) return void 0;
+		return {
+			items,
+			index
+		};
+	}
+	function isDescendantNode(ancestor, node) {
+		let current = node.parent;
+		while (current) {
+			if (current.key === ancestor.key) return true;
+			current = current.parent;
+		}
+		return false;
+	}
+	function canMoveNode(node, referenceNode, dropType) {
+		const sourceNode = resolveNodeTarget(node);
+		const targetNode = resolveNodeTarget(referenceNode);
+		if (!sourceNode || !targetNode) return false;
+		if (sourceNode.key === targetNode.key) return false;
+		if (isDescendantNode(sourceNode, targetNode)) return false;
+		if (!getNodeContainer(sourceNode)) return false;
+		if (dropType === "inner") return true;
+		return Boolean(getNodeContainer(targetNode));
+	}
+	function sanitizeTreeState() {
+		const byKey = treeModel.value.byKey;
+		if (currentKey.value != null && !byKey.has(currentKey.value)) currentKey.value = void 0;
+		const nextExpandedKeys = new Set(Array.from(expandedKeys.value).filter((key) => byKey.has(key)));
+		if (nextExpandedKeys.size !== expandedKeys.value.size) expandedKeys.value = nextExpandedKeys;
+		const nextCheckedKeys = new Set(Array.from(checkedKeys.value).filter((key) => byKey.has(key)));
+		if (nextCheckedKeys.size !== checkedKeys.value.size) checkedKeys.value = nextCheckedKeys;
+	}
+	function isExpandedKey(key) {
+		return expandedKeys.value.has(key);
+	}
+	function setExpandedKey(key, expanded) {
+		const next = new Set(expandedKeys.value);
+		if (expanded) next.add(key);
+		else next.delete(key);
+		expandedKeys.value = next;
+	}
+	function toggleExpand(node) {
+		setExpandedKey(node.key, !isExpandedKey(node.key));
+	}
+	function setCurrentKey(key) {
+		currentKey.value = key;
+	}
+	function getCurrentKey() {
+		return currentKey.value;
+	}
+	function getCurrentNode() {
+		const key = currentKey.value;
+		return key == null ? void 0 : getNode(key);
+	}
+	function setCurrentNode(node) {
+		if (node == null) {
+			currentKey.value = void 0;
+			return true;
+		}
+		const targetNode = resolveNodeTarget(node);
+		if (!targetNode) return false;
+		currentKey.value = targetNode.key;
+		return true;
+	}
+	function resolveInsertedNode(data) {
+		const key = options.adapter.getExplicitNodeKey(data);
+		if (key != null) return getNode(key);
+		return findNodeByData(data);
+	}
+	function moveNode(node, referenceNode, dropType) {
+		const sourceNode = resolveNodeTarget(node);
+		const targetNode = resolveNodeTarget(referenceNode);
+		if (!sourceNode || !targetNode) return void 0;
+		if (!canMoveNode(sourceNode, targetNode, dropType)) return void 0;
+		const sourceContainer = getNodeContainer(sourceNode);
+		if (!sourceContainer) return void 0;
+		let destinationItems;
+		let destinationIndex;
+		if (dropType === "inner") {
+			destinationItems = options.adapter.ensureChildren(targetNode.data);
+			destinationIndex = destinationItems.length;
+		} else {
+			const targetContainer = getNodeContainer(targetNode);
+			if (!targetContainer) return void 0;
+			destinationItems = targetContainer.items;
+			destinationIndex = dropType === "prev" ? targetContainer.index : targetContainer.index + 1;
+		}
+		if (destinationItems === sourceContainer.items && sourceContainer.index < destinationIndex) destinationIndex -= 1;
+		const [movedData] = sourceContainer.items.splice(sourceContainer.index, 1);
+		destinationItems.splice(destinationIndex, 0, movedData);
+		if (dropType === "inner") setExpandedKey(targetNode.key, true);
+		sanitizeTreeState();
+		return resolveInsertedNode(movedData);
+	}
+	function appendNode(data, parent) {
+		const parentNode = resolveNodeTarget(parent);
+		if (!parentNode) return void 0;
+		options.adapter.ensureChildren(parentNode.data).push(data);
+		setExpandedKey(parentNode.key, true);
+		sanitizeTreeState();
+		return resolveInsertedNode(data);
+	}
+	function removeNode(node) {
+		if (!options.adapter.hasNodeKey()) return false;
+		const targetNode = resolveNodeTarget(node);
+		if (!targetNode) return false;
+		const container = getNodeContainer(targetNode);
+		if (!container) return false;
+		container.items.splice(container.index, 1);
+		sanitizeTreeState();
+		return true;
+	}
+	function insertNodeBefore(data, referenceNode) {
+		const targetNode = resolveNodeTarget(referenceNode);
+		if (!targetNode) return void 0;
+		const container = getNodeContainer(targetNode);
+		if (!container) return void 0;
+		container.items.splice(container.index, 0, data);
+		sanitizeTreeState();
+		return resolveInsertedNode(data);
+	}
+	function insertNodeAfter(data, referenceNode) {
+		const targetNode = resolveNodeTarget(referenceNode);
+		if (!targetNode) return void 0;
+		const container = getNodeContainer(targetNode);
+		if (!container) return void 0;
+		container.items.splice(container.index + 1, 0, data);
+		sanitizeTreeState();
+		return resolveInsertedNode(data);
+	}
+	const checkStates = computed(() => resolveCheckStates(treeModel.value.roots, checkedKeys.value, Boolean(toValue(options.checkStrictly))));
+	function getCheckState(key) {
+		return checkStates.value.get(key) ?? "unchecked";
+	}
+	function setChecked(node, checked) {
+		const targetNode = resolveNodeTarget(node);
+		if (!targetNode) return void 0;
+		checkedKeys.value = toggleCheckedKeys(treeModel.value.roots, checkedKeys.value, targetNode, checked, Boolean(toValue(options.checkStrictly)));
+		return targetNode;
+	}
+	function toggleChecked(node) {
+		return setChecked(node, getCheckState(node.key) !== "checked");
+	}
+	function getCheckedKeys(opts) {
+		return collectCheckedKeys(treeModel.value.roots, checkStates.value, Boolean(opts?.leafOnly));
+	}
+	function setCheckedKeys(keys) {
+		checkedKeys.value = pruneToTree(treeModel.value.roots, new Set(keys));
+	}
+	function getHalfCheckedKeys() {
+		return collectHalfCheckedKeys(checkStates.value);
+	}
+	function isLeafNode(node) {
+		if (node.childNodes.length > 0) return false;
+		if (!toValue(options.lazy)) return true;
+		const declared = options.adapter.getIsLeaf(node.data);
+		if (declared !== void 0) return declared;
+		return loadedKeys.value.has(node.key);
+	}
+	function isLoadingKey(key) {
+		return loadingKeys.value.has(key);
+	}
+	function markLoading(key, loading) {
+		const next = new Set(loadingKeys.value);
+		if (loading) next.add(key);
+		else next.delete(key);
+		loadingKeys.value = next;
+	}
+	function ensureLoaded(node) {
+		const load = toValue(options.load);
+		if (!toValue(options.lazy) || !load) return;
+		if (loadedKeys.value.has(node.key) || loadingKeys.value.has(node.key) || isLeafNode(node)) return;
+		markLoading(node.key, true);
+		let settled = false;
+		load(node, (children) => {
+			if (settled) return;
+			settled = true;
+			const next = new Map(loadedChildren.value);
+			next.set(node.key, [...children ?? []]);
+			loadedChildren.value = next;
+			loadedKeys.value = new Set(loadedKeys.value).add(node.key);
+			markLoading(node.key, false);
+		});
+	}
+	function filter(value) {
+		filterValue.value = value;
+	}
+	return {
+		filterValue,
+		expandedKeys,
+		loadedChildren,
+		checkedKeys,
+		checkStates,
+		loadingKeys,
+		loadedKeys,
+		currentKey,
+		treeModel,
+		filterInfo,
+		filter,
+		isExpandedKey,
+		setExpandedKey,
+		toggleExpand,
+		setCurrentKey,
+		getCurrentKey,
+		getCurrentNode,
+		setCurrentNode,
+		getNode,
+		canMoveNode,
+		moveNode,
+		appendNode,
+		removeNode,
+		insertNodeBefore,
+		insertNodeAfter,
+		getCheckState,
+		setChecked,
+		toggleChecked,
+		getCheckedKeys,
+		setCheckedKeys,
+		getHalfCheckedKeys,
+		isLeafNode,
+		isLoadingKey,
+		ensureLoaded
+	};
+}
+//#endregion
+//#region src/components/GrTree/grTreeStyles.ts
+var treeSizeVars = {
+	xs: {
+		"--gr-tree-row-min-height": "22px",
+		"--gr-tree-row-px": "4px",
+		"--gr-tree-row-py": "3px",
+		"--gr-tree-toggle-size": "18px",
+		"--gr-tree-drag-handle-size": "18px",
+		"--gr-tree-icon-size": "12px",
+		"--gr-tree-content-gap": "4px",
+		"--gr-tree-font-size": "12px"
+	},
+	sm: {
+		"--gr-tree-row-min-height": "24px",
+		"--gr-tree-row-px": "6px",
+		"--gr-tree-row-py": "5px",
+		"--gr-tree-toggle-size": "20px",
+		"--gr-tree-drag-handle-size": "20px",
+		"--gr-tree-icon-size": "14px",
+		"--gr-tree-content-gap": "6px",
+		"--gr-tree-font-size": "13px"
+	},
+	md: {
+		"--gr-tree-row-min-height": "28px",
+		"--gr-tree-row-px": "8px",
+		"--gr-tree-row-py": "8px",
+		"--gr-tree-toggle-size": "24px",
+		"--gr-tree-drag-handle-size": "24px",
+		"--gr-tree-icon-size": "16px",
+		"--gr-tree-content-gap": "8px",
+		"--gr-tree-font-size": "inherit"
+	},
+	lg: {
+		"--gr-tree-row-min-height": "32px",
+		"--gr-tree-row-px": "10px",
+		"--gr-tree-row-py": "10px",
+		"--gr-tree-toggle-size": "28px",
+		"--gr-tree-drag-handle-size": "28px",
+		"--gr-tree-icon-size": "20px",
+		"--gr-tree-content-gap": "10px",
+		"--gr-tree-font-size": "15px"
+	}
+};
+//#endregion
+//#region src/components/GrTree/GrTree.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["data-gr-virtual", "aria-multiselectable"];
+var _hoisted_2 = [
+	"data-gr-tree-node-key",
+	"aria-level",
+	"aria-posinset",
+	"aria-setsize",
+	"aria-expanded",
+	"aria-selected",
+	"aria-checked",
+	"aria-busy",
+	"tabindex"
+];
+var _hoisted_3 = [
+	"onClick",
+	"onContextmenu",
+	"onMouseenter",
+	"onMouseleave"
+];
+var _hoisted_4 = [
+	"aria-label",
+	"aria-disabled",
+	"onPointerdown"
+];
+var _hoisted_5 = ["aria-label", "onClick"];
+var _hoisted_6 = {
+	key: 0,
+	"data-gr-tree-loading": "",
+	class: "gr-tree__toggle-icon animate-spin i-lucide-loader-circle"
+};
+var _hoisted_7 = ["onClick"];
+var _hoisted_8 = { class: "gr-tree__label" };
+var DEFAULT_BRANCH_LINE_COLOR = "var(--gr-tree-branch-line-default-color, var(--gr-brd))";
+/** Стрелки, которые вместе с `Shift` двигают узел, а не фокус. */
+var TREE_ROW_GAP = 2;
+var TYPEAHEAD_RESET_MS = 600;
+//#endregion
+//#region src/components/GrTree/GrTree.vue
+var GrTree_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "GrTree",
+	props: {
+		data: {},
+		props: { default: () => ({
+			children: "children",
+			label: "label"
+		}) },
+		nodeKey: { default: "id" },
+		defaultExpandedKeys: { default: () => [] },
+		defaultExpandAll: {
+			type: Boolean,
+			default: false
+		},
+		filterNodeMethod: {},
+		lazy: {
+			type: Boolean,
+			default: false
+		},
+		load: {
+			type: Function,
+			default: void 0
+		},
+		size: { default: void 0 },
+		indent: { default: 0 },
+		virtual: {
+			type: Boolean,
+			default: false
+		},
+		maxHeight: { default: void 0 },
+		highlightCurrent: {
+			type: Boolean,
+			default: true
+		},
+		expandIcon: { default: "i-lucide-chevron-right" },
+		collapseIcon: { default: "i-lucide-chevron-right" },
+		toggleIconRotate: {
+			type: Boolean,
+			default: true
+		},
+		branchLine: {
+			type: Boolean,
+			default: false
+		},
+		branchLineColor: {
+			type: [String, Function],
+			default: void 0
+		},
+		branchLineActiveColor: {
+			type: [String, Function],
+			default: void 0
+		},
+		rowClass: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		dragHandleClass: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		toggleClass: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		toggleIconClass: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		toggleSpacerClass: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		contentClass: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		dragLabel: { default: void 0 },
+		expandLabel: { default: void 0 },
+		collapseLabel: { default: void 0 },
+		showCheckbox: {
+			type: Boolean,
+			default: false
+		},
+		checkedKeys: { default: void 0 },
+		defaultCheckedKeys: { default: () => [] },
+		checkStrictly: {
+			type: Boolean,
+			default: false
+		},
+		expandOnClickNode: {
+			type: Boolean,
+			default: false
+		},
+		accordion: {
+			type: Boolean,
+			default: false
+		},
+		draggable: {
+			type: Boolean,
+			default: false
+		},
+		dragHandleIcon: { default: "i-lucide-grip-vertical" },
+		allowDrop: {},
+		allowDrag: {}
+	},
+	emits: [
+		"nodeClick",
+		"nodeExpand",
+		"nodeCollapse",
+		"nodeDrop",
+		"nodeContextMenu",
+		"update:checkedKeys",
+		"check"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const MOVE_KEYS = /* @__PURE__ */ new Set([
+			"ArrowUp",
+			"ArrowDown",
+			"ArrowLeft",
+			"ArrowRight"
+		]);
+		const props = __props;
+		const emit = __emit;
+		const treeStore = createGrTreeStore({
+			adapter: createGrTreeDataAdapter(props),
+			data: () => props.data,
+			defaultExpandedKeys: () => props.defaultExpandedKeys,
+			defaultExpandAll: () => props.defaultExpandAll,
+			filterNodeMethod: () => props.filterNodeMethod,
+			defaultCheckedKeys: () => props.defaultCheckedKeys,
+			checkedKeys: () => props.checkedKeys,
+			checkStrictly: () => props.checkStrictly,
+			lazy: () => props.lazy,
+			load: () => props.load
+		});
+		const interactionContext = createGrTreeInteractionContext(props, {
+			emitNodeClick: (data, node) => emit("nodeClick", data, node),
+			emitNodeExpand: (data, node) => emit("nodeExpand", data, node),
+			emitNodeCollapse: (data, node) => emit("nodeCollapse", data, node),
+			emitNodeDrop: (draggingNode, dropNode, dropType) => emit("nodeDrop", draggingNode, dropNode, dropType),
+			emitNodeContextMenu: (evt, data, node) => emit("nodeContextMenu", evt, data, node)
+		});
+		const treeProps = props;
+		const { t } = useGranularityTranslations();
+		const { announce } = useAnnouncer();
+		const dragLabel = computed(() => treeProps.dragLabel ?? t("gr.tree.drag", "Drag"));
+		const expandLabel = computed(() => treeProps.expandLabel ?? t("gr.tree.expand", "Expand"));
+		const collapseLabel = computed(() => treeProps.collapseLabel ?? t("gr.tree.collapse", "Collapse"));
+		const currentKey = treeStore.currentKey;
+		const hoveredKey = interactionContext.hoveredKey;
+		const dropTarget = interactionContext.dropTarget;
+		const treeRootEl = ref(null);
+		/**
+		* Видимые строки одним плоским списком в порядке отображения.
+		*
+		* Плоско — потому что рекурсивный рендер стоил по инстансу компонента на каждый
+		* раскрытый узел: дерево на 2 000 видимых строк превращалось в 2 000
+		* компонентов со своими вычислениями и подписками. Иерархию несут `aria-level`,
+		* `aria-posinset` и `aria-setsize`, отступ — `padding-left` строки.
+		*/
+		const visibleRows = computed(() => {
+			const { roots } = treeStore.treeModel.value;
+			const { isActive, subtreeHasMatch, matchedKeys, autoExpandKeys } = treeStore.filterInfo.value;
+			const branch = treeProps.branchLine;
+			const rows = [];
+			const walk = (nodes, ancestorColors) => {
+				const siblings = isActive ? nodes.filter((node) => subtreeHasMatch.get(node.key)) : nodes;
+				siblings.forEach((node, index) => {
+					const isLeaf = treeStore.isLeafNode(node);
+					const isExpanded = treeStore.isExpandedKey(node.key) || isActive && autoExpandKeys.has(node.key);
+					rows.push({
+						node,
+						isExpanded,
+						isLeaf,
+						isMatched: matchedKeys.has(node.key),
+						posInSet: index + 1,
+						setSize: siblings.length,
+						isLoading: treeStore.isLoadingKey(node.key),
+						branchColors: ancestorColors
+					});
+					if (isExpanded && node.childNodes.length) walk(node.childNodes, branch ? [...ancestorColors, resolveBranchLineColor(node)] : ancestorColors);
+				});
+			};
+			walk(roots, []);
+			return rows;
+		});
+		/**
+		* Кольцо roving-фокуса: ровно один `treeitem` на всё дерево держит `tabindex=0`.
+		*
+		* Ориентация вертикальная намеренно: влево-вправо в дереве заняты раскрытием
+		* ветки и переходом к родителю, и примитив их не трогает — это доменная логика,
+		* она осталась в `onTreeKeydown`.
+		*/
+		const roving = useRovingFocus({
+			items: () => visibleRows.value.map((row) => row.node.key),
+			elementFor: (key) => interactionContext.nodeEls.get(key),
+			orientation: () => "vertical",
+			wrap: () => false,
+			onOverflow: () => true,
+			initialKey: () => currentKey.value ?? void 0,
+			beforeFocus: (key) => scrollRowIntoView(key)
+		});
+		function onRowClick(node) {
+			treeStore.setCurrentKey(node.key);
+			roving.setActive(node.key);
+			interactionContext.emitNodeClick(node.data, node);
+		}
+		function onRowActivate(row) {
+			onRowClick(row.node);
+			if (treeProps.expandOnClickNode && !row.isLeaf) toggleExpand(row.node);
+		}
+		function onRowContextMenu(evt, node) {
+			interactionContext.emitNodeContextMenu(evt, node.data, node);
+		}
+		function isRovingItem(key) {
+			return roving.rovingKey.value === key;
+		}
+		const resolvedSize = useGrComponentSize(() => props.size, { component: "GrTree" });
+		const sizeStyle = computed(() => treeSizeVars[resolvedSize.value]);
+		/**
+		* Виртуализация: в DOM живёт только окно вокруг вьюпорта.
+		*
+		* Корень дерева и есть скроллер — обёрток-распорок между `role="tree"` и
+		* `role="treeitem"` быть не должно, поэтому срезанное сверху и снизу держат
+		* отступы самого корня.
+		*/
+		const rowEstimate = computed(() => Number.parseFloat(sizeStyle.value["--gr-tree-row-min-height"]));
+		const virtualMaxHeight = computed(() => {
+			const value = treeProps.maxHeight;
+			if (value == null) return void 0;
+			return typeof value === "number" ? `${value}px` : value;
+		});
+		const virtualizer = useVirtualList({
+			container: treeRootEl,
+			count: () => treeProps.virtual ? visibleRows.value.length : 0,
+			source: () => visibleRows.value,
+			itemSize: () => rowEstimate.value,
+			gap: TREE_ROW_GAP,
+			viewportSize: () => typeof treeProps.maxHeight === "number" ? treeProps.maxHeight : void 0
+		});
+		/** Строки к отрисовке: при выключенной виртуализации — все. */
+		const renderedRows = computed(() => {
+			if (!treeProps.virtual) return visibleRows.value;
+			const { start, end } = virtualizer.range.value;
+			return visibleRows.value.slice(start, end);
+		});
+		/**
+		* Срезанное сверху и снизу держат псевдоэлементы контейнера.
+		*
+		* Ни один из трёх напрашивающихся вариантов не годится:
+		*
+		*  - `padding` контейнера — `max-height` меряет ту же коробку, и распорка в сто
+		*    тысяч пикселей либо раздувает скроллер до той же сотни тысяч, либо съедает
+		*    всю его высоту;
+		*  - обёртка-распорка внутри — между `role="tree"` и `role="treeitem"` не должно
+		*    быть посторонних узлов, роль потеряла бы обязательных потомков;
+		*  - отступы крайних отрисованных строк — распорка исчезает ровно в тот момент,
+		*    когда строки заменяются целиком (прыжок прокрутки), содержимое схлопывается
+		*    до высоты окна, и браузер обрезает `scrollTop` до почти нуля.
+		*
+		* `::before`/`::after` не узлы DOM: их не за что размонтировать, в дереве
+		* доступности их нет, а высота приезжает переменными в том же патче, что и сами
+		* строки, — схлопнуться между кадрами нечему.
+		*/
+		const rootStyle = computed(() => {
+			if (!treeProps.virtual) return sizeStyle.value;
+			return {
+				...sizeStyle.value,
+				overflow: "auto",
+				maxHeight: virtualMaxHeight.value,
+				...virtualizer.spacerStyle.value
+			};
+		});
+		/** Абсолютный индекс отрисованной строки: поиск по массиву стоил бы O(n) на строку. */
+		function absoluteIndex(offsetInWindow) {
+			return treeProps.virtual ? virtualizer.range.value.start + offsetInWindow : offsetInWindow;
+		}
+		/**
+		* Строка размонтируется: снимаем регистрацию и, если фокус был на ней, уводим
+		* его на корень — делегированный keydown живёт там, первая же стрелка вернёт
+		* видимую строку через `focusRow`. Иначе фокус упал бы на `body` и клавиатура
+		* дерева умерла бы до клика мышью.
+		*
+		* Спрашиваем сам элемент, а не `document.activeElement === body`: Vue обнуляет
+		* function ref ДО удаления узла, поэтому в момент вызова фокус ещё на строке —
+		* а «фокус на body» означает лишь то, что страницу никто не трогал.
+		*/
+		let isUnmounting = false;
+		function releaseNodeEl(key) {
+			const el = interactionContext.nodeEls.get(key);
+			const active = typeof document === "undefined" ? null : document.activeElement;
+			const heldFocus = Boolean(el && active && (el === active || el.contains(active)));
+			interactionContext.registerNodeEl(key, null);
+			if (heldFocus && !isUnmounting) treeRootEl.value?.focus({ preventScroll: true });
+		}
+		/**
+		* При виртуализации узла вне окна в DOM нет: `nodeEls.get` вернул бы
+		* `undefined`, а фокус уехал бы на `body` вместе с размонтированной строкой.
+		* Поэтому сперва прокрутка, и только следующим тиком — фокус.
+		*/
+		function scrollRowIntoView(key) {
+			if (treeProps.virtual) {
+				const index = visibleRows.value.findIndex((row) => row.node.key === key);
+				if (index >= 0) virtualizer.scrollToIndex(index);
+			}
+			return nextTick();
+		}
+		function focusRow(key) {
+			roving.focusKey(key);
+		}
+		/**
+		* Typeahead паттерна tree: печатные символы копятся в буфер и переводят фокус
+		* на первый подходящий видимый узел, начиная со следующего за текущим.
+		*/
+		let typeaheadBuffer = "";
+		let typeaheadTimer;
+		function onTypeahead(char, rows, fromIndex) {
+			clearTimeout(typeaheadTimer);
+			typeaheadTimer = setTimeout(() => {
+				typeaheadBuffer = "";
+			}, TYPEAHEAD_RESET_MS);
+			typeaheadBuffer = typeaheadBuffer.length === 1 && typeaheadBuffer === char ? char : typeaheadBuffer + char;
+			const query = typeaheadBuffer.toLowerCase();
+			const total = rows.length;
+			for (let step = 1; step <= total; step += 1) {
+				const row = rows[(fromIndex + step) % total];
+				if (row.node.label.toLowerCase().startsWith(query)) {
+					focusRow(row.node.key);
+					return;
+				}
+			}
+		}
+		/** `*` — раскрыть всех соседей узла, на котором фокус (уровень целиком). */
+		function expandSiblings(node) {
+			const siblings = node.parent ? node.parent.childNodes : treeStore.treeModel.value.roots;
+			for (const sibling of siblings) {
+				if (sibling.childNodes.length === 0 || treeStore.isExpandedKey(sibling.key)) continue;
+				treeStore.setExpandedKey(sibling.key, true);
+				interactionContext.emitNodeExpand(sibling.data, sibling);
+			}
+		}
+		function onTreeKeydown(event) {
+			const interactive = event.target?.closest("button, a[href], input, select, textarea, [contenteditable]");
+			if (interactive && interactive !== event.currentTarget) {
+				if (interactive.tabIndex >= 0) return;
+				if (event.key === "Enter" || event.key === " ") return;
+			}
+			const rows = visibleRows.value;
+			if (rows.length === 0) return;
+			const idx = Math.max(0, rows.findIndex((r) => r.node.key === roving.rovingKey.value));
+			const cur = rows[idx];
+			if (event.key === "*") {
+				event.preventDefault();
+				expandSiblings(cur.node);
+				return;
+			}
+			if (event.key.length === 1 && event.key !== " " && !event.ctrlKey && !event.metaKey && !event.altKey) {
+				event.preventDefault();
+				onTypeahead(event.key, rows, idx);
+				return;
+			}
+			if (event.shiftKey && MOVE_KEYS.has(event.key)) {
+				if (!treeProps.draggable) return;
+				event.preventDefault();
+				onNodeMoveKey(cur.node, event.key);
+				return;
+			}
+			if (roving.handleNavigationKeys(event)) return;
+			switch (event.key) {
+				case "ArrowRight":
+					event.preventDefault();
+					if (!cur.isLeaf) {
+						if (!cur.isExpanded) toggleExpand(cur.node);
+						else if (idx < rows.length - 1) focusRow(rows[idx + 1].node.key);
+					}
+					break;
+				case "ArrowLeft":
+					event.preventDefault();
+					if (!cur.isLeaf && cur.isExpanded) toggleExpand(cur.node);
+					else if (cur.node.parent && rows.some((r) => r.node.key === cur.node.parent.key)) focusRow(cur.node.parent.key);
+					break;
+				case "Enter":
+					event.preventDefault();
+					onRowClick(cur.node);
+					break;
+				case " ":
+					event.preventDefault();
+					if (treeProps.showCheckbox) toggleChecked(cur.node);
+					else onRowClick(cur.node);
+					break;
+			}
+		}
+		function onRowMouseEnter(node) {
+			hoveredKey.value = node.key;
+		}
+		function onRowMouseLeave(node) {
+			if (hoveredKey.value === node.key) hoveredKey.value = void 0;
+		}
+		function collapseSiblings(node) {
+			const siblings = node.parent ? node.parent.childNodes : treeStore.treeModel.value.roots;
+			for (const sibling of siblings) {
+				if (sibling.key === node.key || !treeStore.isExpandedKey(sibling.key)) continue;
+				treeStore.setExpandedKey(sibling.key, false);
+				interactionContext.emitNodeCollapse(sibling.data, sibling);
+			}
+		}
+		function toggleExpand(node) {
+			const expanded = !treeStore.isExpandedKey(node.key);
+			if (expanded && treeProps.accordion) collapseSiblings(node);
+			if (expanded) treeStore.ensureLoaded(node);
+			treeStore.toggleExpand(node);
+			if (expanded) interactionContext.emitNodeExpand(node.data, node);
+			else interactionContext.emitNodeCollapse(node.data, node);
+		}
+		function checkStateOf(key) {
+			return treeStore.getCheckState(key);
+		}
+		function ariaCheckedOf(row) {
+			if (!treeProps.showCheckbox) return void 0;
+			const state = checkStateOf(row.node.key);
+			return state === "checked" ? "true" : state === "half" ? "mixed" : "false";
+		}
+		function emitCheck(node) {
+			const checkedKeys = treeStore.getCheckedKeys();
+			emit("update:checkedKeys", checkedKeys);
+			emit("check", node.data, node, {
+				checkedKeys,
+				halfCheckedKeys: treeStore.getHalfCheckedKeys()
+			});
+		}
+		function toggleChecked(node) {
+			if (!treeProps.showCheckbox) return;
+			const changed = treeStore.toggleChecked(node);
+			if (changed) emitCheck(changed);
+		}
+		function rowStyle(row) {
+			return { "--gr-tree-row-indent": `calc(${treeProps.indent && treeProps.indent > 0 ? `${treeProps.indent}px` : "var(--gr-tree-indent-step)"} * ${row.node.level - 1})` };
+		}
+		/**
+		* Направляющая уровня-предка. Считается от того же шага отступа, что и сам
+		* отступ строки, — иначе линия и содержимое разъедутся на вложенных уровнях.
+		*/
+		function branchGuideStyle(row, index) {
+			return {
+				"left": `calc(${treeProps.indent && treeProps.indent > 0 ? `${treeProps.indent}px` : "var(--gr-tree-indent-step)"} * ${index} + var(--gr-tree-branch-line-offset))`,
+				"--gr-tree-branch-line-color": row.branchColors[index]
+			};
+		}
+		function canDrag(node) {
+			return interactionContext.canDrag(node);
+		}
+		function shouldShowDragHandle(node) {
+			return canDrag(node) && hoveredKey.value === node.key;
+		}
+		/**
+		* Треть строки сверху — «до», треть снизу — «после», середина — «внутрь».
+		* Зоны нарезает компонент: примитив отдаёт только долю вдоль строки.
+		*/
+		function dropTypeFromFraction(fraction) {
+			if (fraction < 1 / 3) return "prev";
+			if (fraction > 2 / 3) return "next";
+			return "inner";
+		}
+		function canDrop(drag, target, type) {
+			return interactionContext.canDrop(drag, target, type);
+		}
+		/** Перенос состоялся: одна дорога и для указателя, и для клавиатуры. */
+		function applyMove(source, targetKey, type) {
+			const reference = treeStore.getNode(targetKey);
+			if (!reference) return false;
+			const movedNode = treeStore.moveNode(source, reference, type);
+			if (!movedNode) return false;
+			const dropNode = treeStore.getNode(reference.key) ?? reference;
+			interactionContext.emitNodeDrop(movedNode, dropNode, type);
+			return true;
+		}
+		const dragSort = useDragSort({
+			items: () => visibleRows.value.map((row) => row.node.key),
+			elementFor: (key) => interactionContext.nodeEls.get(key) ?? null,
+			scroller: () => treeRootEl.value,
+			disabled: () => !treeProps.draggable,
+			canDrag: (key) => {
+				const node = treeStore.getNode(key);
+				return node ? canDrag(node) : false;
+			},
+			resolveTarget: (hit, sourceKey, previous) => {
+				const source = treeStore.getNode(sourceKey);
+				const node = treeStore.getNode(hit.key);
+				if (!source || !node) return null;
+				const type = dropTypeFromFraction(hit.fraction);
+				const allowed = treeStore.canMoveNode(source, node, type) && canDrop(source, node, type);
+				if (previous && previous.key === node.key && previous.type === type && previous.allowed === allowed) return previous;
+				return {
+					key: node.key,
+					type,
+					allowed
+				};
+			},
+			onDrop: (sourceKey, target) => {
+				const source = treeStore.getNode(sourceKey);
+				if (!source || !target.allowed) return;
+				applyMove(source, target.key, target.type);
+			},
+			onUpdate: (sourceKey, target) => {
+				interactionContext.draggingNode.value = sourceKey === null ? null : treeStore.getNode(sourceKey) ?? null;
+				interactionContext.dropTarget.value = target;
+			}
+		});
+		function onHandlePointerDown(event, node) {
+			if (!treeProps.draggable) return;
+			dragSort.startFrom(node.key)(event);
+		}
+		/**
+		* Клавиатурный перенос — раскладка аутлайнера: `Shift` со стрелкой сразу
+		* двигает узел, без режима «взято». Режим здесь был бы лишним: `Space` в дереве
+		* уже отмечает чекбокс, а стрелки водят фокус по веткам.
+		*/
+		function moveByKeyboard(node, key) {
+			const siblings = node.parent ? node.parent.childNodes : treeStore.treeModel.value.roots;
+			const index = siblings.findIndex((sibling) => sibling.key === node.key);
+			if (key === "ArrowUp" && index > 0) return applyMove(node, siblings[index - 1].key, "prev");
+			if (key === "ArrowDown" && index >= 0 && index < siblings.length - 1) return applyMove(node, siblings[index + 1].key, "next");
+			if (key === "ArrowRight" && index > 0) return applyMove(node, siblings[index - 1].key, "inner");
+			if (key === "ArrowLeft" && node.parent) return applyMove(node, node.parent.key, "next");
+			return false;
+		}
+		async function onNodeMoveKey(node, key) {
+			if (!treeProps.draggable || !canDrag(node)) return;
+			if (!moveByKeyboard(node, key)) return;
+			announce(t("gr.tree.moved", "Moved {label}", { label: node.label }));
+			await nextTick();
+			focusRow(node.key);
+		}
+		function filter(value) {
+			treeStore.filter(value);
+		}
+		function resolveNodeClass(classValue, row) {
+			if (!classValue) return void 0;
+			return typeof classValue === "function" ? classValue(row) : classValue;
+		}
+		function resolveBranchLineColorValue(color, node) {
+			if (!color) return void 0;
+			return typeof color === "function" ? color(node) ?? void 0 : color;
+		}
+		function isBranchLineActive(node) {
+			const selectedKey = currentKey.value;
+			if (selectedKey == null) return false;
+			if (node.key === selectedKey) return true;
+			return node.childNodes.some((child) => child.key === selectedKey && !treeStore.isExpandedKey(child.key));
+		}
+		function resolveBranchLineColor(node) {
+			const defaultColor = resolveBranchLineColorValue(treeProps.branchLineColor, node) ?? DEFAULT_BRANCH_LINE_COLOR;
+			if (!isBranchLineActive(node)) return defaultColor;
+			return resolveBranchLineColorValue(treeProps.branchLineActiveColor, node) ?? defaultColor;
+		}
+		/**
+		* Переводит фокус на узел (по умолчанию — на тот, что держит roving tabindex).
+		* Нужен снаружи: `GrTreeSelect` открывает панель и обязан отдать клавиатуру
+		* дереву, иначе стрелки из триггера никуда не ведут.
+		*/
+		function focus(key) {
+			const rows = visibleRows.value;
+			if (rows.length === 0) return false;
+			focusRow(key != null && rows.some((row) => row.node.key === key) ? key : roving.rovingKey.value ?? rows[0].node.key);
+			return true;
+		}
+		onUnmounted(() => clearTimeout(typeaheadTimer));
+		onBeforeUnmount(() => {
+			isUnmounting = true;
+		});
+		__expose({
+			appendNode: treeStore.appendNode,
+			getCheckedKeys: (options) => treeStore.getCheckedKeys(options),
+			setCheckedKeys: (keys) => {
+				treeStore.setCheckedKeys(keys);
+				emit("update:checkedKeys", treeStore.getCheckedKeys());
+			},
+			getHalfCheckedKeys: treeStore.getHalfCheckedKeys,
+			setChecked: (node, checked) => {
+				const changed = treeStore.setChecked(node, checked);
+				if (changed) emitCheck(changed);
+				return Boolean(changed);
+			},
+			filter,
+			focus,
+			getCurrentNode: treeStore.getCurrentNode,
+			setCurrentKey: treeStore.setCurrentKey,
+			getCurrentKey: treeStore.getCurrentKey,
+			getNode: treeStore.getNode,
+			insertNodeAfter: treeStore.insertNodeAfter,
+			insertNodeBefore: treeStore.insertNodeBefore,
+			removeNode: treeStore.removeNode,
+			setCurrentNode: treeStore.setCurrentNode
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				ref_key: "treeRootEl",
+				ref: treeRootEl,
+				"data-gr-tree": "",
+				class: "gr-tree",
+				tabindex: "-1",
+				"data-gr-virtual": unref(treeProps).virtual ? "" : void 0,
+				role: "tree",
+				"aria-multiselectable": unref(treeProps).showCheckbox ? "true" : void 0,
+				style: normalizeStyle(rootStyle.value),
+				onKeydown: onTreeKeydown
+			}, [(openBlock(true), createElementBlock(Fragment, null, renderList(renderedRows.value, (row, windowIndex) => {
+				return openBlock(), createElementBlock("div", {
+					key: row.node.key,
+					ref_for: true,
+					ref: (el) => {
+						if (el) unref(interactionContext).registerNodeEl(row.node.key, el);
+						else releaseNodeEl(row.node.key);
+						if (unref(treeProps).virtual) unref(virtualizer).measure(absoluteIndex(windowIndex), el);
+					},
+					"data-gr-tree-node": "",
+					"data-gr-tree-node-key": row.node.key,
+					role: "treeitem",
+					"aria-level": row.node.level,
+					"aria-posinset": row.posInSet,
+					"aria-setsize": row.setSize,
+					"aria-expanded": row.isLeaf ? void 0 : row.isExpanded,
+					"aria-selected": unref(currentKey) === row.node.key ? "true" : void 0,
+					"aria-checked": ariaCheckedOf(row),
+					"aria-busy": row.isLoading ? "true" : void 0,
+					tabindex: isRovingItem(row.node.key) ? 0 : -1
+				}, [createElementVNode("div", {
+					"data-gr-tree-row": "",
+					class: normalizeClass(["gr-tree__row", [
+						unref(treeProps).highlightCurrent && unref(currentKey) === row.node.key ? "gr-tree__row--current" : "",
+						row.isMatched ? "gr-tree__row--matched" : "",
+						unref(dropTarget)?.key === row.node.key && unref(dropTarget).allowed && unref(dropTarget).type === "inner" ? "gr-tree__row--drop-inner" : "",
+						unref(dropTarget)?.key === row.node.key && unref(dropTarget).allowed && unref(dropTarget).type === "prev" ? "gr-tree__row--drop-prev" : "",
+						unref(dropTarget)?.key === row.node.key && unref(dropTarget).allowed && unref(dropTarget).type === "next" ? "gr-tree__row--drop-next" : "",
+						resolveNodeClass(unref(treeProps).rowClass, row)
+					]]),
+					style: normalizeStyle(rowStyle(row)),
+					onClick: ($event) => onRowActivate(row),
+					onContextmenu: ($event) => onRowContextMenu($event, row.node),
+					onDrop: _cache[1] || (_cache[1] = withModifiers(() => {}, ["prevent"])),
+					onMouseenter: ($event) => onRowMouseEnter(row.node),
+					onMouseleave: ($event) => onRowMouseLeave(row.node)
+				}, [
+					(openBlock(true), createElementBlock(Fragment, null, renderList(row.branchColors, (color, guideIndex) => {
+						return openBlock(), createElementBlock("span", {
+							key: guideIndex,
+							"data-gr-tree-branch-guide": "",
+							class: "gr-tree__branch-guide",
+							style: normalizeStyle(branchGuideStyle(row, guideIndex)),
+							"aria-hidden": "true"
+						}, null, 4);
+					}), 128)),
+					unref(treeProps).draggable ? (openBlock(), createElementBlock("button", {
+						key: 0,
+						type: "button",
+						tabindex: "-1",
+						"data-gr-tree-drag-handle": "",
+						class: normalizeClass(["gr-tree__drag-handle", [
+							shouldShowDragHandle(row.node) ? "gr-tree__drag-handle--visible" : "",
+							canDrag(row.node) ? "" : "gr-tree__drag-handle--disabled",
+							resolveNodeClass(unref(treeProps).dragHandleClass, row)
+						]]),
+						"aria-label": dragLabel.value,
+						"aria-disabled": canDrag(row.node) ? void 0 : "true",
+						onClick: _cache[0] || (_cache[0] = withModifiers(() => {}, ["stop"])),
+						onPointerdown: ($event) => onHandlePointerDown($event, row.node)
+					}, [createElementVNode("span", { class: normalizeClass(["gr-tree__drag-icon", unref(treeProps).dragHandleIcon]) }, null, 2)], 42, _hoisted_4)) : createCommentVNode("", true),
+					!row.isLeaf ? (openBlock(), createElementBlock("button", {
+						key: 1,
+						"data-gr-tree-toggle": "",
+						type: "button",
+						tabindex: "-1",
+						class: normalizeClass(["gr-tree__toggle", resolveNodeClass(unref(treeProps).toggleClass, row)]),
+						"aria-label": row.isExpanded ? collapseLabel.value : expandLabel.value,
+						onClick: withModifiers(($event) => toggleExpand(row.node), ["stop"])
+					}, [row.isLoading ? (openBlock(), createElementBlock("span", _hoisted_6)) : (openBlock(), createElementBlock("span", {
+						key: 1,
+						class: normalizeClass(["gr-tree__toggle-icon", [
+							row.isExpanded ? unref(treeProps).collapseIcon : unref(treeProps).expandIcon,
+							row.isExpanded && unref(treeProps).toggleIconRotate ? "gr-tree__toggle-icon--expanded" : "",
+							resolveNodeClass(unref(treeProps).toggleIconClass, row)
+						]])
+					}, null, 2))], 10, _hoisted_5)) : (openBlock(), createElementBlock("span", {
+						key: 2,
+						class: normalizeClass(["gr-tree__toggle-spacer", resolveNodeClass(unref(treeProps).toggleSpacerClass, row)])
+					}, null, 2)),
+					unref(treeProps).showCheckbox ? (openBlock(), createElementBlock("span", {
+						key: 3,
+						"data-gr-tree-checkbox": "",
+						class: normalizeClass(["gr-tree__checkbox", [checkStateOf(row.node.key) === "checked" ? "gr-tree__checkbox--checked" : "", checkStateOf(row.node.key) === "half" ? "gr-tree__checkbox--half" : ""]]),
+						"aria-hidden": "true",
+						onClick: withModifiers(($event) => toggleChecked(row.node), ["stop"])
+					}, [checkStateOf(row.node.key) !== "unchecked" ? (openBlock(), createElementBlock("span", {
+						key: 0,
+						class: normalizeClass(["gr-tree__checkbox-mark", checkStateOf(row.node.key) === "half" ? "i-lucide-minus" : "i-lucide-check"])
+					}, null, 2)) : createCommentVNode("", true)], 10, _hoisted_7)) : createCommentVNode("", true),
+					createElementVNode("div", { class: normalizeClass(["gr-tree__content", resolveNodeClass(unref(treeProps).contentClass, row)]) }, [renderSlot(_ctx.$slots, "default", {
+						node: row.node,
+						data: row.node.data
+					}, () => [createElementVNode("span", _hoisted_8, toDisplayString(row.node.label), 1)], true)], 2)
+				], 46, _hoisted_3)], 8, _hoisted_2);
+			}), 128))], 44, _hoisted_1);
+		};
+	}
+}), [["__scopeId", "data-v-d84c923c"]]);
+//#endregion
+export { GrTree_default as t };