使用VUE重构项目

frontend/admin/node_modules/element-plus/lib/components/tree/index.d.ts

@@ -0,0 +1,13 @@
+import { SFCWithInstall } from "../../utils/vue/typescript.js";
+import "../../utils/index.js";
+import { TreeEmits, treeEmits, treeProps } from "./src/tree.js";
+import { DragEvents } from "./src/model/useDragNode.js";
+import { AllowDragFunction, AllowDropFunction, AllowDropType, CheckedInfo, FakeNode, FilterNodeMethodFunction, FilterValue, LoadFunction, NodeDropType, RenderContentContext, RenderContentFunction, RootTreeType, TreeComponentProps, TreeData, TreeKey, TreeNodeChildState, TreeNodeData, TreeNodeLoadedDefaultProps, TreeNodeOptions, TreeOptionProps, TreeStoreNodesMap, TreeStoreOptions, hType } from "./src/tree.type.js";
+import { _default } from "./src/tree.vue.js";
+import { TreeInstance } from "./src/instance.js";
+import { NODE_INSTANCE_INJECTION_KEY, ROOT_TREE_INJECTION_KEY, TREE_NODE_MAP_INJECTION_KEY } from "./src/tokens.js";
+
+//#region ../../packages/components/tree/index.d.ts
+declare const ElTree: SFCWithInstall<typeof _default>;
+//#endregion
+export { AllowDragFunction, AllowDropFunction, AllowDropType, CheckedInfo, DragEvents, ElTree, ElTree as default, FakeNode, FilterNodeMethodFunction, FilterValue, LoadFunction, NODE_INSTANCE_INJECTION_KEY, NodeDropType, ROOT_TREE_INJECTION_KEY, RenderContentContext, RenderContentFunction, RootTreeType, TREE_NODE_MAP_INJECTION_KEY, TreeComponentProps, TreeData, TreeEmits, TreeInstance, TreeKey, TreeNodeChildState, TreeNodeData, TreeNodeLoadedDefaultProps, TreeNodeOptions, TreeOptionProps, TreeStoreNodesMap, TreeStoreOptions, hType, treeEmits, treeProps };

frontend/admin/node_modules/element-plus/lib/components/tree/index.js

@@ -0,0 +1,18 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_install = require('../../utils/vue/install.js');
+const require_tokens = require('./src/tokens.js');
+const require_tree = require('./src/tree.js');
+const require_tree$1 = require('./src/tree2.js');
+
+//#region ../../packages/components/tree/index.ts
+const ElTree = require_install.withInstall(require_tree$1.default);
+
+//#endregion
+exports.ElTree = ElTree;
+exports.default = ElTree;
+exports.NODE_INSTANCE_INJECTION_KEY = require_tokens.NODE_INSTANCE_INJECTION_KEY;
+exports.ROOT_TREE_INJECTION_KEY = require_tokens.ROOT_TREE_INJECTION_KEY;
+exports.TREE_NODE_MAP_INJECTION_KEY = require_tokens.TREE_NODE_MAP_INJECTION_KEY;
+exports.treeEmits = require_tree.treeEmits;
+exports.treeProps = require_tree.treeProps;
+//# sourceMappingURL=index.js.map

frontend/admin/node_modules/element-plus/lib/components/tree/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["withInstall","Tree"],"sources":["../../../../../packages/components/tree/index.ts"],"sourcesContent":["import { withInstall } from '@element-plus/utils'\nimport Tree from './src/tree.vue'\n\nimport type { SFCWithInstall } from '@element-plus/utils'\n\nexport const ElTree: SFCWithInstall<typeof Tree> = withInstall(Tree)\n\nexport default ElTree\n\nexport * from './src/tree.type'\nexport * from './src/instance'\nexport * from './src/tokens'\nexport * from './src/tree'\n"],"mappings":";;;;;;;AAKA,MAAa,SAAsCA,4BAAYC,uBAAK"}

frontend/admin/node_modules/element-plus/lib/components/tree/src/instance.d.ts

@@ -0,0 +1,6 @@
+import { _default } from "./tree.vue.js";
+
+//#region ../../packages/components/tree/src/instance.d.ts
+type TreeInstance = InstanceType<typeof _default> & unknown;
+//#endregion
+export { TreeInstance };

frontend/admin/node_modules/element-plus/lib/components/tree/src/instance.js

@@ -0,0 +1 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

frontend/admin/node_modules/element-plus/lib/components/tree/src/model/node.d.ts

@@ -0,0 +1,66 @@
+import { Nullable } from "../../../../utils/typescript.js";
+import "../../../../utils/index.js";
+import { TreeStore } from "./tree-store.js";
+import { FakeNode, TreeKey, TreeNodeData, TreeNodeLoadedDefaultProps, TreeNodeOptions } from "../tree.type.js";
+
+//#region ../../packages/components/tree/src/model/node.d.ts
+declare class Node {
+  id: number;
+  text: string | null;
+  checked: boolean;
+  indeterminate: boolean;
+  data: TreeNodeData;
+  expanded: boolean;
+  parent: Node | null;
+  visible: boolean;
+  isCurrent: boolean;
+  store: TreeStore;
+  isLeafByUser: boolean | undefined;
+  isLeaf: boolean | undefined;
+  canFocus: boolean;
+  level: number;
+  loaded: boolean;
+  childNodes: Node[];
+  loading: boolean;
+  /**
+   * Determines whether the current tree node is effectively checked.
+   *
+   * Rules:
+   * 1. A disabled leaf node is always considered checked.
+   * 2. A non-disabled leaf node reflects its actual checked state.
+   * 3. A non-leaf node is considered checked only when:
+   *    - All of its child nodes are effectively checked, and
+   *    - Each child follows the same evaluation rules:
+   *      - Disabled leaf nodes follow rule #1.
+   *      - Non-leaf child nodes are recursively evaluated under this rule (#3).
+   */
+  isEffectivelyChecked: boolean;
+  constructor(options: TreeNodeOptions);
+  initialize(): void;
+  setData(data: TreeNodeData): void;
+  get label(): string;
+  get key(): TreeKey | null | undefined;
+  get disabled(): boolean;
+  get nextSibling(): Nullable<Node>;
+  get previousSibling(): Nullable<Node>;
+  contains(target: Node, deep?: boolean): boolean;
+  remove(): void;
+  insertChild(child?: FakeNode | Node, index?: number, batch?: boolean): void;
+  insertBefore(child: FakeNode | Node, ref: Node): void;
+  insertAfter(child: FakeNode | Node, ref: Node): void;
+  removeChild(child: Node): void;
+  removeChildByData(data: TreeNodeData | null): void;
+  expand(callback?: (() => void) | null, expandParent?: boolean): void;
+  doCreateChildren(array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps): void;
+  collapse(): void;
+  shouldLoadData(): boolean;
+  updateLeafState(): void;
+  setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void;
+  getChildren(forceInit?: boolean): TreeNodeData | TreeNodeData[] | null;
+  updateChildren(): void;
+  loadData(callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps): void;
+  eachNode(callback: (node: Node) => void): void;
+  reInitChecked(): void;
+}
+//#endregion
+export { Node };

frontend/admin/node_modules/element-plus/lib/components/tree/src/model/node.js

