@feugene/granularity 0.18.0 → 0.20.0

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

@@ -1,1371 +0,0 @@
-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 };