@@ -0,0 +1,367 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_runtime = require('../../../../_virtual/_rolldown/runtime.js');
+const require_types = require('../../../../utils/types.js');
+const require_util = require('./util.js');
+let lodash_unified = require("lodash-unified");
+let vue = require("vue");
+let _vue_shared = require("@vue/shared");
+
+//#region ../../packages/components/tree/src/model/node.ts
+const getChildState = (node) => {
+	let all = true;
+	let none = true;
+	let allWithoutDisable = true;
+	let isEffectivelyChecked = true;
+	for (let i = 0, j = node.length; i < j; i++) {
+		const n = node[i];
+		if (n.checked !== true || n.indeterminate) {
+			all = false;
+			if (!n.disabled) allWithoutDisable = false;
+		}
+		if (n.checked !== false || n.indeterminate) none = false;
+		if (!n.isEffectivelyChecked) isEffectivelyChecked = false;
+	}
+	return {
+		all,
+		none,
+		allWithoutDisable,
+		half: !all && !none,
+		isEffectivelyChecked
+	};
+};
+const reInitChecked = function(node) {
+	if (node.childNodes.length === 0 || node.loading) {
+		node.isEffectivelyChecked = node.disabled || node.checked;
+		return;
+	}
+	const { all, none, half, isEffectivelyChecked } = getChildState(node.childNodes);
+	node.isEffectivelyChecked = isEffectivelyChecked;
+	if (all) {
+		node.checked = true;
+		node.indeterminate = false;
+	} else if (half) {
+		node.checked = false;
+		node.indeterminate = true;
+	} else if (none) {
+		node.checked = false;
+		node.indeterminate = false;
+	}
+	const parent = node.parent;
+	if (!parent || parent.level === 0) return;
+	if (!node.store.checkStrictly) reInitChecked(parent);
+};
+const getPropertyFromData = function(node, prop) {
+	const props = node.store.props;
+	const data = node.data || {};
+	const config = props[prop];
+	if ((0, _vue_shared.isFunction)(config)) return config(data, node);
+	else if ((0, _vue_shared.isString)(config)) return data[config];
+	else if (require_types.isUndefined(config)) {
+		const dataProp = data[prop];
+		return require_types.isUndefined(dataProp) ? "" : dataProp;
+	}
+};
+const setCanFocus = function(childNodes, focus) {
+	childNodes.forEach((item) => {
+		item.canFocus = focus;
+		setCanFocus(item.childNodes, focus);
+	});
+};
+let nodeIdSeed = 0;
+var Node = class Node {
+	constructor(options) {
+		this.isLeafByUser = void 0;
+		this.isLeaf = void 0;
+		this.isEffectivelyChecked = false;
+		this.id = nodeIdSeed++;
+		this.text = null;
+		this.checked = false;
+		this.indeterminate = false;
+		this.data = null;
+		this.expanded = false;
+		this.parent = null;
+		this.visible = true;
+		this.isCurrent = false;
+		this.canFocus = false;
+		for (const name in options) if ((0, _vue_shared.hasOwn)(options, name)) this[name] = options[name];
+		this.level = 0;
+		this.loaded = false;
+		this.childNodes = [];
+		this.loading = false;
+		if (this.parent) this.level = this.parent.level + 1;
+	}
+	initialize() {
+		const store = this.store;
+		if (!store) throw new Error("[Node]store is required!");
+		store.registerNode(this);
+		const props = store.props;
+		if (props && typeof props.isLeaf !== "undefined") {
+			const isLeaf = getPropertyFromData(this, "isLeaf");
+			if (require_types.isBoolean(isLeaf)) this.isLeafByUser = isLeaf;
+		}
+		if (store.lazy !== true && this.data) {
+			this.setData(this.data);
+			if (store.defaultExpandAll) {
+				this.expanded = true;
+				this.canFocus = true;
+			}
+		} else if (this.level > 0 && store.lazy && store.defaultExpandAll && !this.isLeafByUser) this.expand();
+		if (!(0, _vue_shared.isArray)(this.data)) require_util.markNodeData(this, this.data);
+		if (!this.data) return;
+		const defaultExpandedKeys = store.defaultExpandedKeys;
+		const key = store.key;
+		if (key && !(0, lodash_unified.isNil)(this.key) && defaultExpandedKeys && defaultExpandedKeys.includes(this.key)) this.expand(null, store.autoExpandParent);
+		if (key && store.currentNodeKey !== void 0 && this.key === store.currentNodeKey) {
+			store.currentNode && (store.currentNode.isCurrent = false);
+			store.currentNode = this;
+			store.currentNode.isCurrent = true;
+		}
+		if (store.lazy) store._initDefaultCheckedNode(this);
+		this.updateLeafState();
+		if (this.level === 1 || this.parent?.expanded === true) this.canFocus = true;
+	}
+	setData(data) {
+		if (!(0, _vue_shared.isArray)(data)) require_util.markNodeData(this, data);
+		this.data = data;
+		this.childNodes = [];
+		let children;
+		if (this.level === 0 && (0, _vue_shared.isArray)(this.data)) children = this.data;
+		else children = getPropertyFromData(this, "children") || [];
+		for (let i = 0, j = children.length; i < j; i++) this.insertChild({ data: children[i] });
+	}
+	get label() {
+		return getPropertyFromData(this, "label");
+	}
+	get key() {
+		const nodeKey = this.store.key;
+		if (this.data) return this.data[nodeKey];
+		return null;
+	}
+	get disabled() {
+		return getPropertyFromData(this, "disabled");
+	}
+	get nextSibling() {
+		const parent = this.parent;
+		if (parent) {
+			const index = parent.childNodes.indexOf(this);
+			if (index > -1) return parent.childNodes[index + 1];
+		}
+		return null;
+	}
+	get previousSibling() {
+		const parent = this.parent;
+		if (parent) {
+			const index = parent.childNodes.indexOf(this);
+			if (index > -1) return index > 0 ? parent.childNodes[index - 1] : null;
+		}
+		return null;
+	}
+	contains(target, deep = true) {
+		return (this.childNodes || []).some((child) => child === target || deep && child.contains(target));
+	}
+	remove() {
+		const parent = this.parent;
+		if (parent) parent.removeChild(this);
+	}
+	insertChild(child, index, batch) {
+		if (!child) throw new Error("InsertChild error: child is required.");
+		if (!(child instanceof Node)) {
+			if (!batch) {
+				const children = this.getChildren(true);
+				if (!children?.includes(child.data)) if (require_types.isUndefined(index) || index < 0) children?.push(child.data);
+				else children?.splice(index, 0, child.data);
+			}
+			Object.assign(child, {
+				parent: this,
+				store: this.store
+			});
+			child = (0, vue.reactive)(new Node(child));
+			if (child instanceof Node) child.initialize();
+		}
+		child.level = this.level + 1;
+		if (require_types.isUndefined(index) || index < 0) this.childNodes.push(child);
+		else this.childNodes.splice(index, 0, child);
+		this.updateLeafState();
+	}
+	insertBefore(child, ref) {
+		let index;
+		if (ref) index = this.childNodes.indexOf(ref);
+		this.insertChild(child, index);
+	}
+	insertAfter(child, ref) {
+		let index;
+		if (ref) {
+			index = this.childNodes.indexOf(ref);
+			if (index !== -1) index += 1;
+		}
+		this.insertChild(child, index);
+	}
+	removeChild(child) {
+		const children = this.getChildren() || [];
+		const dataIndex = children.indexOf(child.data);
+		if (dataIndex > -1) children.splice(dataIndex, 1);
+		const index = this.childNodes.indexOf(child);
+		if (index > -1) {
+			this.store && this.store.deregisterNode(child);
+			child.parent = null;
+			this.childNodes.splice(index, 1);
+		}
+		this.updateLeafState();
+	}
+	removeChildByData(data) {
+		const targetNode = this.childNodes.find((child) => child.data === data);
+		if (targetNode) this.removeChild(targetNode);
+	}
+	expand(callback, expandParent) {
+		const done = () => {
+			if (expandParent) {
+				let parent = this.parent;
+				while (parent && parent.level > 0) {
+					parent.expanded = true;
+					parent = parent.parent;
+				}
+			}
+			this.expanded = true;
+			if (callback) callback();
+			setCanFocus(this.childNodes, true);
+		};
+		if (this.shouldLoadData()) this.loadData((data) => {
+			if ((0, _vue_shared.isArray)(data)) {
+				if (this.checked) this.setChecked(true, true);
+				else if (!this.store.checkStrictly) reInitChecked(this);
+				done();
+			}
+		});
+		else done();
+	}
+	doCreateChildren(array, defaultProps = {}) {
+		array.forEach((item) => {
+			this.insertChild(Object.assign({ data: item }, defaultProps), void 0, true);
+		});
+	}
+	collapse() {
+		this.expanded = false;
+		setCanFocus(this.childNodes, false);
+	}
+	shouldLoadData() {
+		return Boolean(this.store.lazy === true && this.store.load && !this.loaded);
+	}
+	updateLeafState() {
+		if (this.store.lazy === true && this.loaded !== true && typeof this.isLeafByUser !== "undefined") {
+			this.isLeaf = this.isLeafByUser;
+			this.isEffectivelyChecked = this.isLeaf && this.disabled;
+			return;
+		}
+		const childNodes = this.childNodes;
+		if (!this.store.lazy || this.store.lazy === true && this.loaded === true) {
+			this.isLeaf = !childNodes || childNodes.length === 0;
+			this.isEffectivelyChecked = this.isLeaf && this.disabled;
+			return;
+		}
+		this.isLeaf = false;
+	}
+	setChecked(value, deep, recursion, passValue) {
+		this.indeterminate = value === "half";
+		this.checked = value === true;
+		this.isEffectivelyChecked = !this.childNodes.length && (this.disabled || this.checked);
+		if (this.store.checkStrictly) return;
+		if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
+			const handleDescendants = () => {
+				if (deep) {
+					const childNodes = this.childNodes;
+					for (let i = 0, j = childNodes.length; i < j; i++) {
+						const child = childNodes[i];
+						passValue = passValue || value !== false;
+						const isCheck = child.disabled && child.isLeaf ? child.checked : passValue;
+						child.setChecked(isCheck, deep, true, passValue);
+					}
+					const { half, all, isEffectivelyChecked } = getChildState(childNodes);
+					if (!all) {
+						this.checked = all;
+						this.indeterminate = half;
+					}
+					this.isEffectivelyChecked = !this.childNodes.length ? this.disabled || this.checked : isEffectivelyChecked;
+				}
+			};
+			if (this.shouldLoadData()) {
+				this.loadData(() => {
+					handleDescendants();
+					reInitChecked(this);
+				}, { checked: value !== false });
+				return;
+			} else handleDescendants();
+		}
+		const parent = this.parent;
+		if (!parent || parent.level === 0) return;
+		if (!recursion) reInitChecked(parent);
+	}
+	getChildren(forceInit = false) {
+		if (this.level === 0) return this.data;
+		const data = this.data;
+		if (!data) return null;
+		const props = this.store.props;
+		let children = "children";
+		if (props) children = props.children || "children";
+		if (require_types.isUndefined(data[children])) data[children] = null;
+		if (forceInit && !data[children]) data[children] = [];
+		return data[children];
+	}
+	updateChildren() {
+		const newData = this.getChildren() || [];
+		const oldData = this.childNodes.map((node) => node.data);
+		const newDataMap = {};
+		const newNodes = [];
+		newData.forEach((item, index) => {
+			const key = item[require_util.NODE_KEY];
+			if (!!key && oldData.some((data) => data?.[require_util.NODE_KEY] === key)) newDataMap[key] = {
+				index,
+				data: item
+			};
+			else newNodes.push({
+				index,
+				data: item
+			});
+		});
+		if (!this.store.lazy) oldData.forEach((item) => {
+			if (!newDataMap[item?.[require_util.NODE_KEY]]) this.removeChildByData(item);
+		});
+		newNodes.forEach(({ index, data }) => {
+			this.insertChild({ data }, index);
+		});
+		this.updateLeafState();
+	}
+	loadData(callback, defaultProps = {}) {
+		if (this.store.lazy === true && this.store.load && !this.loaded && (!this.loading || Object.keys(defaultProps).length)) {
+			this.loading = true;
+			const resolve = (children) => {
+				this.childNodes = [];
+				this.doCreateChildren(children, defaultProps);
+				this.loaded = true;
+				this.loading = false;
+				this.updateLeafState();
+				if (callback) callback.call(this, children);
+			};
+			const reject = () => {
+				this.loading = false;
+			};
+			this.store.load(this, resolve, reject);
+		} else if (callback) callback.call(this);
+	}
+	eachNode(callback) {
+		const arr = [this];
+		while (arr.length) {
+			const node = arr.shift();
+			arr.unshift(...node.childNodes);
+			callback(node);
+		}
+	}
+	reInitChecked() {
+		if (this.store.checkStrictly) return;
+		reInitChecked(this);
+	}
+};
+
+//#endregion
+exports.default = Node;
+exports.getChildState = getChildState;
+//# sourceMappingURL=node.js.map

frontend/admin/node_modules/element-plus/lib/components/tree/src/model/tree-store.d.ts

@@ -0,0 +1,55 @@
+import { Node } from "./node.js";
+import { FilterNodeMethodFunction, FilterValue, LoadFunction, TreeData, TreeKey, TreeNodeData, TreeOptionProps, TreeStoreNodesMap, TreeStoreOptions } from "../tree.type.js";
+
+//#region ../../packages/components/tree/src/model/tree-store.d.ts
+declare class TreeStore {
+  currentNode: Node | null;
+  currentNodeKey: TreeKey | null;
+  nodesMap: TreeStoreNodesMap;
+  root: Node;
+  data: TreeData;
+  lazy: boolean;
+  load?: LoadFunction;
+  filterNodeMethod?: FilterNodeMethodFunction;
+  key: TreeKey;
+  defaultCheckedKeys?: TreeKey[];
+  checkStrictly: boolean;
+  defaultExpandedKeys?: TreeKey[];
+  autoExpandParent: boolean;
+  defaultExpandAll: boolean;
+  checkDescendants: boolean;
+  props: TreeOptionProps;
+  constructor(options: TreeStoreOptions);
+  initialize(): void;
+  filter(value: FilterValue): void;
+  setData(newVal: TreeData): void;
+  getNode(data: TreeKey | TreeNodeData | Node): Node;
+  insertBefore(data: TreeNodeData, refData: TreeKey | TreeNodeData | Node): void;
+  insertAfter(data: TreeNodeData, refData: TreeKey | TreeNodeData | Node): void;
+  remove(data: TreeNodeData | Node): void;
+  append(data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node): void;
+  _initDefaultCheckedNodes(): void;
+  _initDefaultCheckedNode(node: Node): void;
+  setDefaultCheckedKey(newVal: TreeKey[]): void;
+  registerNode(node: Node): void;
+  deregisterNode(node: Node): void;
+  getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): TreeNodeData[];
+  getCheckedKeys(leafOnly?: boolean): TreeKey[];
+  getHalfCheckedNodes(): TreeNodeData[];
+  getHalfCheckedKeys(): TreeKey[];
+  _getAllNodes(): Node[];
+  updateChildren(key: TreeKey, data: TreeData): void;
+  _setCheckedKeys(key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+    [key: string]: boolean;
+  }): void;
+  setCheckedNodes(array: Node[], leafOnly?: boolean): void;
+  setCheckedKeys(keys: TreeKey[], leafOnly?: boolean): void;
+  setDefaultExpandedKeys(keys: TreeKey[]): void;
+  setChecked(data: TreeKey | TreeNodeData, checked: boolean, deep: boolean): void;
+  getCurrentNode(): Node | null;
+  setCurrentNode(currentNode: Node): void;
+  setUserCurrentNode(node: Node, shouldAutoExpandParent?: boolean): void;
+  setCurrentNodeKey(key: TreeKey | null, shouldAutoExpandParent?: boolean): void;
+}
+//#endregion
+export { TreeStore };

frontend/admin/node_modules/element-plus/lib/components/tree/src/model/tree-store.js

@@ -0,0 +1,271 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_runtime = require('../../../../_virtual/_rolldown/runtime.js');
+const require_types = require('../../../../utils/types.js');
+const require_util = require('./util.js');
+const require_node = require('./node.js');
+let lodash_unified = require("lodash-unified");
+let vue = require("vue");
+let _vue_shared = require("@vue/shared");
+
+//#region ../../packages/components/tree/src/model/tree-store.ts
+var TreeStore = class {
+	constructor(options) {
+		this.lazy = false;
+		this.checkStrictly = false;
+		this.autoExpandParent = false;
+		this.defaultExpandAll = false;
+		this.checkDescendants = false;
+		this.currentNode = null;
+		this.currentNodeKey = null;
+		for (const option in options) if ((0, _vue_shared.hasOwn)(options, option)) this[option] = options[option];
+		this.nodesMap = {};
+	}
+	initialize() {
+		this.root = new require_node.default({
+			data: this.data,
+			store: this
+		});
+		this.root.initialize();
+		if (this.lazy && this.load) {
+			const loadFn = this.load;
+			loadFn(this.root, (data) => {
+				this.root.doCreateChildren(data);
+				this._initDefaultCheckedNodes();
+			}, _vue_shared.NOOP);
+		} else this._initDefaultCheckedNodes();
+	}
+	filter(value) {
+		const filterNodeMethod = this.filterNodeMethod;
+		const lazy = this.lazy;
+		const traverse = async function(node) {
+			const childNodes = node.root ? node.root.childNodes : node.childNodes;
+			for (const [index, child] of childNodes.entries()) {
+				child.visible = !!filterNodeMethod?.call(child, value, child.data, child);
+				if (index % 80 === 0 && index > 0) await (0, vue.nextTick)();
+				await traverse(child);
+			}
+			if (!node.visible && childNodes.length) {
+				let allHidden = true;
+				allHidden = !childNodes.some((child) => child.visible);
+				if (node.root) node.root.visible = allHidden === false;
+				else node.visible = allHidden === false;
+			}
+			if (!value) return;
+			if (node.visible && !node.isLeaf) {
+				if (!lazy || node.loaded) node.expand();
+			}
+		};
+		traverse(this);
+	}
+	setData(newVal) {
+		if (newVal !== this.root.data) {
+			this.nodesMap = {};
+			this.root.setData(newVal);
+			this._initDefaultCheckedNodes();
+			this.setCurrentNodeKey(this.currentNodeKey);
+		} else this.root.updateChildren();
+	}
+	getNode(data) {
+		if (data instanceof require_node.default) return data;
+		const key = (0, _vue_shared.isObject)(data) ? require_util.getNodeKey(this.key, data) : data;
+		return this.nodesMap[key] || null;
+	}
+	insertBefore(data, refData) {
+		const refNode = this.getNode(refData);
+		refNode.parent?.insertBefore({ data }, refNode);
+	}
+	insertAfter(data, refData) {
+		const refNode = this.getNode(refData);
+		refNode.parent?.insertAfter({ data }, refNode);
+	}
+	remove(data) {
+		const node = this.getNode(data);
+		if (node && node.parent) {
+			if (node === this.currentNode) this.currentNode = null;
+			node.parent.removeChild(node);
+		}
+	}
+	append(data, parentData) {
+		const parentNode = !require_types.isPropAbsent(parentData) ? this.getNode(parentData) : this.root;
+		if (parentNode) parentNode.insertChild({ data });
+	}
+	_initDefaultCheckedNodes() {
+		const defaultCheckedKeys = this.defaultCheckedKeys || [];
+		const nodesMap = this.nodesMap;
+		defaultCheckedKeys.forEach((checkedKey) => {
+			const node = nodesMap[checkedKey];
+			if (node) node.setChecked(true, !this.checkStrictly);
+		});
+	}
+	_initDefaultCheckedNode(node) {
+		const defaultCheckedKeys = this.defaultCheckedKeys || [];
+		if (!(0, lodash_unified.isNil)(node.key) && defaultCheckedKeys.includes(node.key)) node.setChecked(true, !this.checkStrictly);
+	}
+	setDefaultCheckedKey(newVal) {
+		if (newVal !== this.defaultCheckedKeys) {
+			this.defaultCheckedKeys = newVal;
+			this._initDefaultCheckedNodes();
+		}
+	}
+	registerNode(node) {
+		const key = this.key;
+		if (!node || !node.data) return;
+		if (!key) this.nodesMap[node.id] = node;
+		else {
+			const nodeKey = node.key;
+			if (!(0, lodash_unified.isNil)(nodeKey)) this.nodesMap[nodeKey] = node;
+		}
+	}
+	deregisterNode(node) {
+		if (!this.key || !node || !node.data) return;
+		node.childNodes.forEach((child) => {
+			this.deregisterNode(child);
+		});
+		delete this.nodesMap[node.key];
+	}
+	getCheckedNodes(leafOnly = false, includeHalfChecked = false) {
+		const checkedNodes = [];
+		const traverse = function(node) {
+			(node.root ? node.root.childNodes : node.childNodes).forEach((child) => {
+				if ((child.checked || includeHalfChecked && child.indeterminate) && (!leafOnly || leafOnly && child.isLeaf)) checkedNodes.push(child.data);
+				traverse(child);
+			});
+		};
+		traverse(this);
+		return checkedNodes;
+	}
+	getCheckedKeys(leafOnly = false) {
+		return this.getCheckedNodes(leafOnly).map((data) => (data || {})[this.key]);
+	}
+	getHalfCheckedNodes() {
+		const nodes = [];
+		const traverse = function(node) {
+			(node.root ? node.root.childNodes : node.childNodes).forEach((child) => {
+				if (child.indeterminate) nodes.push(child.data);
+				traverse(child);
+			});
+		};
+		traverse(this);
+		return nodes;
+	}
+	getHalfCheckedKeys() {
+		return this.getHalfCheckedNodes().map((data) => (data || {})[this.key]);
+	}
+	_getAllNodes() {
+		const allNodes = [];
+		const nodesMap = this.nodesMap;
+		for (const nodeKey in nodesMap) if ((0, _vue_shared.hasOwn)(nodesMap, nodeKey)) allNodes.push(nodesMap[nodeKey]);
+		return allNodes;
+	}
+	updateChildren(key, data) {
+		const node = this.nodesMap[key];
+		if (!node) return;
+		const childNodes = node.childNodes;
+		for (let i = childNodes.length - 1; i >= 0; i--) {
+			const child = childNodes[i];
+			this.remove(child.data);
+		}
+		for (let i = 0, j = data.length; i < j; i++) {
+			const child = data[i];
+			this.append(child, node.data);
+		}
+	}
+	_setCheckedKeys(key, leafOnly = false, checkedKeys) {
+		const allNodes = this._getAllNodes().sort((a, b) => a.level - b.level);
+		const cache = Object.create(null);
+		const keys = Object.keys(checkedKeys);
+		allNodes.forEach((node) => node.setChecked(false, false));
+		const cacheCheckedChild = (node) => {
+			node.childNodes.forEach((child) => {
+				cache[child.data[key]] = true;
+				if (child.childNodes?.length) cacheCheckedChild(child);
+			});
+		};
+		for (let i = 0, j = allNodes.length; i < j; i++) {
+			const node = allNodes[i];
+			const nodeKey = node.data[key].toString();
+			if (!keys.includes(nodeKey)) {
+				if (node.checked && !cache[nodeKey]) node.setChecked(false, false);
+				continue;
+			}
+			if (node.childNodes.length) cacheCheckedChild(node);
+			if (node.isLeaf || this.checkStrictly) {
+				node.setChecked(true, false);
+				continue;
+			}
+			node.setChecked(true, true);
+			if (leafOnly) {
+				node.setChecked(false, false, true);
+				const traverse = function(node) {
+					node.childNodes.forEach((child) => {
+						if (!child.isLeaf) child.setChecked(false, false, true);
+						traverse(child);
+					});
+					node.reInitChecked();
+				};
+				traverse(node);
+			}
+		}
+	}
+	setCheckedNodes(array, leafOnly = false) {
+		const key = this.key;
+		const checkedKeys = {};
+		array.forEach((item) => {
+			checkedKeys[(item || {})[key]] = true;
+		});
+		this._setCheckedKeys(key, leafOnly, checkedKeys);
+	}
+	setCheckedKeys(keys, leafOnly = false) {
+		this.defaultCheckedKeys = keys;
+		const key = this.key;
+		const checkedKeys = {};
+		keys.forEach((key) => {
+			checkedKeys[key] = true;
+		});
+		this._setCheckedKeys(key, leafOnly, checkedKeys);
+	}
+	setDefaultExpandedKeys(keys) {
+		keys = keys || [];
+		this.defaultExpandedKeys = keys;
+		keys.forEach((key) => {
+			const node = this.getNode(key);
+			if (node) node.expand(null, this.autoExpandParent);
+		});
+	}
+	setChecked(data, checked, deep) {
+		const node = this.getNode(data);
+		if (node) node.setChecked(!!checked, deep);
+	}
+	getCurrentNode() {
+		return this.currentNode;
+	}
+	setCurrentNode(currentNode) {
+		const prevCurrentNode = this.currentNode;
+		if (prevCurrentNode) prevCurrentNode.isCurrent = false;
+		this.currentNode = currentNode;
+		this.currentNode.isCurrent = true;
+	}
+	setUserCurrentNode(node, shouldAutoExpandParent = true) {
+		const key = node[this.key];
+		const currNode = this.nodesMap[key];
+		this.setCurrentNode(currNode);
+		if (shouldAutoExpandParent && this.currentNode && this.currentNode.level > 1) this.currentNode.parent?.expand(null, true);
+	}
+	setCurrentNodeKey(key, shouldAutoExpandParent = true) {
+		this.currentNodeKey = key;
+		if (require_types.isPropAbsent(key)) {
+			this.currentNode && (this.currentNode.isCurrent = false);
+			this.currentNode = null;
+			return;
+		}
+		const node = this.getNode(key);
+		if (node) {
+			this.setCurrentNode(node);
+			if (shouldAutoExpandParent && this.currentNode && this.currentNode.level > 1) this.currentNode.parent?.expand(null, true);
+		}
+	}
+};
+
+//#endregion
+exports.default = TreeStore;
+//# sourceMappingURL=tree-store.js.map

frontend/admin/node_modules/element-plus/lib/components/tree/src/model/useDragNode.d.ts

@@ -0,0 +1,22 @@
+import "./tree-store.js";
+import { Node } from "./node.js";
+import "../tree.js";
+import "../tree.type.js";
+import { InjectionKey, Ref, SetupContext } from "vue";
+
+//#region ../../packages/components/tree/src/model/useDragNode.d.ts
+interface TreeNode {
+  node: Node;
+  $el?: HTMLElement;
+}
+interface DragOptions {
+  event: DragEvent;
+  treeNode: TreeNode;
+}
+interface DragEvents {
+  treeNodeDragStart: (options: DragOptions) => void;
+  treeNodeDragOver: (options: DragOptions) => void;
+  treeNodeDragEnd: (event: DragEvent) => void;
+}
+//#endregion
+export { DragEvents, TreeNode };

frontend/admin/node_modules/element-plus/lib/components/tree/src/model/useDragNode.js

@@ -0,0 +1,126 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../../../_virtual/_rolldown/runtime.js');
+const require_style = require('../../../../utils/dom/style.js');
+const require_index = require('../../../../hooks/use-namespace/index.js');
+let vue = require("vue");
+let _vue_shared = require("@vue/shared");
+
+//#region ../../packages/components/tree/src/model/useDragNode.ts
+const dragEventsKey = Symbol("dragEvents");
+function useDragNodeHandler({ props, ctx, el$, dropIndicator$, store }) {
+	const ns = require_index.useNamespace("tree");
+	const dragState = (0, vue.ref)({
+		showDropIndicator: false,
+		draggingNode: null,
+		dropNode: null,
+		allowDrop: true,
+		dropType: null
+	});
+	const treeNodeDragStart = ({ event, treeNode }) => {
+		if (!event.dataTransfer) return;
+		if ((0, _vue_shared.isFunction)(props.allowDrag) && !props.allowDrag(treeNode.node)) {
+			event.preventDefault();
+			return false;
+		}
+		event.dataTransfer.effectAllowed = "move";
+		try {
+			event.dataTransfer.setData("text/plain", "");
+		} catch {}
+		dragState.value.draggingNode = treeNode;
+		ctx.emit("node-drag-start", treeNode.node, event);
+	};
+	const treeNodeDragOver = ({ event, treeNode }) => {
+		if (!event.dataTransfer) return;
+		const dropNode = treeNode;
+		const oldDropNode = dragState.value.dropNode;
+		if (oldDropNode && oldDropNode.node.id !== dropNode.node.id) require_style.removeClass(oldDropNode.$el, ns.is("drop-inner"));
+		const draggingNode = dragState.value.draggingNode;
+		if (!draggingNode || !dropNode) return;
+		let dropPrev = true;
+		let dropInner = true;
+		let dropNext = true;
+		let userAllowDropInner = true;
+		if ((0, _vue_shared.isFunction)(props.allowDrop)) {
+			dropPrev = props.allowDrop(draggingNode.node, dropNode.node, "prev");
+			userAllowDropInner = dropInner = props.allowDrop(draggingNode.node, dropNode.node, "inner");
+			dropNext = props.allowDrop(draggingNode.node, dropNode.node, "next");
+		}
+		event.dataTransfer.dropEffect = dropInner || dropPrev || dropNext ? "move" : "none";
+		if ((dropPrev || dropInner || dropNext) && oldDropNode?.node.id !== dropNode.node.id) {
+			if (oldDropNode) ctx.emit("node-drag-leave", draggingNode.node, oldDropNode.node, event);
+			ctx.emit("node-drag-enter", draggingNode.node, dropNode.node, event);
+		}
+		if (dropPrev || dropInner || dropNext) dragState.value.dropNode = dropNode;
+		else dragState.value.dropNode = null;
+		if (dropNode.node.nextSibling === draggingNode.node) dropNext = false;
+		if (dropNode.node.previousSibling === draggingNode.node) dropPrev = false;
+		if (dropNode.node.contains(draggingNode.node, false)) dropInner = false;
+		if (draggingNode.node === dropNode.node || draggingNode.node.contains(dropNode.node)) {
+			dropPrev = false;
+			dropInner = false;
+			dropNext = false;
+		}
+		const dropEl = dropNode.$el;
+		const targetPosition = dropEl.querySelector(`.${ns.be("node", "content")}`).getBoundingClientRect();
+		const treePosition = el$.value.getBoundingClientRect();
+		const treeScrollTop = el$.value.scrollTop;
+		let dropType;
+		const prevPercent = dropPrev ? dropInner ? .25 : dropNext ? .45 : 1 : Number.NEGATIVE_INFINITY;
+		const nextPercent = dropNext ? dropInner ? .75 : dropPrev ? .55 : 0 : Number.POSITIVE_INFINITY;
+		let indicatorTop = -9999;
+		const distance = event.clientY - targetPosition.top;
+		if (distance < targetPosition.height * prevPercent) dropType = "before";
+		else if (distance > targetPosition.height * nextPercent) dropType = "after";
+		else if (dropInner) dropType = "inner";
+		else dropType = "none";
+		const iconPosition = dropEl.querySelector(`.${ns.be("node", "expand-icon")}`).getBoundingClientRect();
+		const dropIndicator = dropIndicator$.value;
+		if (dropType === "before") indicatorTop = iconPosition.top - treePosition.top + treeScrollTop;
+		else if (dropType === "after") indicatorTop = iconPosition.bottom - treePosition.top + treeScrollTop;
+		dropIndicator.style.top = `${indicatorTop}px`;
+		dropIndicator.style.left = `${iconPosition.right - treePosition.left}px`;
+		if (dropType === "inner") require_style.addClass(dropEl, ns.is("drop-inner"));
+		else require_style.removeClass(dropEl, ns.is("drop-inner"));
+		dragState.value.showDropIndicator = dropType === "before" || dropType === "after";
+		dragState.value.allowDrop = dragState.value.showDropIndicator || userAllowDropInner;
+		dragState.value.dropType = dropType;
+		ctx.emit("node-drag-over", draggingNode.node, dropNode.node, event);
+	};
+	const treeNodeDragEnd = (event) => {
+		const { draggingNode, dropType, dropNode } = dragState.value;
+		event.preventDefault();
+		if (event.dataTransfer) event.dataTransfer.dropEffect = "move";
+		if (draggingNode?.node.data && dropNode) {
+			const draggingNodeCopy = { data: draggingNode.node.data };
+			if (dropType !== "none") draggingNode.node.remove();
+			if (dropType === "before") dropNode.node.parent?.insertBefore(draggingNodeCopy, dropNode.node);
+			else if (dropType === "after") dropNode.node.parent?.insertAfter(draggingNodeCopy, dropNode.node);
+			else if (dropType === "inner") dropNode.node.insertChild(draggingNodeCopy);
+			if (dropType !== "none") {
+				store.value.registerNode(draggingNodeCopy);
+				if (store.value.key) draggingNode.node.eachNode((node) => {
+					store.value.nodesMap[node.data[store.value.key]]?.setChecked(node.checked, !store.value.checkStrictly);
+				});
+			}
+			require_style.removeClass(dropNode.$el, ns.is("drop-inner"));
+			ctx.emit("node-drag-end", draggingNode.node, dropNode.node, dropType, event);
+			if (dropType !== "none") ctx.emit("node-drop", draggingNode.node, dropNode.node, dropType, event);
+		}
+		if (draggingNode && !dropNode) ctx.emit("node-drag-end", draggingNode.node, null, dropType, event);
+		dragState.value.showDropIndicator = false;
+		dragState.value.draggingNode = null;
+		dragState.value.dropNode = null;
+		dragState.value.allowDrop = true;
+	};
+	(0, vue.provide)(dragEventsKey, {
+		treeNodeDragStart,
+		treeNodeDragOver,
+		treeNodeDragEnd
+	});
+	return { dragState };
+}
+
+//#endregion
+exports.dragEventsKey = dragEventsKey;
+exports.useDragNodeHandler = useDragNodeHandler;
+//# sourceMappingURL=useDragNode.js.map

frontend/admin/node_modules/element-plus/lib/components/tree/src/model/useKeydown.js

@@ -0,0 +1,92 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../../../_virtual/_rolldown/runtime.js');
+const require_aria = require('../../../../constants/aria.js');
+const require_event = require('../../../../utils/dom/event.js');
+const require_index = require('../../../../hooks/use-namespace/index.js');
+let _vueuse_core = require("@vueuse/core");
+let vue = require("vue");
+
+//#region ../../packages/components/tree/src/model/useKeydown.ts
+function useKeydown({ el$ }, store) {
+	const ns = require_index.useNamespace("tree");
+	(0, vue.onMounted)(() => {
+		initTabIndex();
+	});
+	(0, vue.onUpdated)(() => {
+		el$.value?.querySelectorAll("input[type=checkbox]").forEach((checkbox) => {
+			checkbox.setAttribute("tabindex", "-1");
+		});
+	});
+	function canNodeFocus(treeItems, nextIndex) {
+		const currentNode = store.value.getNode(treeItems[nextIndex].dataset.key);
+		return currentNode.canFocus && currentNode.visible && (currentNode.parent?.expanded || currentNode.parent?.level === 0);
+	}
+	const handleKeydown = (ev) => {
+		const currentItem = ev.target;
+		if (!currentItem.className.includes(ns.b("node"))) return;
+		const code = require_event.getEventCode(ev);
+		const treeItems = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
+		const currentIndex = treeItems.indexOf(currentItem);
+		let nextIndex;
+		if ([require_aria.EVENT_CODE.up, require_aria.EVENT_CODE.down].includes(code)) {
+			ev.preventDefault();
+			if (code === require_aria.EVENT_CODE.up) {
+				nextIndex = currentIndex === -1 ? 0 : currentIndex !== 0 ? currentIndex - 1 : treeItems.length - 1;
+				const startIndex = nextIndex;
+				while (true) {
+					if (canNodeFocus(treeItems, nextIndex)) break;
+					nextIndex--;
+					if (nextIndex === startIndex) {
+						nextIndex = -1;
+						break;
+					}
+					if (nextIndex < 0) nextIndex = treeItems.length - 1;
+				}
+			} else {
+				nextIndex = currentIndex === -1 ? 0 : currentIndex < treeItems.length - 1 ? currentIndex + 1 : 0;
+				const startIndex = nextIndex;
+				while (true) {
+					if (canNodeFocus(treeItems, nextIndex)) break;
+					nextIndex++;
+					if (nextIndex === startIndex) {
+						nextIndex = -1;
+						break;
+					}
+					if (nextIndex >= treeItems.length) nextIndex = 0;
+				}
+			}
+			nextIndex !== -1 && treeItems[nextIndex].focus();
+		}
+		if ([require_aria.EVENT_CODE.left, require_aria.EVENT_CODE.right].includes(code)) {
+			ev.preventDefault();
+			currentItem.click();
+		}
+		const hasInput = currentItem.querySelector("[type=\"checkbox\"]");
+		if ([
+			require_aria.EVENT_CODE.enter,
+			require_aria.EVENT_CODE.numpadEnter,
+			require_aria.EVENT_CODE.space
+		].includes(code) && hasInput) {
+			ev.preventDefault();
+			hasInput.click();
+		}
+	};
+	(0, _vueuse_core.useEventListener)(el$, "keydown", handleKeydown);
+	const initTabIndex = () => {
+		if (!el$.value) return;
+		const treeItems = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
+		Array.from(el$.value.querySelectorAll("input[type=checkbox]")).forEach((checkbox) => {
+			checkbox.setAttribute("tabindex", "-1");
+		});
+		const checkedItem = el$.value.querySelectorAll(`.${ns.is("checked")}[role=treeitem]`);
+		if (checkedItem.length) {
+			checkedItem[0].setAttribute("tabindex", "0");
+			return;
+		}
+		treeItems[0]?.setAttribute("tabindex", "0");
+	};
+}
+
+//#endregion
+exports.useKeydown = useKeydown;
+//# sourceMappingURL=useKeydown.js.map

frontend/admin/node_modules/element-plus/lib/components/tree/src/model/useNodeExpandEventBroadcast.js

@@ -0,0 +1,29 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../../../_virtual/_rolldown/runtime.js');
+const require_tokens = require('../tokens.js');
+let vue = require("vue");
+
+//#region ../../packages/components/tree/src/model/useNodeExpandEventBroadcast.ts
+function useNodeExpandEventBroadcast(props) {
+	const parentNodeMap = (0, vue.inject)(require_tokens.TREE_NODE_MAP_INJECTION_KEY, null);
+	let currentNodeMap = {
+		treeNodeExpand: (node) => {
+			if (props.node !== node) props.node?.collapse();
+		},
+		children: /* @__PURE__ */ new Set()
+	};
+	if (parentNodeMap) parentNodeMap.children.add(currentNodeMap);
+	(0, vue.onBeforeUnmount)(() => {
+		if (parentNodeMap) parentNodeMap.children.delete(currentNodeMap);
+		currentNodeMap = null;
+	});
+	(0, vue.provide)(require_tokens.TREE_NODE_MAP_INJECTION_KEY, currentNodeMap);
+	return { broadcastExpanded: (node) => {
+		if (!props.accordion) return;
+		for (const childNode of currentNodeMap.children) childNode.treeNodeExpand(node);
+	} };
+}
+
+//#endregion
+exports.useNodeExpandEventBroadcast = useNodeExpandEventBroadcast;
+//# sourceMappingURL=useNodeExpandEventBroadcast.js.map

frontend/admin/node_modules/element-plus/lib/components/tree/src/model/useNodeExpandEventBroadcast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNodeExpandEventBroadcast.js","names":["TREE_NODE_MAP_INJECTION_KEY"],"sources":["../../../../../../../packages/components/tree/src/model/useNodeExpandEventBroadcast.ts"],"sourcesContent":["import { inject, onBeforeUnmount, provide } from 'vue'\nimport { TREE_NODE_MAP_INJECTION_KEY } from '../tokens'\n\nimport type Node from '../model/node'\n\ninterface NodeMap {\n  treeNodeExpand(node?: Node): void\n  children: Set<NodeMap>\n}\n\ninterface Props {\n  node?: Node\n  accordion: boolean\n}\n\nexport function useNodeExpandEventBroadcast(props: Props) {\n  const parentNodeMap = inject(\n    TREE_NODE_MAP_INJECTION_KEY,\n    null\n  ) as NodeMap | null\n  let currentNodeMap: NodeMap | null = {\n    treeNodeExpand: (node) => {\n      if (props.node !== node) {\n        props.node?.collapse()\n      }\n    },\n    children: new Set(),\n  }\n\n  if (parentNodeMap) {\n    parentNodeMap.children.add(currentNodeMap)\n  }\n\n  onBeforeUnmount(() => {\n    if (parentNodeMap) {\n      parentNodeMap.children.delete(currentNodeMap!)\n    }\n    currentNodeMap = null\n  })\n\n  provide(TREE_NODE_MAP_INJECTION_KEY, currentNodeMap)\n\n  return {\n    broadcastExpanded: (node?: Node): void => {\n      if (!props.accordion) return\n      for (const childNode of currentNodeMap!.children) {\n        childNode.treeNodeExpand(node)\n      }\n    },\n  }\n}\n"],"mappings":";;;;;;AAeA,SAAgB,4BAA4B,OAAc;CACxD,MAAM,gCACJA,4CACA,KACD;CACD,IAAI,iBAAiC;EACnC,iBAAiB,SAAS;AACxB,OAAI,MAAM,SAAS,KACjB,OAAM,MAAM,UAAU;;EAG1B,0BAAU,IAAI,KAAK;EACpB;AAED,KAAI,cACF,eAAc,SAAS,IAAI,eAAe;AAG5C,gCAAsB;AACpB,MAAI,cACF,eAAc,SAAS,OAAO,eAAgB;AAEhD,mBAAiB;GACjB;AAEF,kBAAQA,4CAA6B,eAAe;AAEpD,QAAO,EACL,oBAAoB,SAAsB;AACxC,MAAI,CAAC,MAAM,UAAW;AACtB,OAAK,MAAM,aAAa,eAAgB,SACtC,WAAU,eAAe,KAAK;IAGnC"}

frontend/admin/node_modules/element-plus/lib/components/tree/src/model/util.js

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region ../../packages/components/tree/src/model/util.ts
+const NODE_KEY = "$treeNodeId";
+const markNodeData = function(node, data) {
+	if (!data || data[NODE_KEY]) return;
+	Object.defineProperty(data, NODE_KEY, {
+		value: node.id,
+		enumerable: false,
+		configurable: false,
+		writable: false
+	});
+};
+const getNodeKey = (key, data) => data?.[key || NODE_KEY];
+const handleCurrentChange = (store, emit, setCurrent) => {
+	const preCurrentNode = store.value.currentNode;
+	setCurrent();
+	const currentNode = store.value.currentNode;
+	if (preCurrentNode === currentNode) return;
+	emit("current-change", currentNode ? currentNode.data : null, currentNode);
+};
+
+//#endregion
+exports.NODE_KEY = NODE_KEY;
+exports.getNodeKey = getNodeKey;
+exports.handleCurrentChange = handleCurrentChange;
+exports.markNodeData = markNodeData;
+//# sourceMappingURL=util.js.map

frontend/admin/node_modules/element-plus/lib/components/tree/src/model/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","names":[],"sources":["../../../../../../../packages/components/tree/src/model/util.ts"],"sourcesContent":["import type Node from './node'\nimport type { TreeEmits } from '../tree'\nimport type { RootTreeType, TreeKey, TreeNodeData } from '../tree.type'\n\nexport const NODE_KEY = '$treeNodeId'\n\nexport const markNodeData = function (\n  node: Node,\n  data: TreeNodeData | null\n): void {\n  if (!data || data[NODE_KEY]) return\n  Object.defineProperty(data, NODE_KEY, {\n    value: node.id,\n    enumerable: false,\n    configurable: false,\n    writable: false,\n  })\n}\n\nexport const getNodeKey = (key: TreeKey | undefined, data: TreeNodeData) =>\n  data?.[key || NODE_KEY]\n\nexport const handleCurrentChange = (\n  store: RootTreeType['store'],\n  emit: TreeEmits,\n  setCurrent: () => void\n) => {\n  const preCurrentNode = store.value.currentNode\n  setCurrent()\n  const currentNode = store.value.currentNode\n  if (preCurrentNode === currentNode) return\n\n  emit('current-change', currentNode ? currentNode.data : null, currentNode)\n}\n"],"mappings":";;;AAIA,MAAa,WAAW;AAExB,MAAa,eAAe,SAC1B,MACA,MACM;AACN,KAAI,CAAC,QAAQ,KAAK,UAAW;AAC7B,QAAO,eAAe,MAAM,UAAU;EACpC,OAAO,KAAK;EACZ,YAAY;EACZ,cAAc;EACd,UAAU;EACX,CAAC;;AAGJ,MAAa,cAAc,KAA0B,SACnD,OAAO,OAAO;AAEhB,MAAa,uBACX,OACA,MACA,eACG;CACH,MAAM,iBAAiB,MAAM,MAAM;AACnC,aAAY;CACZ,MAAM,cAAc,MAAM,MAAM;AAChC,KAAI,mBAAmB,YAAa;AAEpC,MAAK,kBAAkB,cAAc,YAAY,OAAO,MAAM,YAAY"}

frontend/admin/node_modules/element-plus/lib/components/tree/src/tokens.d.ts

@@ -0,0 +1,6 @@
+//#region ../../packages/components/tree/src/tokens.d.ts
+declare const ROOT_TREE_INJECTION_KEY = "RootTree";
+declare const NODE_INSTANCE_INJECTION_KEY = "NodeInstance";
+declare const TREE_NODE_MAP_INJECTION_KEY = "TreeNodeMap";
+//#endregion
+export { NODE_INSTANCE_INJECTION_KEY, ROOT_TREE_INJECTION_KEY, TREE_NODE_MAP_INJECTION_KEY };

frontend/admin/node_modules/element-plus/lib/components/tree/src/tokens.js

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region ../../packages/components/tree/src/tokens.ts
+const ROOT_TREE_INJECTION_KEY = "RootTree";
+const NODE_INSTANCE_INJECTION_KEY = "NodeInstance";
+const TREE_NODE_MAP_INJECTION_KEY = "TreeNodeMap";
+
+//#endregion
+exports.NODE_INSTANCE_INJECTION_KEY = NODE_INSTANCE_INJECTION_KEY;
+exports.ROOT_TREE_INJECTION_KEY = ROOT_TREE_INJECTION_KEY;
+exports.TREE_NODE_MAP_INJECTION_KEY = TREE_NODE_MAP_INJECTION_KEY;
+//# sourceMappingURL=tokens.js.map

frontend/admin/node_modules/element-plus/lib/components/tree/src/tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.js","names":[],"sources":["../../../../../../packages/components/tree/src/tokens.ts"],"sourcesContent":["export const ROOT_TREE_INJECTION_KEY = 'RootTree'\n\nexport const NODE_INSTANCE_INJECTION_KEY = 'NodeInstance'\n\nexport const TREE_NODE_MAP_INJECTION_KEY = 'TreeNodeMap'\n"],"mappings":";;;AAAA,MAAa,0BAA0B;AAEvC,MAAa,8BAA8B;AAE3C,MAAa,8BAA8B"}

frontend/admin/node_modules/element-plus/lib/components/tree/src/tree-node-content.js

@@ -0,0 +1,9 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_tree_node_content_vue_vue_type_script_lang = require('./tree-node-content.vue_vue_type_script_lang.js');
+
+//#region ../../packages/components/tree/src/tree-node-content.vue
+var tree_node_content_default = require_tree_node_content_vue_vue_type_script_lang.default;
+
+//#endregion
+exports.default = tree_node_content_default;
+//# sourceMappingURL=tree-node-content.js.map

frontend/admin/node_modules/element-plus/lib/components/tree/src/tree-node-content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-node-content.js","names":[],"sources":["../../../../../../packages/components/tree/src/tree-node-content.vue"],"sourcesContent":["<script lang=\"ts\">\nimport { defineComponent, h, inject, renderSlot } from 'vue'\nimport ElText from '@element-plus/components/text'\nimport { useNamespace } from '@element-plus/hooks'\nimport { NODE_INSTANCE_INJECTION_KEY, ROOT_TREE_INJECTION_KEY } from './tokens'\n\nimport type { ComponentInternalInstance } from 'vue'\nimport type { RootTreeType } from './tree.type'\n\nexport default defineComponent({\n  name: 'ElTreeNodeContent',\n  props: {\n    node: {\n      type: Object,\n      required: true,\n    },\n    renderContent: Function,\n  },\n  setup(props) {\n    const ns = useNamespace('tree')\n    const nodeInstance = inject<ComponentInternalInstance>(\n      NODE_INSTANCE_INJECTION_KEY\n    )\n    const tree = inject<RootTreeType>(ROOT_TREE_INJECTION_KEY)!\n    return () => {\n      const node = props.node\n      const { data, store } = node\n      return props.renderContent\n        ? props.renderContent(h, { _self: nodeInstance, node, data, store })\n        : renderSlot(tree.ctx.slots, 'default', { node, data }, () => [\n            h(\n              ElText,\n              { tag: 'span', truncated: true, class: ns.be('node', 'label') },\n              () => [node.label]\n            ),\n          ])\n    }\n  },\n})\n</script>\n"],"mappings":""}

frontend/admin/node_modules/element-plus/lib/components/tree/src/tree-node-content.vue_vue_type_script_lang.js

@@ -0,0 +1,43 @@
+const require_runtime = require('../../../_virtual/_rolldown/runtime.js');
+const require_index = require('../../../hooks/use-namespace/index.js');
+const require_index$1 = require('../../text/index.js');
+const require_tokens = require('./tokens.js');
+let vue = require("vue");
+
+//#region ../../packages/components/tree/src/tree-node-content.vue?vue&type=script&lang.ts
+var tree_node_content_vue_vue_type_script_lang_default = (0, vue.defineComponent)({
+	name: "ElTreeNodeContent",
+	props: {
+		node: {
+			type: Object,
+			required: true
+		},
+		renderContent: Function
+	},
+	setup(props) {
+		const ns = require_index.useNamespace("tree");
+		const nodeInstance = (0, vue.inject)(require_tokens.NODE_INSTANCE_INJECTION_KEY);
+		const tree = (0, vue.inject)(require_tokens.ROOT_TREE_INJECTION_KEY);
+		return () => {
+			const node = props.node;
+			const { data, store } = node;
+			return props.renderContent ? props.renderContent(vue.h, {
+				_self: nodeInstance,
+				node,
+				data,
+				store
+			}) : (0, vue.renderSlot)(tree.ctx.slots, "default", {
+				node,
+				data
+			}, () => [(0, vue.h)(require_index$1.ElText, {
+				tag: "span",
+				truncated: true,
+				class: ns.be("node", "label")
+			}, () => [node.label])]);
+		};
+	}
+});
+
+//#endregion
+exports.default = tree_node_content_vue_vue_type_script_lang_default;
+//# sourceMappingURL=tree-node-content.vue_vue_type_script_lang.js.map

frontend/admin/node_modules/element-plus/lib/components/tree/src/tree-node-content.vue_vue_type_script_lang.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-node-content.vue_vue_type_script_lang.js","names":[],"sources":["../../../../../../packages/components/tree/src/tree-node-content.vue"],"sourcesContent":["<script lang=\"ts\">\nimport { defineComponent, h, inject, renderSlot } from 'vue'\nimport ElText from '@element-plus/components/text'\nimport { useNamespace } from '@element-plus/hooks'\nimport { NODE_INSTANCE_INJECTION_KEY, ROOT_TREE_INJECTION_KEY } from './tokens'\n\nimport type { ComponentInternalInstance } from 'vue'\nimport type { RootTreeType } from './tree.type'\n\nexport default defineComponent({\n  name: 'ElTreeNodeContent',\n  props: {\n    node: {\n      type: Object,\n      required: true,\n    },\n    renderContent: Function,\n  },\n  setup(props) {\n    const ns = useNamespace('tree')\n    const nodeInstance = inject<ComponentInternalInstance>(\n      NODE_INSTANCE_INJECTION_KEY\n    )\n    const tree = inject<RootTreeType>(ROOT_TREE_INJECTION_KEY)!\n    return () => {\n      const node = props.node\n      const { data, store } = node\n      return props.renderContent\n        ? props.renderContent(h, { _self: nodeInstance, node, data, store })\n        : renderSlot(tree.ctx.slots, 'default', { node, data }, () => [\n            h(\n              ElText,\n              { tag: 'span', truncated: true, class: ns.be('node', 'label') },\n              () => [node.label]\n            ),\n          ])\n    }\n  },\n})\n</script>\n"],"mappings":";;;;;;;AASA,kFAA+B;CAC7B,MAAM;CACN,OAAO;EACL,MAAM;GACJ,MAAM;GACN,UAAU;GACX;EACD,eAAe;EAChB;CACD,MAAM,OAAO;EACX,MAAM,KAAK,2BAAa,OAAM;EAC9B,MAAM,+BACJ,2CACF;EACA,MAAM,uBAA4B,uCAAwB;AAC1D,eAAa;GACX,MAAM,OAAO,MAAM;GACnB,MAAM,EAAE,MAAM,UAAU;AACxB,UAAO,MAAM,gBACT,MAAM,cAAc,OAAG;IAAE,OAAO;IAAc;IAAM;IAAM;IAAO,CAAA,uBACtD,KAAK,IAAI,OAAO,WAAW;IAAE;IAAM;IAAM,QAAQ,YAExD,wBACA;IAAE,KAAK;IAAQ,WAAW;IAAM,OAAO,GAAG,GAAG,QAAQ,QAAO;IAAG,QACzD,CAAC,KAAK,MAAK,CAClB,CACF,CAAA;;;CAGV,CAAA"}

frontend/admin/node_modules/element-plus/lib/components/tree/src/tree-node.js

@@ -0,0 +1,121 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_runtime = require('../../../_virtual/_rolldown/runtime.js');
+const require__plugin_vue_export_helper = require('../../../_virtual/_plugin-vue_export-helper.js');
+const require_tree_node_vue_vue_type_script_lang = require('./tree-node.vue_vue_type_script_lang.js');
+let vue = require("vue");
+
+//#region ../../packages/components/tree/src/tree-node.vue
+const _hoisted_1 = [
+	"aria-expanded",
+	"aria-disabled",
+	"aria-checked",
+	"draggable",
+	"data-key"
+];
+const _hoisted_2 = ["aria-expanded"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+	const _component_el_icon = (0, vue.resolveComponent)("el-icon");
+	const _component_el_checkbox = (0, vue.resolveComponent)("el-checkbox");
+	const _component_loading = (0, vue.resolveComponent)("loading");
+	const _component_node_content = (0, vue.resolveComponent)("node-content");
+	const _component_el_tree_node = (0, vue.resolveComponent)("el-tree-node");
+	const _component_el_collapse_transition = (0, vue.resolveComponent)("el-collapse-transition");
+	return (0, vue.withDirectives)(((0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
+		ref: "node$",
+		class: (0, vue.normalizeClass)([
+			_ctx.ns.b("node"),
+			_ctx.ns.is("expanded", _ctx.expanded),
+			_ctx.ns.is("current", _ctx.node.isCurrent),
+			_ctx.ns.is("hidden", !_ctx.node.visible),
+			_ctx.ns.is("focusable", !_ctx.node.disabled),
+			_ctx.ns.is("checked", !_ctx.node.disabled && _ctx.node.checked),
+			_ctx.getNodeClass(_ctx.node)
+		]),
+		role: "treeitem",
+		tabindex: "-1",
+		"aria-expanded": _ctx.expanded,
+		"aria-disabled": _ctx.node.disabled,
+		"aria-checked": _ctx.node.checked,
+		draggable: _ctx.tree.props.draggable,
+		"data-key": _ctx.getNodeKey(_ctx.node),
+		onClick: _cache[2] || (_cache[2] = (0, vue.withModifiers)((...args) => _ctx.handleClick && _ctx.handleClick(...args), ["stop"])),
+		onContextmenu: _cache[3] || (_cache[3] = (...args) => _ctx.handleContextMenu && _ctx.handleContextMenu(...args)),
+		onDragstart: _cache[4] || (_cache[4] = (0, vue.withModifiers)((...args) => _ctx.handleDragStart && _ctx.handleDragStart(...args), ["stop"])),
+		onDragover: _cache[5] || (_cache[5] = (0, vue.withModifiers)((...args) => _ctx.handleDragOver && _ctx.handleDragOver(...args), ["stop"])),
+		onDragend: _cache[6] || (_cache[6] = (0, vue.withModifiers)((...args) => _ctx.handleDragEnd && _ctx.handleDragEnd(...args), ["stop"])),
+		onDrop: _cache[7] || (_cache[7] = (0, vue.withModifiers)((...args) => _ctx.handleDrop && _ctx.handleDrop(...args), ["stop"]))
+	}, [(0, vue.createElementVNode)("div", {
+		class: (0, vue.normalizeClass)(_ctx.ns.be("node", "content")),
+		style: (0, vue.normalizeStyle)({ paddingLeft: (_ctx.node.level - 1) * _ctx.tree.props.indent + "px" })
+	}, [
+		_ctx.tree.props.icon || _ctx.CaretRight ? ((0, vue.openBlock)(), (0, vue.createBlock)(_component_el_icon, {
+			key: 0,
+			class: (0, vue.normalizeClass)([
+				_ctx.ns.be("node", "expand-icon"),
+				_ctx.ns.is("leaf", _ctx.node.isLeaf),
+				{ expanded: !_ctx.node.isLeaf && _ctx.expanded }
+			]),
+			onClick: (0, vue.withModifiers)(_ctx.handleExpandIconClick, ["stop"])
+		}, {
+			default: (0, vue.withCtx)(() => [((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)(_ctx.tree.props.icon || _ctx.CaretRight)))]),
+			_: 1
+		}, 8, ["class", "onClick"])) : (0, vue.createCommentVNode)("v-if", true),
+		_ctx.showCheckbox ? ((0, vue.openBlock)(), (0, vue.createBlock)(_component_el_checkbox, {
+			key: 1,
+			"model-value": _ctx.node.checked,
+			indeterminate: _ctx.node.indeterminate,
+			disabled: !!_ctx.node.disabled,
+			onClick: _cache[0] || (_cache[0] = (0, vue.withModifiers)(() => {}, ["stop"])),
+			onChange: _ctx.handleCheckChange
+		}, null, 8, [
+			"model-value",
+			"indeterminate",
+			"disabled",
+			"onChange"
+		])) : (0, vue.createCommentVNode)("v-if", true),
+		_ctx.node.loading ? ((0, vue.openBlock)(), (0, vue.createBlock)(_component_el_icon, {
+			key: 2,
+			class: (0, vue.normalizeClass)([_ctx.ns.be("node", "loading-icon"), _ctx.ns.is("loading")])
+		}, {
+			default: (0, vue.withCtx)(() => [(0, vue.createVNode)(_component_loading)]),
+			_: 1
+		}, 8, ["class"])) : (0, vue.createCommentVNode)("v-if", true),
+		(0, vue.createVNode)(_component_node_content, {
+			node: _ctx.node,
+			"render-content": _ctx.renderContent
+		}, null, 8, ["node", "render-content"])
+	], 6), (0, vue.createVNode)(_component_el_collapse_transition, null, {
+		default: (0, vue.withCtx)(() => [!_ctx.renderAfterExpand || _ctx.childNodeRendered ? (0, vue.withDirectives)(((0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
+			key: 0,
+			class: (0, vue.normalizeClass)(_ctx.ns.be("node", "children")),
+			role: "group",
+			"aria-expanded": _ctx.expanded,
+			onClick: _cache[1] || (_cache[1] = (0, vue.withModifiers)(() => {}, ["stop"]))
+		}, [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(_ctx.node.childNodes, (child) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)(_component_el_tree_node, {
+				key: _ctx.getNodeKey(child),
+				"render-content": _ctx.renderContent,
+				"render-after-expand": _ctx.renderAfterExpand,
+				"show-checkbox": _ctx.showCheckbox,
+				node: child,
+				accordion: _ctx.accordion,
+				props: _ctx.props,
+				onNodeExpand: _ctx.handleChildNodeExpand
+			}, null, 8, [
+				"render-content",
+				"render-after-expand",
+				"show-checkbox",
+				"node",
+				"accordion",
+				"props",
+				"onNodeExpand"
+			]);
+		}), 128))], 10, _hoisted_2)), [[vue.vShow, _ctx.expanded]]) : (0, vue.createCommentVNode)("v-if", true)]),
+		_: 1
+	})], 42, _hoisted_1)), [[vue.vShow, _ctx.node.visible]]);
+}
+var tree_node_default = /* @__PURE__ */ require__plugin_vue_export_helper.default(require_tree_node_vue_vue_type_script_lang.default, [["render", _sfc_render]]);
+
+//#endregion
+exports.default = tree_node_default;
+//# sourceMappingURL=tree-node.js.map

frontend/admin/node_modules/element-plus/lib/components/tree/src/tree-node.vue_vue_type_script_lang.js

@@ -0,0 +1,195 @@
+const require_runtime = require('../../../_virtual/_rolldown/runtime.js');
+const require_error = require('../../../utils/error.js');
+const require_index = require('../../../hooks/use-namespace/index.js');
+const require_index$1 = require('../../icon/index.js');
+const require_index$2 = require('../../checkbox/index.js');
+const require_index$3 = require('../../collapse-transition/index.js');
+const require_util = require('./model/util.js');
+const require_node = require('./model/node.js');
+const require_tokens = require('./tokens.js');
+const require_tree_node_content = require('./tree-node-content.js');
+const require_useNodeExpandEventBroadcast = require('./model/useNodeExpandEventBroadcast.js');
+const require_useDragNode = require('./model/useDragNode.js');
+let _element_plus_icons_vue = require("@element-plus/icons-vue");
+let vue = require("vue");
+let _vue_shared = require("@vue/shared");
+
+//#region ../../packages/components/tree/src/tree-node.vue?vue&type=script&lang.ts
+var tree_node_vue_vue_type_script_lang_default = (0, vue.defineComponent)({
+	name: "ElTreeNode",
+	components: {
+		ElCollapseTransition: require_index$3.ElCollapseTransition,
+		ElCheckbox: require_index$2.ElCheckbox,
+		NodeContent: require_tree_node_content.default,
+		ElIcon: require_index$1.ElIcon,
+		Loading: _element_plus_icons_vue.Loading
+	},
+	props: {
+		node: {
+			type: require_node.default,
+			default: () => ({})
+		},
+		props: {
+			type: Object,
+			default: () => ({})
+		},
+		accordion: Boolean,
+		renderContent: Function,
+		renderAfterExpand: Boolean,
+		showCheckbox: Boolean
+	},
+	emits: ["node-expand"],
+	setup(props, ctx) {
+		const ns = require_index.useNamespace("tree");
+		const { broadcastExpanded } = require_useNodeExpandEventBroadcast.useNodeExpandEventBroadcast(props);
+		const tree = (0, vue.inject)(require_tokens.ROOT_TREE_INJECTION_KEY);
+		const expanded = (0, vue.ref)(false);
+		const childNodeRendered = (0, vue.ref)(false);
+		const oldChecked = (0, vue.ref)();
+		const oldIndeterminate = (0, vue.ref)();
+		const node$ = (0, vue.ref)();
+		const dragEvents = (0, vue.inject)(require_useDragNode.dragEventsKey);
+		const instance = (0, vue.getCurrentInstance)();
+		(0, vue.provide)(require_tokens.NODE_INSTANCE_INJECTION_KEY, instance);
+		if (!tree) require_error.debugWarn("Tree", "Can not find node's tree.");
+		if (props.node.expanded) {
+			expanded.value = true;
+			childNodeRendered.value = true;
+		}
+		const childrenKey = tree.props.props["children"] || "children";
+		(0, vue.watch)(() => {
+			const children = props.node.data?.[childrenKey];
+			return children && [...children];
+		}, () => {
+			props.node.updateChildren();
+		});
+		(0, vue.watch)(() => props.node.indeterminate, (val) => {
+			handleSelectChange(props.node.checked, val);
+		});
+		(0, vue.watch)(() => props.node.checked, (val) => {
+			handleSelectChange(val, props.node.indeterminate);
+		});
+		(0, vue.watch)(() => props.node.childNodes.length, () => props.node.reInitChecked());
+		(0, vue.watch)(() => props.node.expanded, (val) => {
+			(0, vue.nextTick)(() => expanded.value = val);
+			if (val) childNodeRendered.value = true;
+		});
+		const getNodeKey$1 = (node) => {
+			return tree.props.nodeKey ? require_util.getNodeKey(tree.props.nodeKey, node.data) : node.id;
+		};
+		const getNodeClass = (node) => {
+			const nodeClassFunc = props.props.class;
+			if (!nodeClassFunc) return {};
+			let className;
+			if ((0, _vue_shared.isFunction)(nodeClassFunc)) {
+				const { data } = node;
+				className = nodeClassFunc(data, node);
+			} else className = nodeClassFunc;
+			if ((0, _vue_shared.isString)(className)) return { [className]: true };
+			else return className;
+		};
+		const handleSelectChange = (checked, indeterminate) => {
+			if (oldChecked.value !== checked || oldIndeterminate.value !== indeterminate) tree.ctx.emit("check-change", props.node.data, checked, indeterminate);
+			oldChecked.value = checked;
+			oldIndeterminate.value = indeterminate;
+		};
+		const handleClick = (e) => {
+			require_util.handleCurrentChange(tree.store, tree.ctx.emit, () => {
+				if (tree?.props?.nodeKey) {
+					const curNodeKey = getNodeKey$1(props.node);
+					tree.store.value.setCurrentNodeKey(curNodeKey);
+				} else tree.store.value.setCurrentNode(props.node);
+			});
+			tree.currentNode.value = props.node;
+			if (tree.props.expandOnClickNode) handleExpandIconClick();
+			if ((tree.props.checkOnClickNode || props.node.isLeaf && tree.props.checkOnClickLeaf && props.showCheckbox) && !props.node.disabled) handleCheckChange(!props.node.checked);
+			tree.ctx.emit("node-click", props.node.data, props.node, instance, e);
+		};
+		const handleContextMenu = (event) => {
+			if (tree.instance.vnode.props?.["onNodeContextmenu"]) {
+				event.stopPropagation();
+				event.preventDefault();
+			}
+			tree.ctx.emit("node-contextmenu", event, props.node.data, props.node, instance);
+		};
+		const handleExpandIconClick = () => {
+			if (props.node.isLeaf) return;
+			if (expanded.value) {
+				tree.ctx.emit("node-collapse", props.node.data, props.node, instance);
+				props.node.collapse();
+			} else props.node.expand(() => {
+				ctx.emit("node-expand", props.node.data, props.node, instance);
+			});
+		};
+		const handleCheckChange = (value) => {
+			const checkStrictly = tree?.props.checkStrictly;
+			const childNodes = props.node.childNodes;
+			if (!checkStrictly && childNodes.length) value = childNodes.some((node) => !node.isEffectivelyChecked);
+			props.node.setChecked(value, !checkStrictly);
+			(0, vue.nextTick)(() => {
+				const store = tree.store.value;
+				tree.ctx.emit("check", props.node.data, {
+					checkedNodes: store.getCheckedNodes(),
+					checkedKeys: store.getCheckedKeys(),
+					halfCheckedNodes: store.getHalfCheckedNodes(),
+					halfCheckedKeys: store.getHalfCheckedKeys()
+				});
+			});
+		};
+		const handleChildNodeExpand = (nodeData, node, instance) => {
+			broadcastExpanded(node);
+			tree.ctx.emit("node-expand", nodeData, node, instance);
+		};
+		const handleDragStart = (event) => {
+			if (!tree.props.draggable) return;
+			dragEvents.treeNodeDragStart({
+				event,
+				treeNode: props
+			});
+		};
+		const handleDragOver = (event) => {
+			event.preventDefault();
+			if (!tree.props.draggable) return;
+			dragEvents.treeNodeDragOver({
+				event,
+				treeNode: {
+					$el: node$.value,
+					node: props.node
+				}
+			});
+		};
+		const handleDrop = (event) => {
+			event.preventDefault();
+		};
+		const handleDragEnd = (event) => {
+			if (!tree.props.draggable) return;
+			dragEvents.treeNodeDragEnd(event);
+		};
+		return {
+			ns,
+			node$,
+			tree,
+			expanded,
+			childNodeRendered,
+			oldChecked,
+			oldIndeterminate,
+			getNodeKey: getNodeKey$1,
+			getNodeClass,
+			handleSelectChange,
+			handleClick,
+			handleContextMenu,
+			handleExpandIconClick,
+			handleCheckChange,
+			handleChildNodeExpand,
+			handleDragStart,
+			handleDragOver,
+			handleDrop,
+			handleDragEnd,
+			CaretRight: _element_plus_icons_vue.CaretRight
+		};
+	}
+});
+
+//#endregion
+exports.default = tree_node_vue_vue_type_script_lang_default;
+//# sourceMappingURL=tree-node.vue_vue_type_script_lang.js.map

frontend/admin/node_modules/element-plus/lib/components/tree/src/tree.d.ts

@@ -0,0 +1,110 @@
+import { EmitFn } from "../../../utils/vue/typescript.js";
+import { EpPropFinalized, EpPropMergeType } from "../../../utils/vue/props/types.js";
+import "../../../utils/index.js";
+import { Node } from "./model/node.js";
+import { AllowDragFunction, AllowDropFunction, CheckedInfo, FilterNodeMethodFunction, LoadFunction, NodeDropType, RenderContentFunction, TreeData, TreeKey, TreeOptionProps } from "./tree.type.js";
+import * as vue from "vue";
+import { ComponentInternalInstance, PropType } from "vue";
+
+//#region ../../packages/components/tree/src/tree.d.ts
+declare const treeProps: {
+  readonly data: EpPropFinalized<(new (...args: any[]) => TreeData) | (() => TreeData) | (((new (...args: any[]) => TreeData) | (() => TreeData)) | null)[], unknown, unknown, () => never[], boolean>;
+  readonly emptyText: {
+    readonly type: PropType<string>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly renderAfterExpand: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly nodeKey: StringConstructor;
+  readonly checkStrictly: BooleanConstructor;
+  readonly defaultExpandAll: BooleanConstructor;
+  readonly expandOnClickNode: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly checkOnClickNode: BooleanConstructor;
+  readonly checkOnClickLeaf: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly checkDescendants: BooleanConstructor;
+  readonly autoExpandParent: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly defaultCheckedKeys: {
+    readonly type: PropType<TreeKey[]>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly defaultExpandedKeys: {
+    readonly type: PropType<TreeKey[]>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly currentNodeKey: {
+    readonly type: PropType<EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly renderContent: {
+    readonly type: PropType<RenderContentFunction>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly showCheckbox: BooleanConstructor;
+  readonly draggable: BooleanConstructor;
+  readonly allowDrag: {
+    readonly type: PropType<AllowDragFunction>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly allowDrop: {
+    readonly type: PropType<AllowDropFunction>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly props: EpPropFinalized<(new (...args: any[]) => TreeOptionProps) | (() => TreeOptionProps) | (((new (...args: any[]) => TreeOptionProps) | (() => TreeOptionProps)) | null)[], unknown, unknown, () => {
+    children: string;
+    label: string;
+    disabled: string;
+  }, boolean>;
+  readonly lazy: BooleanConstructor;
+  readonly highlightCurrent: BooleanConstructor;
+  readonly load: {
+    readonly type: PropType<LoadFunction>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly filterNodeMethod: {
+    readonly type: PropType<FilterNodeMethodFunction>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly accordion: BooleanConstructor;
+  readonly indent: EpPropFinalized<NumberConstructor, unknown, unknown, 18, boolean>;
+  readonly icon: {
+    readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | (((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+};
+declare const treeEmits: {
+  'check-change': (data: any, checked: boolean, indeterminate: boolean) => any;
+  'current-change': (data: any | null, node: Node | null) => boolean;
+  'node-click': (data: any, node: Node, nodeInstance: ComponentInternalInstance | null, evt: MouseEvent) => any;
+  'node-contextmenu': (evt: Event, data: any, node: Node, nodeInstance: ComponentInternalInstance | null) => any;
+  'node-collapse': (data: any, node: Node, nodeInstance: ComponentInternalInstance | null) => any;
+  'node-expand': (data: any, node: Node, nodeInstance: ComponentInternalInstance | null) => any;
+  check: (data: any, checkedInfo: CheckedInfo) => any;
+  'node-drag-start': (node: Node, evt: DragEvent) => DragEvent;
+  'node-drag-end': (draggingNode: Node, dropNode: Node | null, dropType: NodeDropType, evt: DragEvent) => DragEvent;
+  'node-drop': (draggingNode: Node, dropNode: Node, dropType: Exclude<NodeDropType, "none">, evt: DragEvent) => DragEvent;
+  'node-drag-leave': (draggingNode: Node, oldDropNode: Node, evt: DragEvent) => DragEvent;
+  'node-drag-enter': (draggingNode: Node, dropNode: Node, evt: DragEvent) => DragEvent;
+  'node-drag-over': (draggingNode: Node, dropNode: Node, evt: DragEvent) => DragEvent;
+};
+type TreeEmits = EmitFn<typeof treeEmits>;
+//#endregion
+export { TreeEmits, treeEmits, treeProps };

frontend/admin/node_modules/element-plus/lib/components/tree/src/tree.js

@@ -0,0 +1,80 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_types = require('../../../utils/types.js');
+const require_runtime = require('../../../utils/vue/props/runtime.js');
+const require_icon = require('../../../utils/vue/icon.js');
+
+//#region ../../packages/components/tree/src/tree.ts
+const treeProps = require_runtime.buildProps({
+	data: {
+		type: require_runtime.definePropType(Array),
+		default: () => []
+	},
+	emptyText: { type: String },
+	renderAfterExpand: {
+		type: Boolean,
+		default: true
+	},
+	nodeKey: String,
+	checkStrictly: Boolean,
+	defaultExpandAll: Boolean,
+	expandOnClickNode: {
+		type: Boolean,
+		default: true
+	},
+	checkOnClickNode: Boolean,
+	checkOnClickLeaf: {
+		type: Boolean,
+		default: true
+	},
+	checkDescendants: Boolean,
+	autoExpandParent: {
+		type: Boolean,
+		default: true
+	},
+	defaultCheckedKeys: { type: Array },
+	defaultExpandedKeys: { type: Array },
+	currentNodeKey: { type: [String, Number] },
+	renderContent: { type: require_runtime.definePropType(Function) },
+	showCheckbox: Boolean,
+	draggable: Boolean,
+	allowDrag: { type: require_runtime.definePropType(Function) },
+	allowDrop: { type: require_runtime.definePropType(Function) },
+	props: {
+		type: Object,
+		default: () => ({
+			children: "children",
+			label: "label",
+			disabled: "disabled"
+		})
+	},
+	lazy: Boolean,
+	highlightCurrent: Boolean,
+	load: { type: Function },
+	filterNodeMethod: { type: Function },
+	accordion: Boolean,
+	indent: {
+		type: Number,
+		default: 18
+	},
+	icon: { type: require_icon.iconPropType }
+});
+const treeEmits = {
+	"check-change": (data, checked, indeterminate) => data && require_types.isBoolean(checked) && require_types.isBoolean(indeterminate),
+	"current-change": (data, node) => true,
+	"node-click": (data, node, nodeInstance, evt) => data && node && evt instanceof Event,
+	"node-contextmenu": (evt, data, node, nodeInstance) => evt instanceof Event && data && node,
+	"node-collapse": (data, node, nodeInstance) => data && node,
+	"node-expand": (data, node, nodeInstance) => data && node,
+	check: (data, checkedInfo) => data && checkedInfo,
+	"node-drag-start": (node, evt) => node && evt,
+	"node-drag-end": (draggingNode, dropNode, dropType, evt) => draggingNode && evt,
+	"node-drop": (draggingNode, dropNode, dropType, evt) => draggingNode && dropNode && evt,
+	"node-drag-leave": (draggingNode, oldDropNode, evt) => draggingNode && oldDropNode && evt,
+	"node-drag-enter": (draggingNode, dropNode, evt) => draggingNode && dropNode && evt,
+	"node-drag-over": (draggingNode, dropNode, evt) => draggingNode && dropNode && evt
+};
+
+//#endregion
+exports.treeEmits = treeEmits;
+exports.treeProps = treeProps;
+//# sourceMappingURL=tree.js.map

frontend/admin/node_modules/element-plus/lib/components/tree/src/tree.type.d.ts

@@ -0,0 +1,115 @@
+import { TreeStore } from "./model/tree-store.js";
+import { Node } from "./model/node.js";
+import { treeEmits } from "./tree.js";
+import { DragEvents } from "./model/useDragNode.js";
+import { Component, ComponentInternalInstance, Ref, SetupContext, VNode, h } from "vue";
+
+//#region ../../packages/components/tree/src/tree.type.d.ts
+interface RootTreeType {
+  ctx: SetupContext<typeof treeEmits>;
+  props: TreeComponentProps;
+  store: Ref<TreeStore>;
+  root: Ref<Node>;
+  currentNode: Ref<Node>;
+  instance: ComponentInternalInstance;
+}
+type hType = typeof h;
+type TreeData = TreeNodeData[];
+type TreeKey = string | number;
+interface FakeNode {
+  data: TreeNodeData;
+}
+type TreeNodeData = Record<string, any>;
+interface TreeNodeLoadedDefaultProps {
+  checked?: boolean;
+}
+interface TreeNodeChildState {
+  all: boolean;
+  none: boolean;
+  allWithoutDisable: boolean;
+  half: boolean;
+  isEffectivelyChecked: boolean;
+}
+interface TreeNodeOptions {
+  data: TreeNodeData;
+  store: TreeStore;
+  parent?: Node;
+}
+interface TreeStoreNodesMap {
+  [key: string]: Node;
+}
+interface TreeStoreOptions {
+  key?: TreeKey;
+  data: TreeData;
+  lazy: boolean;
+  props: TreeOptionProps;
+  load?: LoadFunction;
+  currentNodeKey?: TreeKey;
+  checkStrictly: boolean;
+  checkDescendants: boolean;
+  defaultCheckedKeys?: TreeKey[];
+  defaultExpandedKeys?: TreeKey[];
+  autoExpandParent: boolean;
+  defaultExpandAll: boolean;
+  filterNodeMethod?: FilterNodeMethodFunction;
+}
+interface TreeOptionProps {
+  children?: string;
+  label?: string | ((data: TreeNodeData, node: Node) => string);
+  disabled?: string | ((data: TreeNodeData, node: Node) => boolean);
+  isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean);
+  class?: (data: TreeNodeData, node: Node) => string | {
+    [key: string]: boolean;
+  };
+}
+type RenderContentFunction = (h: hType, context: RenderContentContext) => VNode | VNode[];
+interface RenderContentContext {
+  _self: ComponentInternalInstance;
+  node: Node;
+  data: TreeNodeData;
+  store: TreeStore;
+}
+type AllowDragFunction = (node: Node) => boolean;
+type AllowDropType = 'inner' | 'prev' | 'next';
+type AllowDropFunction = (draggingNode: Node, dropNode: Node, type: AllowDropType) => boolean;
+type LoadFunction = (rootNode: Node, loadedCallback: (data: TreeData) => void, stopLoading: () => void) => void;
+type FilterValue = any;
+type FilterNodeMethodFunction = (value: FilterValue, data: TreeNodeData, child: Node) => boolean;
+interface TreeComponentProps {
+  data: TreeData;
+  emptyText: string;
+  renderAfterExpand: boolean;
+  nodeKey: string;
+  checkStrictly: boolean;
+  expandOnClickNode: boolean;
+  defaultExpandAll: boolean;
+  checkOnClickNode: boolean;
+  checkOnClickLeaf: boolean;
+  checkDescendants: boolean;
+  autoExpandParent: boolean;
+  defaultCheckedKeys: TreeKey[];
+  defaultExpandedKeys: TreeKey[];
+  currentNodeKey: TreeKey;
+  renderContent: RenderContentFunction;
+  showCheckbox: boolean;
+  draggable: boolean;
+  allowDrag: AllowDragFunction;
+  allowDrop: AllowDropFunction;
+  props: TreeOptionProps;
+  lazy: boolean;
+  highlightCurrent: boolean;
+  load: LoadFunction;
+  filterNodeMethod: FilterNodeMethodFunction;
+  accordion: boolean;
+  indent: number;
+  icon: string | Component;
+}
+type NodeDropType = 'before' | 'after' | 'inner' | 'none';
+interface CheckedInfo {
+  checkedKeys: TreeKey[];
+  checkedNodes: TreeData;
+  halfCheckedKeys: TreeKey[];
+  halfCheckedNodes: TreeData;
+}
+//#endregion
+export { AllowDragFunction, AllowDropFunction, AllowDropType, CheckedInfo, FakeNode, FilterNodeMethodFunction, FilterValue, LoadFunction, NodeDropType, RenderContentContext, RenderContentFunction, RootTreeType, TreeComponentProps, TreeData, TreeKey, TreeNodeChildState, TreeNodeData, TreeNodeLoadedDefaultProps, TreeNodeOptions, TreeOptionProps, TreeStoreNodesMap, TreeStoreOptions, hType };

frontend/admin/node_modules/element-plus/lib/components/tree/src/tree.type.js

@@ -0,0 +1 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

frontend/admin/node_modules/element-plus/lib/components/tree/src/tree.vue_vue_type_script_lang.js

@@ -0,0 +1,220 @@
+const require_runtime = require('../../../_virtual/_rolldown/runtime.js');
+const require_index = require('../../../hooks/use-locale/index.js');
+const require_index$1 = require('../../../hooks/use-namespace/index.js');
+const require_constants = require('../../form/src/constants.js');
+const require_util = require('./model/util.js');
+const require_tree_store = require('./model/tree-store.js');
+const require_tokens = require('./tokens.js');
+const require_useNodeExpandEventBroadcast = require('./model/useNodeExpandEventBroadcast.js');
+const require_useDragNode = require('./model/useDragNode.js');
+const require_tree_node = require('./tree-node.js');
+const require_useKeydown = require('./model/useKeydown.js');
+const require_tree = require('./tree.js');
+let lodash_unified = require("lodash-unified");
+let vue = require("vue");
+
+//#region ../../packages/components/tree/src/tree.vue?vue&type=script&lang.ts
+var tree_vue_vue_type_script_lang_default = (0, vue.defineComponent)({
+	name: "ElTree",
+	components: { ElTreeNode: require_tree_node.default },
+	props: require_tree.treeProps,
+	emits: require_tree.treeEmits,
+	setup(props, ctx) {
+		const { t } = require_index.useLocale();
+		const ns = require_index$1.useNamespace("tree");
+		const store = (0, vue.ref)(new require_tree_store.default({
+			key: props.nodeKey,
+			data: props.data,
+			lazy: props.lazy,
+			props: props.props,
+			load: props.load,
+			currentNodeKey: props.currentNodeKey,
+			checkStrictly: props.checkStrictly,
+			checkDescendants: props.checkDescendants,
+			defaultCheckedKeys: props.defaultCheckedKeys,
+			defaultExpandedKeys: props.defaultExpandedKeys,
+			autoExpandParent: props.autoExpandParent,
+			defaultExpandAll: props.defaultExpandAll,
+			filterNodeMethod: props.filterNodeMethod
+		}));
+		store.value.initialize();
+		const root = (0, vue.ref)(store.value.root);
+		const currentNode = (0, vue.ref)(null);
+		const el$ = (0, vue.ref)(null);
+		const dropIndicator$ = (0, vue.ref)(null);
+		const { broadcastExpanded } = require_useNodeExpandEventBroadcast.useNodeExpandEventBroadcast(props);
+		const { dragState } = require_useDragNode.useDragNodeHandler({
+			props,
+			ctx,
+			el$,
+			dropIndicator$,
+			store
+		});
+		require_useKeydown.useKeydown({ el$ }, store);
+		const instance = (0, vue.getCurrentInstance)();
+		const isSelectTree = (0, vue.computed)(() => {
+			let parent = instance?.parent;
+			while (parent) {
+				if (parent.type.name === "ElTreeSelect") return true;
+				parent = parent.parent;
+			}
+			return false;
+		});
+		const isEmpty = (0, vue.computed)(() => {
+			const { childNodes } = root.value;
+			return (!childNodes || childNodes.length === 0 || childNodes.every(({ visible }) => !visible)) && !isSelectTree.value;
+		});
+		(0, vue.watch)(() => props.currentNodeKey, (newVal) => {
+			store.value.setCurrentNodeKey(newVal ?? null);
+		});
+		(0, vue.watch)(() => props.defaultCheckedKeys, (newVal, oldVal) => {
+			if ((0, lodash_unified.isEqual)(newVal, oldVal)) return;
+			store.value.setDefaultCheckedKey(newVal ?? []);
+		});
+		(0, vue.watch)(() => props.defaultExpandedKeys, (newVal) => {
+			store.value.setDefaultExpandedKeys(newVal ?? []);
+		});
+		(0, vue.watch)(() => props.data, (newVal) => {
+			store.value.setData(newVal);
+		}, { deep: true });
+		(0, vue.watch)(() => props.checkStrictly, (newVal) => {
+			store.value.checkStrictly = newVal;
+		});
+		const filter = (value) => {
+			if (!props.filterNodeMethod) throw new Error("[Tree] filterNodeMethod is required when filter");
+			store.value.filter(value);
+		};
+		const getNodeKey$1 = (node) => {
+			return props.nodeKey ? require_util.getNodeKey(props.nodeKey, node.data) : node.id;
+		};
+		const requireNodeKey = (methodName) => {
+			if (!props.nodeKey) throw new Error(`[Tree] nodeKey is required in ${methodName}`);
+		};
+		const getNodePath = (data) => {
+			requireNodeKey("getNodePath");
+			const node = store.value.getNode(data);
+			if (!node) return [];
+			const path = [node.data];
+			let parent = node.parent;
+			while (parent && parent !== root.value) {
+				path.push(parent.data);
+				parent = parent.parent;
+			}
+			return path.reverse();
+		};
+		const getCheckedNodes = (leafOnly, includeHalfChecked) => {
+			return store.value.getCheckedNodes(leafOnly, includeHalfChecked);
+		};
+		const getCheckedKeys = (leafOnly) => {
+			return store.value.getCheckedKeys(leafOnly);
+		};
+		const getCurrentNode = () => {
+			const currentNode = store.value.getCurrentNode();
+			return currentNode ? currentNode.data : null;
+		};
+		const getCurrentKey = () => {
+			requireNodeKey("getCurrentKey");
+			const currentNode = getCurrentNode();
+			return currentNode ? currentNode[props.nodeKey] : null;
+		};
+		const setCheckedNodes = (nodes, leafOnly) => {
+			requireNodeKey("setCheckedNodes");
+			store.value.setCheckedNodes(nodes, leafOnly);
+		};
+		const setCheckedKeys = (keys, leafOnly) => {
+			requireNodeKey("setCheckedKeys");
+			store.value.setCheckedKeys(keys, leafOnly);
+		};
+		const setChecked = (data, checked, deep) => {
+			store.value.setChecked(data, checked, deep);
+		};
+		const getHalfCheckedNodes = () => {
+			return store.value.getHalfCheckedNodes();
+		};
+		const getHalfCheckedKeys = () => {
+			return store.value.getHalfCheckedKeys();
+		};
+		const setCurrentNode = (node, shouldAutoExpandParent = true) => {
+			requireNodeKey("setCurrentNode");
+			require_util.handleCurrentChange(store, ctx.emit, () => {
+				broadcastExpanded(node);
+				store.value.setUserCurrentNode(node, shouldAutoExpandParent);
+			});
+		};
+		const setCurrentKey = (key = null, shouldAutoExpandParent = true) => {
+			requireNodeKey("setCurrentKey");
+			require_util.handleCurrentChange(store, ctx.emit, () => {
+				broadcastExpanded();
+				store.value.setCurrentNodeKey(key, shouldAutoExpandParent);
+			});
+		};
+		const getNode = (data) => {
+			return store.value.getNode(data);
+		};
+		const remove = (data) => {
+			store.value.remove(data);
+		};
+		const append = (data, parentNode) => {
+			store.value.append(data, parentNode);
+		};
+		const insertBefore = (data, refNode) => {
+			store.value.insertBefore(data, refNode);
+		};
+		const insertAfter = (data, refNode) => {
+			store.value.insertAfter(data, refNode);
+		};
+		const handleNodeExpand = (nodeData, node, instance) => {
+			broadcastExpanded(node);
+			ctx.emit("node-expand", nodeData, node, instance);
+		};
+		const updateKeyChildren = (key, data) => {
+			requireNodeKey("updateKeyChildren");
+			store.value.updateChildren(key, data);
+		};
+		(0, vue.provide)(require_tokens.ROOT_TREE_INJECTION_KEY, {
+			ctx,
+			props,
+			store,
+			root,
+			currentNode,
+			instance
+		});
+		(0, vue.provide)(require_constants.formItemContextKey, void 0);
+		return {
+			ns,
+			store,
+			root,
+			currentNode,
+			dragState,
+			el$,
+			dropIndicator$,
+			isEmpty,
+			filter,
+			getNodeKey: getNodeKey$1,
+			getNodePath,
+			getCheckedNodes,
+			getCheckedKeys,
+			getCurrentNode,
+			getCurrentKey,
+			setCheckedNodes,
+			setCheckedKeys,
+			setChecked,
+			getHalfCheckedNodes,
+			getHalfCheckedKeys,
+			setCurrentNode,
+			setCurrentKey,
+			t,
+			getNode,
+			remove,
+			append,
+			insertBefore,
+			insertAfter,
+			handleNodeExpand,
+			updateKeyChildren
+		};
+	}
+});
+
+//#endregion
+exports.default = tree_vue_vue_type_script_lang_default;
+//# sourceMappingURL=tree.vue_vue_type_script_lang.js.map

frontend/admin/node_modules/element-plus/lib/components/tree/src/tree2.js

@@ -0,0 +1,55 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_runtime = require('../../../_virtual/_rolldown/runtime.js');
+const require__plugin_vue_export_helper = require('../../../_virtual/_plugin-vue_export-helper.js');
+const require_tree_vue_vue_type_script_lang = require('./tree.vue_vue_type_script_lang.js');
+let vue = require("vue");
+
+//#region ../../packages/components/tree/src/tree.vue
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+	const _component_el_tree_node = (0, vue.resolveComponent)("el-tree-node");
+	return (0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
+		ref: "el$",
+		class: (0, vue.normalizeClass)([
+			_ctx.ns.b(),
+			_ctx.ns.is("dragging", !!_ctx.dragState.draggingNode),
+			_ctx.ns.is("drop-not-allow", !_ctx.dragState.allowDrop),
+			_ctx.ns.is("drop-inner", _ctx.dragState.dropType === "inner"),
+			{ [_ctx.ns.m("highlight-current")]: _ctx.highlightCurrent }
+		]),
+		role: "tree"
+	}, [
+		((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(_ctx.root.childNodes, (child) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)(_component_el_tree_node, {
+				key: _ctx.getNodeKey(child),
+				node: child,
+				props: _ctx.props,
+				accordion: _ctx.accordion,
+				"render-after-expand": _ctx.renderAfterExpand,
+				"show-checkbox": _ctx.showCheckbox,
+				"render-content": _ctx.renderContent,
+				onNodeExpand: _ctx.handleNodeExpand
+			}, null, 8, [
+				"node",
+				"props",
+				"accordion",
+				"render-after-expand",
+				"show-checkbox",
+				"render-content",
+				"onNodeExpand"
+			]);
+		}), 128)),
+		_ctx.isEmpty ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
+			key: 0,
+			class: (0, vue.normalizeClass)(_ctx.ns.e("empty-block"))
+		}, [(0, vue.renderSlot)(_ctx.$slots, "empty", {}, () => [(0, vue.createElementVNode)("span", { class: (0, vue.normalizeClass)(_ctx.ns.e("empty-text")) }, (0, vue.toDisplayString)(_ctx.emptyText ?? _ctx.t("el.tree.emptyText")), 3)])], 2)) : (0, vue.createCommentVNode)("v-if", true),
+		(0, vue.withDirectives)((0, vue.createElementVNode)("div", {
+			ref: "dropIndicator$",
+			class: (0, vue.normalizeClass)(_ctx.ns.e("drop-indicator"))
+		}, null, 2), [[vue.vShow, _ctx.dragState.showDropIndicator]])
+	], 2);
+}
+var tree_default = /* @__PURE__ */ require__plugin_vue_export_helper.default(require_tree_vue_vue_type_script_lang.default, [["render", _sfc_render]]);
+
+//#endregion
+exports.default = tree_default;
+//# sourceMappingURL=tree2.js.map

frontend/admin/node_modules/element-plus/lib/components/tree/style/css.js

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+require('../../base/style/css.js');
+require('../../checkbox/style/css.js');
+require('../../text/style/css.js');
+require("element-plus/theme-chalk/el-tree.css");

frontend/admin/node_modules/element-plus/lib/components/tree/style/index.js

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+require('../../base/style/index.js');
+require('../../checkbox/style/index.js');
+require('../../text/style/index.js');
+require("element-plus/theme-chalk/src/tree.scss");