vue-hook-optimizer 0.0.76 → 0.0.78

package/dist/index.cjs

@@ -0,0 +1,2016 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const __babel_traverse = __toESM(require("@babel/traverse"));
+const __vue_compiler_sfc = __toESM(require("@vue/compiler-sfc"));
+
+//#region src/analyze/utils.ts
+let NodeType = /* @__PURE__ */ function(NodeType$1) {
+	NodeType$1["var"] = "var";
+	NodeType$1["fun"] = "fun";
+	return NodeType$1;
+}({});
+var NodeCollection = class {
+	constructor(_lineOffset = 0, _addInfo = true) {
+		this.lineOffset = 0;
+		this.addInfo = true;
+		this.nodes = /* @__PURE__ */ new Map();
+		this.lineOffset = _lineOffset;
+		this.addInfo = _addInfo;
+	}
+	addNode(label, node, options = {
+		isComputed: false,
+		isMethod: false,
+		comment: ""
+	}) {
+		if (this.nodes.has(label)) return;
+		if (!options.isComputed && (node.type === "VariableDeclarator" && [
+			"ArrowFunctionExpression",
+			"FunctionDeclaration",
+			"FunctionExpression"
+		].includes(node.init?.type || "") || node.type === "ObjectProperty" && [
+			"ArrowFunctionExpression",
+			"FunctionDeclaration",
+			"FunctionExpression"
+		].includes(node.value?.type || "") || node.type === "FunctionDeclaration" || node.type === "ObjectMethod" || node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") || options.isMethod) this.nodes.set(label, {
+			label,
+			type: NodeType.fun,
+			...this.addInfo ? { info: {
+				line: (node.loc?.start.line || 1) - 1 + this.lineOffset,
+				column: node.loc?.start.column || 0,
+				...options.comment ? { comment: options.comment } : {}
+			} } : {}
+		});
+		else this.nodes.set(label, {
+			label,
+			type: NodeType.var,
+			...this.addInfo ? { info: {
+				line: (node.loc?.start.line || 1) - 1 + this.lineOffset,
+				column: node.loc?.start.column || 0,
+				...options.comment ? { comment: options.comment } : {}
+			} } : {}
+		});
+	}
+	addTypedNode(label, node) {
+		this.nodes.set(label, {
+			label,
+			type: node.type,
+			...this.addInfo ? { info: { ...node.info || {} } } : {}
+		});
+	}
+	getNode(label) {
+		return this.nodes.get(label);
+	}
+	map(graph) {
+		const nodes = new Set(Array.from(graph.nodes).map((node) => {
+			return this.nodes.get(node);
+		}).filter((node) => !!node));
+		const edges = new Map(Array.from(graph.edges).map(([from, to]) => {
+			const labelMap = /* @__PURE__ */ new Map();
+			for (const item of to) {
+				const node = this.nodes.get(item.label);
+				if (!node) continue;
+				const existing = labelMap.get(item.label);
+				if (!existing || existing.type === "get" && item.type === "set") labelMap.set(item.label, {
+					node,
+					type: item.type
+				});
+			}
+			const items = Array.from(labelMap.values());
+			return [this.nodes.get(from), new Set(items)];
+		}));
+		return {
+			nodes,
+			edges
+		};
+	}
+};
+function getComment(node) {
+	let comment = "";
+	node.leadingComments?.forEach((_comment) => {
+		if (_comment.loc.end.line > node.loc.start.line) return;
+		if (_comment.value.trim().startsWith("*")) comment += `${_comment.value.trim().replace(/^\s*\*+\s*\**/gm, "").trim()}\n`;
+	});
+	node.trailingComments?.forEach((_comment) => {
+		if (_comment.loc.end.line > node.loc.start.line) return;
+		if (_comment.value.trim().startsWith("*")) comment += `${_comment.value.trim().replace(/^\s*\*+\s*\**/gm, "").trim()}\n`;
+		else comment += `${_comment.value.trim()}\n`;
+	});
+	return comment.trim();
+}
+function isWritingNode(path) {
+	const assignParent = path.findParent((p) => p.isAssignmentExpression());
+	if (assignParent) {
+		const leftNode = assignParent.node.left;
+		if (leftNode.start != null && path.node.start >= leftNode.start && path.node.end <= leftNode.end) return true;
+	}
+	const updateParent = path.findParent((p) => p.isUpdateExpression());
+	if (updateParent) {
+		const argNode = updateParent.node.argument;
+		if (argNode.start != null && path.node.start >= argNode.start && path.node.end <= argNode.end) return true;
+	}
+	return false;
+}
+function isCallingNode(path) {
+	const parent = path.parentPath;
+	if (parent && parent.isCallExpression()) return parent.node.callee === path.node;
+	return false;
+}
+function getRelationType(path) {
+	if (path.node.type === "Identifier" && isCallingNode(path)) return "call";
+	if (isWritingNode(path)) return "set";
+	return "get";
+}
+
+//#endregion
+//#region src/analyze/setupScript.ts
+const traverse$3 = __babel_traverse.default.default?.default || __babel_traverse.default.default || __babel_traverse.default;
+const ignoreFunctionsName = [
+	"defineProps",
+	"defineEmits",
+	"withDefaults"
+];
+const watchHooks = [
+	"watch",
+	"watchArray",
+	"watchAtMost",
+	"watchDebounced",
+	"watchDeep",
+	"watchIgnorable",
+	"watchImmediate",
+	"watchOnce",
+	"watchPausable",
+	"watchThrottled",
+	"watchTriggerable",
+	"watchWithFilter"
+];
+function processSetup(ast, parentScope, parentPath, _spread, _lineOffset = 0) {
+	const spread = _spread || [];
+	const nodeCollection = new NodeCollection(_lineOffset);
+	const graph = {
+		nodes: /* @__PURE__ */ new Set(),
+		edges: /* @__PURE__ */ new Map(),
+		spread: /* @__PURE__ */ new Map()
+	};
+	traverse$3(ast, {
+		VariableDeclaration(path) {
+			path.node.declarations.forEach((declaration) => {
+				if (declaration.id.type === "ArrayPattern") declaration.id.elements.forEach((element) => {
+					if (element?.type === "Identifier") {
+						const name = element.name;
+						const binding = path.scope.getBinding(name);
+						if (binding && (path.parent.type === "Program" || parentPath?.type === "ObjectMethod" && parentPath.body === path.parent) && !(declaration.init?.type === "CallExpression" && declaration.init?.callee.type === "Identifier" && ignoreFunctionsName.includes(declaration.init?.callee.name))) {
+							graph.nodes.add(name);
+							nodeCollection.addNode(name, element, { comment: getComment(path.node) });
+							if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+						}
+					}
+					if (element?.type === "RestElement" && element.argument.type === "Identifier") {
+						const name = element.argument.name;
+						const binding = path.scope.getBinding(name);
+						if (binding && (path.parent.type === "Program" || parentPath?.type === "ObjectMethod" && parentPath.body === path.parent) && !(declaration.init?.type === "CallExpression" && declaration.init?.callee.type === "Identifier" && ignoreFunctionsName.includes(declaration.init?.callee.name))) {
+							graph.nodes.add(name);
+							nodeCollection.addNode(name, element.argument, { comment: getComment(path.node) });
+							if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+						}
+					}
+				});
+				if (declaration.id.type === "ObjectPattern") declaration.id.properties.forEach((property) => {
+					if (property.type === "ObjectProperty" && property.value.type === "Identifier") {
+						const name = property.value.name;
+						const binding = path.scope.getBinding(name);
+						if (binding && (path.parent.type === "Program" || parentPath?.type === "ObjectMethod" && parentPath.body === path.parent) && !(declaration.init?.type === "CallExpression" && declaration.init?.callee.type === "Identifier" && ignoreFunctionsName.includes(declaration.init?.callee.name))) {
+							graph.nodes.add(name);
+							nodeCollection.addNode(name, property.value, { comment: getComment(property) });
+							if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+						}
+					}
+					if (property.type === "RestElement" && property.argument.type === "Identifier") {
+						const name = property.argument.name;
+						const binding = path.scope.getBinding(name);
+						if (binding && (path.parent.type === "Program" || parentPath?.type === "ObjectMethod" && parentPath.body === path.parent) && !(declaration.init?.type === "CallExpression" && declaration.init?.callee.type === "Identifier" && ignoreFunctionsName.includes(declaration.init?.callee.name))) {
+							graph.nodes.add(name);
+							nodeCollection.addNode(name, property.argument, { comment: getComment(property) });
+							if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+						}
+					}
+				});
+				if (declaration.id?.type === "Identifier") {
+					const name = declaration.id.name;
+					const binding = path.scope.getBinding(name);
+					if (binding && (path.parent.type === "Program" || parentPath?.type === "ObjectMethod" && parentPath.body === path.parent) && !(declaration.init?.type === "CallExpression" && declaration.init?.callee.type === "Identifier" && ignoreFunctionsName.includes(declaration.init?.callee.name))) {
+						graph.nodes.add(name);
+						nodeCollection.addNode(name, declaration, { comment: getComment(path.node) });
+						if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+						if (spread.includes(name)) {
+							if (declaration.init?.type === "ObjectExpression") declaration.init?.properties.forEach((prop) => {
+								if ((prop.type === "ObjectProperty" || prop.type === "ObjectMethod") && prop.key.type === "Identifier") {
+									const keyName = prop.key.name;
+									graph.nodes.add(keyName);
+									nodeCollection.addNode(keyName, prop, { comment: getComment(prop) });
+									if (!graph.edges.get(keyName)) graph.edges.set(keyName, /* @__PURE__ */ new Set());
+									if (graph.spread.has(name)) graph.spread.get(name)?.add(keyName);
+									else graph.spread.set(name, new Set([keyName]));
+								} else if (prop.type === "SpreadElement") console.warn("not support spread in spread");
+							});
+							if (declaration.init?.type === "CallExpression" && declaration.init?.callee.type === "Identifier" && declaration.init?.callee.name === "reactive") {
+								const arg = declaration.init?.arguments[0];
+								if (arg.type === "ObjectExpression") arg.properties.forEach((prop) => {
+									if ((prop.type === "ObjectProperty" || prop.type === "ObjectMethod") && prop.key.type === "Identifier") {
+										const keyName = prop.key.name;
+										graph.nodes.add(keyName);
+										nodeCollection.addNode(keyName, prop, { comment: getComment(prop) });
+										if (!graph.edges.get(keyName)) graph.edges.set(keyName, /* @__PURE__ */ new Set());
+										if (graph.spread.has(name)) graph.spread.get(name)?.add(keyName);
+										else graph.spread.set(name, new Set([keyName]));
+									} else if (prop.type === "SpreadElement") console.warn("not support spread in spread");
+								});
+							}
+						}
+					}
+				}
+			});
+		},
+		FunctionDeclaration(path) {
+			const name = path.node.id?.name;
+			if (name) {
+				const binding = path.scope.getBinding(name);
+				if (binding && (path.parent.type === "Program" || parentPath?.type === "ObjectMethod" && parentPath.body === path.parent)) {
+					graph.nodes.add(name);
+					nodeCollection.addNode(name, path.node.id, {
+						isMethod: true,
+						comment: getComment(path.node)
+					});
+					if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+				}
+			}
+		}
+	}, parentScope, parentPath);
+	function traverseHooks(node, patentScope) {
+		if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.type === "Identifier" || node.type === "CallExpression" && node.callee.type === "Identifier") {
+			const hookName = (() => {
+				if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.type === "Identifier") return node.expression.callee.name;
+				if (node.type === "CallExpression" && node.callee.type === "Identifier") return node.callee.name;
+			})() || "";
+			if (!hookName) return;
+			const hookBinding = patentScope.getBinding(hookName);
+			if (!(hookBinding === void 0 || hookBinding?.scope.block.type === "Program" || parentScope === hookBinding?.scope)) return;
+			const expression = node.type === "ExpressionStatement" ? node.expression : node;
+			const watchArgs = /* @__PURE__ */ new Set();
+			if (hookName === "provide") traverse$3(expression, { Identifier(path1) {
+				const binding = path1.scope.getBinding(path1.node.name);
+				if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) {
+					const _node = nodeCollection.getNode(path1.node.name);
+					if (_node?.info?.used) _node?.info?.used?.add(hookName);
+					else if (_node) _node.info = {
+						..._node?.info,
+						used: new Set([hookName])
+					};
+				}
+			} }, patentScope, node);
+			else if (watchHooks.includes(hookName)) if (expression.arguments[0].type === "Identifier") {
+				const binding = patentScope.getBinding(expression.arguments[0].name);
+				if (graph.nodes.has(expression.arguments[0].name) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) watchArgs.add(expression.arguments[0]);
+			} else traverse$3(expression.arguments[0], { Identifier(path1) {
+				const binding = path1.scope.getBinding(path1.node.name);
+				if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) watchArgs.add(path1.node);
+			} }, patentScope, node);
+			else if (hookName === "useEffect" && expression.arguments[1].type === "ArrayExpression") traverse$3(expression.arguments[1], { Identifier(path1) {
+				const binding = path1.scope.getBinding(path1.node.name);
+				if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) watchArgs.add(path1.node);
+			} }, patentScope, node);
+			expression.arguments.forEach((argNode, index) => {
+				if (watchHooks.includes(hookName) && index === 0 && argNode.type === "Identifier") {
+					const _node = nodeCollection.getNode(argNode.name);
+					if (_node?.info?.used) _node?.info?.used?.add(hookName);
+					else if (_node) _node.info = {
+						..._node?.info,
+						used: new Set([hookName])
+					};
+					return;
+				}
+				if (argNode.type === "Identifier") {
+					const binding = patentScope.getBinding(argNode.name);
+					if (graph.nodes.has(argNode.name) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) {
+						const _node = nodeCollection.getNode(argNode.name);
+						if (_node?.info?.used) _node?.info?.used?.add(hookName);
+						else if (_node) _node.info = {
+							..._node?.info,
+							used: new Set([hookName])
+						};
+					}
+				} else traverse$3(argNode, { Identifier(path1) {
+					const binding = path1.scope.getBinding(path1.node.name);
+					if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) {
+						if ([...watchHooks, "useEffect"].includes(hookName) && watchArgs.size > 0) {
+							const watchArgsNames = Array.from(watchArgs).map((arg) => arg.name);
+							watchArgs.forEach((watchArg) => {
+								if (!watchArgsNames.includes(path1.node.name)) graph.edges.get(watchArg.name)?.add({
+									label: path1.node.name,
+									type: getRelationType(path1)
+								});
+							});
+						}
+						const _node = nodeCollection.getNode(path1.node.name);
+						if (_node?.info?.used) _node?.info?.used?.add(hookName);
+						else if (_node) _node.info = {
+							..._node?.info,
+							used: new Set([hookName])
+						};
+					}
+				} }, patentScope, node);
+			});
+		}
+	}
+	traverse$3(ast, {
+		FunctionDeclaration(path) {
+			const name = path.node.id?.name;
+			if (name && graph.nodes.has(name)) traverse$3(path.node.body, {
+				Identifier(path1) {
+					const binding = path1.scope.getBinding(path1.node.name);
+					if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) graph.edges.get(name)?.add({
+						label: path1.node.name,
+						type: getRelationType(path1)
+					});
+				},
+				MemberExpression(path1) {
+					if (path1.node.object.type === "Identifier" && spread.includes(path1.node.object.name)) {
+						const binding = path1.scope.getBinding(path1.node.object.name);
+						if (spread.includes(path1.node.object.name) && path1.node.property.type === "Identifier" && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) graph.edges.get(name)?.add({
+							label: path1.node.property.name,
+							type: getRelationType(path1)
+						});
+					}
+				}
+			}, path.scope, path);
+		},
+		VariableDeclarator(path) {
+			if (path.node.init) {
+				if (path.node.id.type === "ArrayPattern") path.node.id.elements.forEach((element) => {
+					if (element?.type === "Identifier") {
+						const name = element.name;
+						if (name && graph.nodes.has(name) && path.node.init?.type === "CallExpression") traverse$3(path.node.init, {
+							Identifier(path1) {
+								const binding = path1.scope.getBinding(path1.node.name);
+								if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) graph.edges.get(name)?.add({
+									label: path1.node.name,
+									type: getRelationType(path1)
+								});
+							},
+							MemberExpression(path1) {
+								if (path1.node.object.type === "Identifier" && spread.includes(path1.node.object.name)) {
+									const binding = path1.scope.getBinding(path1.node.object.name);
+									if (spread.includes(path1.node.object.name) && path1.node.property.type === "Identifier" && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) graph.edges.get(name)?.add({
+										label: path1.node.property.name,
+										type: getRelationType(path1)
+									});
+								}
+							}
+						}, path.scope, path);
+					}
+				});
+				else if (path.node.id.type === "ObjectPattern") path.node.id.properties.forEach((property) => {
+					if (property.type === "ObjectProperty" && property.value.type === "Identifier") {
+						const name = property.value.name;
+						if (name && graph.nodes.has(name) && path.node.init) traverse$3(path.node.init, {
+							Identifier(path1) {
+								const binding = path1.scope.getBinding(path1.node.name);
+								if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) graph.edges.get(name)?.add({
+									label: path1.node.name,
+									type: getRelationType(path1)
+								});
+							},
+							MemberExpression(path1) {
+								if (path1.node.object.type === "Identifier" && spread.includes(path1.node.object.name)) {
+									const binding = path1.scope.getBinding(path1.node.object.name);
+									if (spread.includes(path1.node.object.name) && path1.node.property.type === "Identifier" && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) graph.edges.get(name)?.add({
+										label: path1.node.property.name,
+										type: getRelationType(path1)
+									});
+								}
+							}
+						}, path.scope, path);
+					}
+				});
+				else if ([
+					"CallExpression",
+					"ArrowFunctionExpression",
+					"FunctionDeclaration"
+				].includes(path.node.init.type) && path.node.id.type === "Identifier") {
+					if (path.node.init.type === "CallExpression" && path.node.init.callee.type === "Identifier" && [...watchHooks, "watchEffect"].includes(path.node.init.callee.name)) traverseHooks(path.node.init, path.scope);
+					const name = path.node.id?.name;
+					if (name && graph.nodes.has(name)) traverse$3(path.node.init, {
+						Identifier(path1) {
+							const binding = path1.scope.getBinding(path1.node.name);
+							if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) graph.edges.get(name)?.add({
+								label: path1.node.name,
+								type: getRelationType(path1)
+							});
+						},
+						MemberExpression(path1) {
+							if (path1.node.object.type === "Identifier" && spread.includes(path1.node.object.name)) {
+								const binding = path1.scope.getBinding(path1.node.object.name);
+								if (spread.includes(path1.node.object.name) && path1.node.property.type === "Identifier" && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) graph.edges.get(name)?.add({
+									label: path1.node.property.name,
+									type: getRelationType(path1)
+								});
+							}
+						}
+					}, path.scope, path);
+				} else if (path.node.id.type === "Identifier") {
+					const name = path.node.id.name;
+					if (path.node.init.type === "Identifier") {
+						const binding = path.scope.getBinding(path.node.init.name);
+						if (graph.nodes.has(path.node.init.name) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) graph.edges.get(name)?.add({
+							label: path.node.init.name,
+							type: getRelationType(path)
+						});
+					} else traverse$3(path.node.init, { Identifier(path1) {
+						const binding = path1.scope.getBinding(path1.node.name);
+						if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) graph.edges.get(name)?.add({
+							label: path1.node.name,
+							type: getRelationType(path1)
+						});
+					} }, path.scope, path);
+				}
+			}
+		},
+		ObjectMethod(path) {
+			if (path.node.key.type === "Identifier" && graph.nodes.has(path.node.key.name)) {
+				const name = path.node.key.name;
+				traverse$3(path.node.body, {
+					Identifier(path1) {
+						const binding = path1.scope.getBinding(path1.node.name);
+						if (graph.nodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node) && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) graph.edges.get(name)?.add({
+							label: path1.node.name,
+							type: getRelationType(path1)
+						});
+					},
+					MemberExpression(path1) {
+						if (path1.node.object.type === "Identifier" && spread.includes(path1.node.object.name)) {
+							const binding = path1.scope.getBinding(path1.node.object.name);
+							if (spread.includes(path1.node.object.name) && path1.node.property.type === "Identifier" && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) graph.edges.get(name)?.add({
+								label: path1.node.property.name,
+								type: getRelationType(path1)
+							});
+						}
+					}
+				}, path.scope, path);
+			}
+		},
+		ObjectProperty(path) {
+			if (path.node.key.type === "Identifier" && graph.nodes.has(path.node.key.name)) {
+				const name = path.node.key.name;
+				traverse$3(path.node.value, { MemberExpression(path1) {
+					if (path1.node.object.type === "Identifier" && spread.includes(path1.node.object.name)) {
+						const binding = path1.scope.getBinding(path1.node.object.name);
+						if (spread.includes(path1.node.object.name) && path1.node.property.type === "Identifier" && (binding?.scope.block.type === "Program" || parentScope === binding?.scope)) graph.edges.get(name)?.add({
+							label: path1.node.property.name,
+							type: getRelationType(path1)
+						});
+					}
+				} }, path.scope, path);
+			}
+		},
+		ExpressionStatement(path) {
+			if (path.type === "ExpressionStatement" && path.node.expression.type === "CallExpression" && path.node.expression.callee.type === "Identifier") {
+				const name = path.node.expression.callee.name;
+				if (graph.nodes.has(name) && path.scope.block.type === "Program") {
+					const _node = nodeCollection.getNode(name);
+					if (_node?.info?.used) _node?.info?.used?.add("Call Expression");
+					else if (_node) _node.info = {
+						..._node?.info,
+						used: new Set(["Call Expression"])
+					};
+				} else traverseHooks(path.node.expression, path.scope);
+			}
+			if (path.type === "ExpressionStatement" && path.node.expression.type === "AssignmentExpression" && path.node.expression.right.type === "CallExpression" && path.node.expression.right.callee.type === "Identifier") traverseHooks(path.node.expression.right, path.scope);
+		}
+	}, parentScope, parentPath);
+	return {
+		graph,
+		nodeCollection
+	};
+}
+function analyze$1(content, lineOffset = 0, jsx = false) {
+	const ast = (0, __vue_compiler_sfc.babelParse)(content, {
+		sourceType: "module",
+		plugins: ["typescript", ...jsx ? ["jsx"] : []]
+	});
+	const { graph, nodeCollection } = processSetup(ast, void 0, void 0, void 0, lineOffset);
+	return nodeCollection.map(graph);
+}
+
+//#endregion
+//#region src/analyze/options.ts
+const traverse$2 = __babel_traverse.default.default?.default || __babel_traverse.default.default || __babel_traverse.default;
+const vueLifeCycleHooks = [
+	"beforeCreate",
+	"created",
+	"beforeMount",
+	"mounted",
+	"beforeUpdate",
+	"updated",
+	"beforeDestroy",
+	"destroyed",
+	"activated",
+	"deactivated",
+	"errorCaptured",
+	"renderTracked",
+	"renderTriggered",
+	"provide"
+];
+function analyze(content, lineOffset = 0, jsx = false) {
+	const ast = (0, __vue_compiler_sfc.babelParse)(content, {
+		sourceType: "module",
+		plugins: ["typescript", ...jsx ? ["jsx"] : []]
+	});
+	let nodeCollection = new NodeCollection(lineOffset);
+	const tNodes = /* @__PURE__ */ new Map();
+	const graph = {
+		nodes: /* @__PURE__ */ new Set(),
+		edges: /* @__PURE__ */ new Map()
+	};
+	/** used in render block or setup return */
+	const nodesUsedInTemplate = /* @__PURE__ */ new Set();
+	function process(node, path) {
+		traverse$2(node, {
+			ObjectProperty(path1) {
+				if (path.node.declaration.type === "ObjectExpression" && path1.parent === path.node.declaration || path.node.declaration.type === "CallExpression" && path1.parent === path.node.declaration.arguments[0]) {
+					if (path1.node.key.type === "Identifier" && path1.node.key.name === "data" && (path1.node.value.type === "ArrowFunctionExpression" || path1.node.value.type === "FunctionExpression")) {
+						const dataNode = path1.node.value;
+						traverse$2(dataNode, { ReturnStatement(path2) {
+							if (path2.parent === dataNode.body) {
+								if (path2.node.argument?.type === "ObjectExpression") path2.node.argument.properties.forEach((prop) => {
+									if (prop.type === "ObjectProperty") {
+										if (prop.key.type === "Identifier") {
+											const name = prop.key.name;
+											graph.nodes.add(name);
+											tNodes.set(name, prop.key);
+											nodeCollection.addNode(name, prop, { comment: getComment(prop) });
+											if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+										}
+									}
+								});
+							}
+						} }, path1.scope, path1);
+					}
+					if (path1.node.key.type === "Identifier" && path1.node.key.name === "computed") {
+						const computedNode = path1.node;
+						if (computedNode.value.type === "ObjectExpression") computedNode.value.properties.forEach((prop) => {
+							if (prop.type === "ObjectProperty" || prop.type === "ObjectMethod") {
+								if (prop.key.type === "Identifier") {
+									const name = prop.key.name;
+									graph.nodes.add(name);
+									tNodes.set(name, prop.key);
+									nodeCollection.addNode(name, prop, {
+										isComputed: true,
+										comment: getComment(prop)
+									});
+									if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+								}
+							}
+						});
+					}
+					if (path1.node.key.type === "Identifier" && path1.node.key.name === "methods") {
+						const methodsNode = path1.node;
+						if (methodsNode.value.type === "ObjectExpression") methodsNode.value.properties.forEach((prop) => {
+							if (prop.type === "ObjectProperty" || prop.type === "ObjectMethod") {
+								if (prop.key.type === "Identifier") {
+									const name = prop.key.name;
+									graph.nodes.add(name);
+									tNodes.set(name, prop.key);
+									nodeCollection.addNode(name, prop, {
+										isMethod: true,
+										comment: getComment(prop)
+									});
+									if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+								}
+							}
+						});
+					}
+					if (path1.node.key.type === "Identifier" && path1.node.key.name === "render" && (path1.node.value.type === "ArrowFunctionExpression" || path1.node.value.type === "FunctionExpression")) traverse$2(path1.node.value, { ReturnStatement(path2) {
+						const templateNode = path2.node;
+						traverse$2(templateNode, { MemberExpression(path3) {
+							if (path3.node.object && path3.node.object.type === "ThisExpression") {
+								if (path3.node.property && path3.node.property.type === "Identifier") nodesUsedInTemplate.add(path3.node.property.name);
+							}
+						} }, path2.scope, path2);
+					} }, path1.scope, path1);
+				}
+			},
+			ObjectMethod(path1) {
+				if (path.node.declaration.type === "ObjectExpression" && path1.parent === path.node.declaration || path.node.declaration.type === "CallExpression" && path1.parent === path.node.declaration.arguments[0]) {
+					if (path1.node.key.type === "Identifier" && path1.node.key.name === "setup") {
+						const setupNode = path1.node;
+						const spread = [];
+						traverse$2(setupNode, { ReturnStatement(path2) {
+							if (path2.node.argument?.type === "ObjectExpression") {
+								const returnNode = path2.node.argument;
+								traverse$2(returnNode, { SpreadElement(path3) {
+									if (path3.node.argument.type === "CallExpression" && path3.node.argument.callee.type === "Identifier" && path3.node.argument.callee.name === "toRefs" && path3.node.argument.arguments[0].type === "Identifier") spread.push(path3.node.argument.arguments[0].name);
+									else if (path3.node.argument.type === "Identifier") spread.push(path3.node.argument.name);
+								} }, path2.scope, path2);
+							}
+							if (path2.node.argument?.type === "FunctionExpression" || path2.node.argument?.type === "ArrowFunctionExpression") {
+								const templateNode = path2.node.argument.body;
+								traverse$2(templateNode, {
+									Identifier(path3) {
+										const binding = path3.scope.getBinding(path3.node.name);
+										if (binding?.scope === path1.scope) nodesUsedInTemplate.add(path3.node.name);
+									},
+									JSXIdentifier(path3) {
+										const binding = path3.scope.getBinding(path3.node.name);
+										if (binding?.scope === path1.scope) nodesUsedInTemplate.add(path3.node.name);
+									}
+								}, path2.scope, path2);
+							}
+						} }, path1.scope, path1);
+						const { graph: { nodes: tempNodes, edges: tempEdges, spread: tempSpread }, nodeCollection: tempNodeCollection } = processSetup(setupNode, path1.scope, setupNode, spread, lineOffset);
+						traverse$2(setupNode, { ReturnStatement(path2) {
+							if (path2.scope !== path1.scope) return;
+							if (path2.node.argument?.type === "ObjectExpression") {
+								const returnNode = path2.node.argument;
+								traverse$2(returnNode, {
+									ObjectProperty(path3) {
+										if (path3.parent === returnNode) {
+											if (path3.node.key.type === "Identifier" && path3.node.value.type === "Identifier" && tempNodes.has(path3.node.value.name)) {
+												const valName = path3.node.value.name;
+												if (!graph.nodes.has(valName)) {
+													graph.nodes.add(valName);
+													tNodes.set(valName, path3.node.value);
+													nodeCollection.addTypedNode(valName, tempNodeCollection.nodes.get(valName));
+												}
+												if (!graph.edges.has(valName)) graph.edges.set(valName, new Set([...Array.from(tempEdges.get(valName) || /* @__PURE__ */ new Set())]));
+												const name = path3.node.key.name;
+												if (name !== valName) {
+													graph.nodes.add(name);
+													tNodes.set(name, path3.node.key);
+													nodeCollection.addNode(name, path3.node.key, { comment: getComment(path3.node) });
+													graph.edges.set(name, new Set([{
+														label: valName,
+														type: getRelationType(path3)
+													}]));
+												}
+											}
+										}
+									},
+									SpreadElement(path3) {
+										if (path3.node.argument.type === "CallExpression" && path3.node.argument.callee.type === "Identifier" && path3.node.argument.callee.name === "toRefs" && path3.node.argument.arguments[0].type === "Identifier" && tempSpread.get(path3.node.argument.arguments[0].name)) tempSpread.get(path3.node.argument.arguments[0].name)?.forEach((name) => {
+											graph.nodes.add(name);
+											tNodes.set(name, path3.node.argument.arguments[0]);
+											nodeCollection.addTypedNode(name, tempNodeCollection.nodes.get(name));
+											if (!graph.edges.get(name)) {
+												graph.edges.set(name, /* @__PURE__ */ new Set());
+												tempEdges.get(name)?.forEach((edge) => {
+													graph.edges.get(name)?.add(edge);
+												});
+											}
+										});
+										else if (path3.node.argument.type === "Identifier" && tempSpread.get(path3.node.argument.name)) tempSpread.get(path3.node.argument.name)?.forEach((name) => {
+											graph.nodes.add(name);
+											tNodes.set(name, path3.node.argument);
+											nodeCollection.addTypedNode(name, tempNodeCollection.nodes.get(name));
+											if (!graph.edges.get(name)) {
+												graph.edges.set(name, /* @__PURE__ */ new Set());
+												tempEdges.get(name)?.forEach((edge) => {
+													graph.edges.get(name)?.add(edge);
+												});
+											}
+										});
+									}
+								}, path2.scope, path2);
+							} else {
+								graph.edges = tempEdges;
+								graph.nodes = tempNodes;
+								nodeCollection = tempNodeCollection;
+							}
+						} }, path1.scope, path1);
+					}
+					if (path1.node.key.type === "Identifier" && path1.node.key.name === "data") {
+						const dataNode = path1.node;
+						traverse$2(dataNode, { ReturnStatement(path2) {
+							if (path2.parent === dataNode.body) {
+								if (path2.node.argument?.type === "ObjectExpression") path2.node.argument.properties.forEach((prop) => {
+									if (prop.type === "ObjectProperty") {
+										if (prop.key.type === "Identifier") {
+											const name = prop.key.name;
+											graph.nodes.add(name);
+											tNodes.set(name, prop.key);
+											nodeCollection.addNode(name, prop, { comment: getComment(prop) });
+											if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+										}
+									}
+								});
+							}
+						} }, path1.scope, path1);
+					}
+					if (path1.node.key.type === "Identifier" && path1.node.key.name === "render") traverse$2(path1.node, { ReturnStatement(path2) {
+						const templateNode = path2.node;
+						traverse$2(templateNode, { MemberExpression(path3) {
+							if (path3.node.object && path3.node.object.type === "ThisExpression") {
+								if (path3.node.property && path3.node.property.type === "Identifier") nodesUsedInTemplate.add(path3.node.property.name);
+							}
+						} }, path2.scope, path2);
+					} }, path1.scope, path1);
+				}
+			}
+		}, path.scope, path);
+		traverse$2(node, {
+			ObjectMethod(path1) {
+				if (path.node.declaration.type === "ObjectExpression" && path1.parent === path.node.declaration || path.node.declaration.type === "CallExpression" && path1.parent === path.node.declaration.arguments[0]) {
+					if (path1.node.key.type === "Identifier" && vueLifeCycleHooks.includes(path1.node.key.name)) {
+						const hookName = path1.node.key.name;
+						traverse$2(path1.node.body, { MemberExpression(path2) {
+							if (path2.node.object.type === "ThisExpression" && path2.node.property.type === "Identifier") {
+								const _node = nodeCollection.getNode(path2.node.property.name);
+								if (_node?.info?.used) _node?.info?.used?.add(hookName);
+								else if (_node) _node.info = {
+									..._node?.info,
+									used: new Set([hookName])
+								};
+							}
+						} }, path1.scope, path1);
+					}
+				}
+			},
+			ObjectProperty(path1) {
+				if (path.node.declaration.type === "ObjectExpression" && path1.parent === path.node.declaration || path.node.declaration.type === "CallExpression" && path1.parent === path.node.declaration.arguments[0]) {
+					if (path1.node.key.type === "Identifier" && path1.node.key.name === "computed") {
+						const computedNode = path1.node;
+						if (computedNode.value.type === "ObjectExpression") computedNode.value.properties.forEach((prop) => {
+							if (prop.type === "ObjectMethod" && prop.key.type === "Identifier") {
+								const name = prop.key.name;
+								traverse$2(prop, { MemberExpression(path2) {
+									if (path2.node.object.type === "ThisExpression" && path2.node.property.type === "Identifier") graph.edges.get(name)?.add({
+										label: path2.node.property.name,
+										type: getRelationType(path2)
+									});
+								} }, path1.scope, path1);
+							}
+							if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.value.type === "ObjectExpression") {
+								const name = prop.key.name;
+								prop.value.properties.forEach((prop1) => {
+									if (prop1.type === "ObjectProperty" && prop1.key.type === "Identifier" && prop1.key.name === "get") traverse$2(prop1, { MemberExpression(path2) {
+										if (path2.node.object.type === "ThisExpression" && path2.node.property.type === "Identifier") graph.edges.get(name)?.add({
+											label: path2.node.property.name,
+											type: getRelationType(path2)
+										});
+									} }, path1.scope, path1);
+								});
+							}
+						});
+					}
+					if (path1.node.key.type === "Identifier" && path1.node.key.name === "methods") {
+						const methodsNode = path1.node;
+						if (methodsNode.value.type === "ObjectExpression") methodsNode.value.properties.forEach((prop) => {
+							if ((prop.type === "ObjectMethod" || prop.type === "ObjectProperty") && prop.key.type === "Identifier") {
+								const name = prop.key.name;
+								traverse$2(prop, { MemberExpression(path2) {
+									if (path2.node.object.type === "ThisExpression" && path2.node.property.type === "Identifier") graph.edges.get(name)?.add({
+										label: path2.node.property.name,
+										type: getRelationType(path2)
+									});
+								} }, path1.scope, path1);
+							}
+						});
+					}
+					if (path1.node.key.type === "Identifier" && [...watchHooks, ...vueLifeCycleHooks].includes(path1.node.key.name)) {
+						const hookName = path1.node.key.name;
+						if (watchHooks.includes(hookName) && path1.node.value.type === "ObjectExpression") path1.node.value.properties.forEach((prop) => {
+							if ((prop.type === "ObjectProperty" || prop.type === "ObjectMethod") && (prop.key.type === "Identifier" || prop.key.type === "StringLiteral")) {
+								const keyName = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "StringLiteral" ? prop.key.value.split(".")[0] : "";
+								const watchArg = tNodes.get(keyName);
+								const _node = nodeCollection.getNode(keyName);
+								if (_node?.info?.used) _node?.info?.used?.add(hookName);
+								else if (_node) _node.info = {
+									..._node?.info,
+									used: new Set([hookName])
+								};
+								traverse$2(path1.node.value, { MemberExpression(path2) {
+									if (path2.node.object.type === "ThisExpression" && path2.node.property.type === "Identifier") {
+										if (watchArg && watchArg.name !== path2.node.property.name) graph.edges.get(watchArg.name)?.add({
+											label: path2.node.property.name,
+											type: getRelationType(path2)
+										});
+									}
+								} }, path1.scope, path1);
+							}
+						});
+						else traverse$2(path1.node.value, { MemberExpression(path2) {
+							if (path2.node.object.type === "ThisExpression" && path2.node.property.type === "Identifier") {
+								const _node = nodeCollection.getNode(path2.node.property.name);
+								if (_node?.info?.used) _node?.info?.used?.add(hookName);
+								else if (_node) _node.info = {
+									..._node?.info,
+									used: new Set([hookName])
+								};
+							}
+						} }, path1.scope, path1);
+					}
+				}
+			}
+		}, path.scope, path);
+	}
+	traverse$2(ast, { ExportDefaultDeclaration(path) {
+		if (path.node.declaration.type === "ObjectExpression") process(path.node.declaration, path);
+		else if (path.node.declaration.type === "CallExpression" && path.node.declaration.callee.type === "Identifier" && path.node.declaration.callee.name === "defineComponent" && path.node.declaration.arguments[0].type === "ObjectExpression") process(path.node.declaration.arguments[0], path);
+	} });
+	return {
+		graph: nodeCollection.map(graph),
+		nodesUsedInTemplate
+	};
+}
+
+//#endregion
+//#region src/analyze/style.ts
+var LexerState = /* @__PURE__ */ function(LexerState$1) {
+	LexerState$1[LexerState$1["inParens"] = 0] = "inParens";
+	LexerState$1[LexerState$1["inSingleQuoteString"] = 1] = "inSingleQuoteString";
+	LexerState$1[LexerState$1["inDoubleQuoteString"] = 2] = "inDoubleQuoteString";
+	return LexerState$1;
+}(LexerState || {});
+function lexBinding(content, start) {
+	let state = LexerState.inParens;
+	let parenDepth = 0;
+	for (let i = start; i < content.length; i++) {
+		const char = content.charAt(i);
+		switch (state) {
+			case LexerState.inParens:
+				if (char === "'") state = LexerState.inSingleQuoteString;
+				else if (char === "\"") state = LexerState.inDoubleQuoteString;
+				else if (char === "(") parenDepth++;
+				else if (char === ")") if (parenDepth > 0) parenDepth--;
+				else return i;
+				break;
+			case LexerState.inSingleQuoteString:
+				if (char === "'") state = LexerState.inParens;
+				break;
+			case LexerState.inDoubleQuoteString:
+				if (char === "\"") state = LexerState.inParens;
+				break;
+		}
+	}
+	return null;
+}
+function normalizeExpression(exp) {
+	exp = exp.trim();
+	if (exp[0] === "'" && exp[exp.length - 1] === "'" || exp[0] === "\"" && exp[exp.length - 1] === "\"") return exp.slice(1, -1);
+	return exp;
+}
+const vBindRE = /v-bind\s*\(/g;
+function analyze$2(styles) {
+	const nodes = /* @__PURE__ */ new Set();
+	styles.forEach((style) => {
+		let match;
+		const content = style.content.replace(/\/\*([\s\S]*?)\*\/|\/\/.*/g, "");
+		while (match = vBindRE.exec(content)) {
+			const start = match.index + match[0].length;
+			const end = lexBinding(content, start);
+			if (end !== null) {
+				const variable = normalizeExpression(content.slice(start, end));
+				nodes.add(variable);
+			}
+		}
+	});
+	return nodes;
+}
+
+//#endregion
+//#region src/analyze/template.ts
+const traverse$1 = __babel_traverse.default.default?.default || __babel_traverse.default.default || __babel_traverse.default;
+function analyze$3(content) {
+	const id = "template";
+	const { code } = (0, __vue_compiler_sfc.compileTemplate)({
+		id,
+		source: content,
+		filename: `${id}.js`
+	});
+	const ast = (0, __vue_compiler_sfc.babelParse)(code, {
+		sourceType: "module",
+		plugins: ["typescript"]
+	});
+	const nodes = /* @__PURE__ */ new Set();
+	traverse$1(ast, {
+		MemberExpression(path) {
+			if (path.type === "MemberExpression") {
+				if (path.node.object && path.node.object.type === "Identifier" && path.node.object.name === "_ctx") {
+					if (path.node.property && path.node.property.type === "Identifier") nodes.add(path.node.property.name);
+				}
+			}
+		},
+		ObjectProperty(path) {
+			if (path.node.key.type === "Identifier" && path.node.key.name === "ref") {
+				if (path.node.value.type === "StringLiteral") {
+					const name = path.node.value.value;
+					if (name) nodes.add(name);
+				}
+			}
+		},
+		CallExpression(path) {
+			if (path.node.callee.type === "Identifier" && path.node.callee.name === "_resolveComponent") {
+				if (path.node.arguments[0].type === "StringLiteral") {
+					const name = path.node.arguments[0].value;
+					if (name) nodes.add(name);
+				}
+			}
+		}
+	});
+	return nodes;
+}
+
+//#endregion
+//#region src/utils/traverse.ts
+const traverse = __babel_traverse.default.default?.default || __babel_traverse.default.default || __babel_traverse.default;
+/**
+* 递归遍历如下结构：
+* let { loc, loc: locd, loc: { start, end }, loc: { start: { line: { deep } }} } = node;
+* 解出 loc, locd, start, end, deep
+*/
+function rescureObjectPattern({ node, rootScope, res, parentScope, parentPath }) {
+	traverse(node, {
+		ObjectProperty(path1) {
+			if (path1.node.type === "ObjectProperty" && path1.node.key.type === "Identifier" && path1.node.value.type === "Identifier") {
+				const name = path1.node.value.name;
+				const _scope = path1.scope.getBinding(name)?.scope;
+				if (_scope && _scope === rootScope) res.push(path1.node.value);
+			} else if (path1.node.type === "ObjectProperty" && path1.node.key.type === "Identifier" && path1.node.value.type === "ObjectPattern") rescureObjectPattern({
+				node: path1.node.value,
+				rootScope,
+				res,
+				parentScope: path1.scope,
+				parentPath: path1
+			});
+		},
+		RestElement(path1) {
+			if (path1.node.argument.type === "Identifier") {
+				const name = path1.node.argument.name;
+				const _scope = path1.scope.getBinding(name)?.scope;
+				if (_scope && _scope === rootScope) res.push(path1.node.argument);
+			}
+		}
+	}, parentScope, parentPath);
+}
+/**
+* 递归遍历如下结构：
+* let [foo, [bar, baz]] = [1, [[2], 3]];
+* 解出 foo, bar, baz
+*/
+function rescureArrayPattern({ node, rootScope, res, parentScope, parentPath }) {
+	traverse(node, {
+		Identifier(path1) {
+			if (path1.node.type === "Identifier") {
+				const name = path1.node.name;
+				const _scope = path1.scope.getBinding(name)?.scope;
+				if (_scope && _scope === rootScope) res.push(path1.node);
+			}
+		},
+		ArrayPattern(path1) {
+			if (path1.node.type === "ArrayPattern") rescureArrayPattern({
+				node: path1.node,
+				rootScope,
+				res,
+				parentScope: path1.scope,
+				parentPath: path1
+			});
+		}
+	}, parentScope, parentPath);
+}
+function parseNodeIdentifierPattern({ path, rootScope, cb }) {
+	if (path.node.id.type !== "Identifier") return;
+	if (path.node.init?.type === "ArrowFunctionExpression" || path.node.init?.type === "FunctionExpression") cb?.({
+		name: path.node.id.name,
+		node: path.node,
+		path,
+		scope: rootScope
+	});
+	else cb?.({
+		name: path.node.id.name,
+		node: path.node,
+		path,
+		scope: rootScope
+	});
+}
+function parseNodeObjectPattern({ path, rootScope, cb }) {
+	if (path.node.id.type !== "ObjectPattern") return;
+	path.node.id.properties.forEach((property) => {
+		if (property.type === "ObjectProperty" && property.key.type === "Identifier" && property.value.type === "Identifier") cb?.({
+			name: property.value.name,
+			node: property,
+			path,
+			scope: rootScope
+		});
+		else if (property.type === "ObjectProperty" && property.key.type === "Identifier" && property.value.type === "AssignmentPattern") cb?.({
+			name: property.key.name,
+			node: property,
+			path,
+			scope: rootScope
+		});
+		else if (property.type === "RestElement" && property.argument.type === "Identifier") cb?.({
+			name: property.argument.name,
+			node: property,
+			path,
+			scope: rootScope
+		});
+		else if (property.type === "ObjectProperty" && property.key.type === "Identifier" && property.value.type === "ObjectPattern") {
+			const res = [];
+			rescureObjectPattern({
+				node: property.value,
+				rootScope,
+				res,
+				parentScope: path.scope,
+				parentPath: path
+			});
+			res.forEach((r) => cb?.({
+				name: r.name,
+				node: r,
+				path,
+				scope: rootScope
+			}));
+		}
+	});
+}
+function parseNodeArrayPattern({ path, rootScope, cb }) {
+	if (path.node.id.type !== "ArrayPattern") return;
+	path.node.id.elements.forEach((ele) => {
+		if (ele?.type === "Identifier") cb?.({
+			name: ele.name,
+			node: ele,
+			path,
+			scope: rootScope
+		});
+		else if (ele?.type === "ArrayPattern") {
+			const res = [];
+			rescureArrayPattern({
+				node: ele,
+				rootScope,
+				res,
+				parentScope: path.scope,
+				parentPath: path
+			});
+			res.forEach((r) => cb?.({
+				name: r.name,
+				node: r,
+				path,
+				scope: rootScope
+			}));
+		} else if (ele?.type === "AssignmentPattern") {
+			if (ele.left.type === "Identifier") cb?.({
+				name: ele.left.name,
+				node: ele,
+				path,
+				scope: rootScope
+			});
+		} else if (ele?.type === "RestElement") {
+			if (ele.argument.type === "Identifier") cb?.({
+				name: ele.argument.name,
+				node: ele,
+				path,
+				scope: rootScope
+			});
+		}
+	});
+}
+function parseNodeFunctionPattern({ path, rootScope, cb }) {
+	if (path.node.type !== "FunctionDeclaration") return;
+	if (path.node.id?.type === "Identifier") cb?.({
+		name: path.node.id.name,
+		node: path.node,
+		path,
+		scope: rootScope
+	});
+}
+function parseEdgeLeftIdentifierPattern({ path, rootScope, cb, collectionNodes, spread }) {
+	if (!path.node.id || path.node.id.type !== "Identifier") return;
+	if (path.node.init?.type && [
+		"ArrowFunctionExpression",
+		"FunctionExpression",
+		"CallExpression",
+		"ObjectExpression",
+		"ArrayExpression"
+	].includes(path.node.init.type)) {
+		if (collectionNodes.has(path.node.id.name) && path.scope.getBinding(path.node.id.name)?.scope === rootScope) {
+			const name = path.node.id.name;
+			traverse(path.node.init, {
+				Identifier(path1) {
+					const binding = path1.scope.getBinding(path1.node.name);
+					if (binding?.scope === rootScope && collectionNodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node)) cb?.({
+						fromName: name,
+						toName: path1.node.name,
+						path: path1,
+						scope: rootScope,
+						collectionNodes
+					});
+				},
+				MemberExpression(path1) {
+					if (spread?.length && path1.node.object.type === "Identifier" && spread.includes(path1.node.object.name) && path1.node.property.type === "Identifier") cb?.({
+						fromName: name,
+						toName: path1.node.property.name,
+						toScope: path1.scope.getBinding(path1.node.object.name)?.scope,
+						path: path1,
+						scope: rootScope,
+						collectionNodes
+					});
+				}
+			}, path.scope, path);
+		}
+	}
+}
+function parseEdgeLeftObjectPattern({ path, rootScope, cb, collectionNodes }) {
+	if (!path.node.id || path.node.id.type !== "ObjectPattern") return;
+	if (path.node.init?.type && [
+		"ArrowFunctionExpression",
+		"FunctionExpression",
+		"CallExpression",
+		"ObjectExpression",
+		"ArrayExpression"
+	].includes(path.node.init.type)) {
+		const res = [];
+		rescureObjectPattern({
+			node: path.node.id,
+			rootScope,
+			res,
+			parentScope: path.scope,
+			parentPath: path
+		});
+		res.filter((r) => collectionNodes.has(r.name) && path.scope.getBinding(r.name)?.scope === rootScope);
+		traverse(path.node.init, { Identifier(path1) {
+			const binding = path1.scope.getBinding(path1.node.name);
+			if (binding?.scope === rootScope && collectionNodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node)) res.forEach((r) => {
+				cb?.({
+					fromName: r.name,
+					toName: path1.node.name,
+					path: path1,
+					scope: rootScope,
+					collectionNodes
+				});
+			});
+		} }, path.scope, path);
+	}
+}
+function parseEdgeLeftArrayPattern({ path, rootScope, cb, collectionNodes }) {
+	if (!path.node.id || path.node.id.type !== "ArrayPattern") return;
+	if (path.node.init?.type && [
+		"ArrowFunctionExpression",
+		"FunctionExpression",
+		"CallExpression",
+		"ObjectExpression",
+		"ArrayExpression"
+	].includes(path.node.init.type)) {
+		const res = [];
+		rescureArrayPattern({
+			node: path.node.id,
+			rootScope,
+			res,
+			parentScope: path.scope,
+			parentPath: path
+		});
+		res.filter((r) => collectionNodes.has(r.name) && path.scope.getBinding(r.name)?.scope === rootScope);
+		traverse(path.node.init, { Identifier(path1) {
+			const binding = path1.scope.getBinding(path1.node.name);
+			if (binding?.scope === rootScope && collectionNodes.has(path1.node.name) && (path1.parent.type !== "MemberExpression" && path1.parent.type !== "OptionalMemberExpression" || path1.parent.object === path1.node)) res.forEach((r) => {
+				cb?.({
+					fromName: r.name,
+					toName: path1.node.name,
+					path: path1,
+					scope: rootScope,
+					collectionNodes
+				});
+			});
+		} }, path.scope, path);
+	}
+}
+function parseEdgeFunctionPattern({ path, rootScope, cb, collectionNodes }) {
+	if (!path.node.id) return;
+	if (collectionNodes.has(path.node.id.name) && path.scope.getBinding(path.node.id.name)?.scope === rootScope) {
+		const name = path.node.id.name;
+		traverse(path.node.body, { Identifier(path1) {
+			const binding = path1.scope.getBinding(path1.node.name);
+			if (binding?.scope === rootScope && collectionNodes.has(path1.node.name)) cb?.({
+				fromName: name,
+				toName: path1.node.name,
+				path: path1,
+				scope: rootScope,
+				collectionNodes
+			});
+		} }, path.scope, path);
+	}
+}
+function parseReturnJsxPattern({ path, parentPath, cb }) {
+	if (path.node.argument && ((path.node.argument.type === "ArrowFunctionExpression" || path.node.argument.type === "FunctionExpression") && (path.node.argument.body.type === "JSXElement" || path.node.argument.body.type === "JSXFragment") || path.node.argument.type === "JSXElement" || path.node.argument.type === "JSXFragment")) path.traverse({ Identifier(path1) {
+		cb?.({
+			name: path1.node.name,
+			path: path1,
+			parentPath
+		});
+	} });
+}
+function traverseSetup({ node, parentScope, parentPath }) {
+	let path;
+	traverse(node, { ObjectMethod(path1) {
+		if (parentPath.node.declaration.type === "ObjectExpression" && path1.parent === parentPath.node.declaration || parentPath.node.declaration.type === "CallExpression" && path1.parent === parentPath.node.declaration.arguments[0]) {
+			if (path1.node.key.type === "Identifier" && path1.node.key.name === "setup") path = path1;
+		}
+	} }, parentScope, parentPath);
+	return path;
+}
+function collectionSpread({ path: path1, spread }) {
+	path1.traverse({ ReturnStatement(path2) {
+		if (path2.node.argument?.type === "ObjectExpression") {
+			const returnNode = path2.node.argument;
+			traverse(returnNode, { SpreadElement(path3) {
+				if (path3.node.argument.type === "CallExpression" && path3.node.argument.callee.type === "Identifier" && path3.node.argument.callee.name === "toRefs" && path3.node.argument.arguments[0].type === "Identifier") spread.push(path3.node.argument.arguments[0].name);
+				else if (path3.node.argument.type === "Identifier") spread.push(path3.node.argument.name);
+			} }, path2.scope, path2);
+		}
+	} });
+}
+function addIdentifiesToGraphByScanReturn({ path: path1, graph, nodeCollection, tempNodeCollection, tempEdges }) {
+	path1.traverse({ ReturnStatement(path2) {
+		if (path2.node.argument?.type === "ObjectExpression") {
+			const returnNode = path2.node.argument;
+			traverse(returnNode, { ObjectProperty(path3) {
+				if (path3.parent === returnNode) {
+					if (path3.node.key.type === "Identifier" && path3.node.value.type === "Identifier") {
+						const valName = path3.node.value.name;
+						if (!graph.nodes.has(valName)) {
+							graph.nodes.add(valName);
+							nodeCollection.addTypedNode(valName, tempNodeCollection.nodes.get(valName));
+						}
+						if (!graph.edges.has(valName)) graph.edges.set(valName, new Set([...Array.from(tempEdges.get(valName) || /* @__PURE__ */ new Set())]));
+						const name = path3.node.key.name;
+						if (name !== valName) {
+							graph.nodes.add(name);
+							nodeCollection.addNode(name, path3.node.key, { comment: getComment(path3.node) });
+							graph.edges.set(name, new Set([{
+								label: valName,
+								type: getRelationType(path3)
+							}]));
+						}
+					}
+				}
+			} }, path2.scope, path2);
+		}
+	} });
+}
+function addSpreadToGraphByScanReturn({ path: path1, graph, nodeCollection, tempNodeCollection, tempEdges, tempSpread }) {
+	path1.traverse({ ReturnStatement(path2) {
+		if (path2.node.argument?.type === "ObjectExpression") {
+			const returnNode = path2.node.argument;
+			traverse(returnNode, { SpreadElement(path3) {
+				if (path3.node.argument.type === "CallExpression" && path3.node.argument.callee.type === "Identifier" && path3.node.argument.callee.name === "toRefs" && path3.node.argument.arguments[0].type === "Identifier" && tempSpread.get(path3.node.argument.arguments[0].name)) tempSpread.get(path3.node.argument.arguments[0].name)?.forEach((name) => {
+					graph.nodes.add(name);
+					nodeCollection.addTypedNode(name, tempNodeCollection.nodes.get(name));
+					if (!graph.edges.get(name)) {
+						graph.edges.set(name, /* @__PURE__ */ new Set());
+						tempEdges.get(name)?.forEach((edge) => {
+							graph.edges.get(name)?.add(edge);
+						});
+					}
+				});
+				else if (path3.node.argument.type === "Identifier" && tempSpread.get(path3.node.argument.name)) tempSpread.get(path3.node.argument.name)?.forEach((name) => {
+					graph.nodes.add(name);
+					nodeCollection.addTypedNode(name, tempNodeCollection.nodes.get(name));
+					if (!graph.edges.get(name)) {
+						graph.edges.set(name, /* @__PURE__ */ new Set());
+						tempEdges.get(name)?.forEach((edge) => {
+							graph.edges.get(name)?.add(edge);
+						});
+					}
+				});
+			} }, path2.scope, path2);
+		}
+	} });
+}
+function addGraphBySpreadIdentifier({ path: path1, graph, nodeCollection, iname }) {
+	if (path1.node.init?.type === "ObjectExpression") path1.node.init?.properties.forEach((prop) => {
+		if ((prop.type === "ObjectProperty" || prop.type === "ObjectMethod") && prop.key.type === "Identifier") {
+			const keyName = prop.key.name;
+			graph.nodes.add(keyName);
+			nodeCollection.addNode(keyName, prop, { comment: getComment(prop) });
+			if (!graph.edges.get(keyName)) graph.edges.set(keyName, /* @__PURE__ */ new Set());
+			if (graph.spread.has(iname)) graph.spread.get(iname)?.add(keyName);
+			else graph.spread.set(iname, new Set([keyName]));
+		} else if (prop.type === "SpreadElement") console.warn("not support spread in spread");
+	});
+	if (path1.node.init?.type === "CallExpression" && path1.node.init?.callee.type === "Identifier" && path1.node.init?.callee.name === "reactive") {
+		const arg = path1.node.init?.arguments[0];
+		if (arg.type === "ObjectExpression") arg.properties.forEach((prop) => {
+			if ((prop.type === "ObjectProperty" || prop.type === "ObjectMethod") && prop.key.type === "Identifier") {
+				const keyName = prop.key.name;
+				graph.nodes.add(keyName);
+				nodeCollection.addNode(keyName, prop, { comment: getComment(prop) });
+				if (!graph.edges.get(keyName)) graph.edges.set(keyName, /* @__PURE__ */ new Set());
+				if (graph.spread.has(iname)) graph.spread.get(iname)?.add(keyName);
+				else graph.spread.set(iname, new Set([keyName]));
+			} else if (prop.type === "SpreadElement") console.warn("not support spread in spread");
+		});
+	}
+}
+
+//#endregion
+//#region src/analyze/tsx.ts
+function processByReturnNotJSX(params) {
+	const { node, parentPath, lineOffset, addInfo } = params;
+	const spread = [];
+	const nodeCollection = new NodeCollection(lineOffset, addInfo);
+	const graph = {
+		nodes: /* @__PURE__ */ new Set(),
+		edges: /* @__PURE__ */ new Map()
+	};
+	const setupPath = traverseSetup({
+		node,
+		parentScope: parentPath.scope,
+		parentPath
+	});
+	collectionSpread({
+		path: setupPath,
+		spread
+	});
+	const { graph: { nodes: tempNodes, edges: tempEdges, spread: tempSpread }, nodeCollection: tempNodeCollection, nodesUsedInTemplate } = processByReturnJSX({
+		node,
+		parentPath,
+		spread,
+		lineOffset,
+		addInfo
+	});
+	addIdentifiesToGraphByScanReturn({
+		path: setupPath,
+		graph,
+		nodeCollection,
+		tempNodeCollection,
+		tempEdges
+	});
+	addSpreadToGraphByScanReturn({
+		path: setupPath,
+		graph,
+		nodeCollection,
+		tempNodeCollection,
+		tempEdges,
+		tempSpread
+	});
+	return {
+		graph,
+		nodeCollection,
+		nodesUsedInTemplate
+	};
+}
+function processByReturnJSX(params) {
+	const { node, parentPath, spread = [], lineOffset, addInfo } = params;
+	const nodeCollection = new NodeCollection(lineOffset, addInfo);
+	const nodesUsedInTemplate = /* @__PURE__ */ new Set();
+	const graph = {
+		nodes: /* @__PURE__ */ new Set(),
+		edges: /* @__PURE__ */ new Map(),
+		spread: /* @__PURE__ */ new Map()
+	};
+	function addNode({ name, node: node$1, path, scope }, commentParentNode) {
+		const binding = path.scope.getBinding(name);
+		if (scope === binding?.scope) {
+			graph.nodes.add(name);
+			nodeCollection.addNode(name, node$1, { comment: commentParentNode ? getComment(commentParentNode) : "" });
+			if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+		}
+	}
+	function addEdge({ fromName, toName, path, scope, toScope, collectionNodes }) {
+		const bindingScope = toScope || path.scope.getBinding(toName)?.scope;
+		if (scope === bindingScope && collectionNodes.has(toName)) graph.edges.get(fromName)?.add({
+			label: toName,
+			type: getRelationType(path)
+		});
+	}
+	function addUsed({ name, path, parentPath: parentPath$1 }) {
+		const binding = path.scope.getBinding(name);
+		if (binding?.scope === parentPath$1.scope) nodesUsedInTemplate.add(name);
+	}
+	const setupPath = traverseSetup({
+		node,
+		parentScope: parentPath.scope,
+		parentPath
+	});
+	const setupScope = setupPath.scope;
+	const setupNode = setupPath.node;
+	traverse(setupNode, {
+		VariableDeclarator(path1) {
+			parseNodeIdentifierPattern({
+				path: path1,
+				rootScope: setupScope,
+				cb: (params$1) => {
+					if (!spread.includes(params$1.name)) addNode(params$1, path1.node);
+					else addGraphBySpreadIdentifier({
+						path: path1,
+						graph,
+						nodeCollection,
+						iname: params$1.name
+					});
+				}
+			});
+			parseNodeObjectPattern({
+				path: path1,
+				rootScope: setupScope,
+				cb: addNode
+			});
+			parseNodeArrayPattern({
+				path: path1,
+				rootScope: setupScope,
+				cb: addNode
+			});
+		},
+		FunctionDeclaration(path1) {
+			parseNodeFunctionPattern({
+				path: path1,
+				rootScope: setupScope,
+				cb: addNode
+			});
+		}
+	}, setupScope, setupPath);
+	setupPath.traverse({ ReturnStatement(path2) {
+		parseReturnJsxPattern({
+			path: path2,
+			parentPath: setupPath,
+			cb: addUsed
+		});
+	} });
+	traverse(setupNode, {
+		VariableDeclarator(path1) {
+			parseEdgeLeftIdentifierPattern({
+				path: path1,
+				rootScope: setupScope,
+				collectionNodes: graph.nodes,
+				cb: addEdge,
+				spread
+			});
+			parseEdgeLeftObjectPattern({
+				path: path1,
+				rootScope: setupScope,
+				collectionNodes: graph.nodes,
+				cb: addEdge
+			});
+			parseEdgeLeftArrayPattern({
+				path: path1,
+				rootScope: setupScope,
+				collectionNodes: graph.nodes,
+				cb: addEdge
+			});
+		},
+		FunctionDeclaration(path1) {
+			parseEdgeFunctionPattern({
+				path: path1,
+				rootScope: setupScope,
+				collectionNodes: graph.nodes,
+				cb: addEdge
+			});
+		}
+	}, setupScope, setupPath);
+	return {
+		graph,
+		nodeCollection,
+		nodesUsedInTemplate
+	};
+}
+function processByReact(params) {
+	const { node, parentScope, parentPath, lineOffset, addInfo } = params;
+	const nodeCollection = new NodeCollection(lineOffset, addInfo);
+	const nodesUsedInTemplate = /* @__PURE__ */ new Set();
+	const graph = {
+		nodes: /* @__PURE__ */ new Set(),
+		edges: /* @__PURE__ */ new Map(),
+		spread: /* @__PURE__ */ new Map()
+	};
+	function addNode({ name, node: node$1, path, scope }, commentParentNode) {
+		const binding = path.scope.getBinding(name);
+		if (scope === binding?.scope) {
+			graph.nodes.add(name);
+			nodeCollection.addNode(name, node$1, { comment: commentParentNode ? getComment(commentParentNode) : "" });
+			if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+		}
+	}
+	function addEdge({ fromName, toName, path, scope, toScope, collectionNodes }) {
+		const bindingScope = toScope || path.scope.getBinding(toName)?.scope;
+		if (scope === bindingScope && collectionNodes.has(toName)) graph.edges.get(fromName)?.add({
+			label: toName,
+			type: getRelationType(path)
+		});
+	}
+	function addUsed({ name, path, parentPath: parentPath$1 }) {
+		const binding = path.scope.getBinding(name);
+		if (binding?.scope === parentPath$1.scope) nodesUsedInTemplate.add(name);
+	}
+	traverse(node, {
+		VariableDeclarator(path1) {
+			parseNodeIdentifierPattern({
+				path: path1,
+				rootScope: parentScope,
+				cb: (params$1) => {
+					addNode(params$1, path1.node);
+				}
+			});
+			parseNodeObjectPattern({
+				path: path1,
+				rootScope: parentScope,
+				cb: addNode
+			});
+			parseNodeArrayPattern({
+				path: path1,
+				rootScope: parentScope,
+				cb: addNode
+			});
+		},
+		FunctionDeclaration(path1) {
+			parseNodeFunctionPattern({
+				path: path1,
+				rootScope: parentScope,
+				cb: addNode
+			});
+		}
+	}, parentScope, parentPath);
+	traverse(node, { ReturnStatement(path2) {
+		parseReturnJsxPattern({
+			path: path2,
+			parentPath,
+			cb: addUsed
+		});
+	} }, parentScope, parentPath);
+	traverse(node, {
+		VariableDeclarator(path1) {
+			parseEdgeLeftIdentifierPattern({
+				path: path1,
+				rootScope: parentScope,
+				collectionNodes: graph.nodes,
+				cb: addEdge
+			});
+			parseEdgeLeftObjectPattern({
+				path: path1,
+				rootScope: parentScope,
+				collectionNodes: graph.nodes,
+				cb: addEdge
+			});
+			parseEdgeLeftArrayPattern({
+				path: path1,
+				rootScope: parentScope,
+				collectionNodes: graph.nodes,
+				cb: addEdge
+			});
+		},
+		FunctionDeclaration(path1) {
+			parseEdgeFunctionPattern({
+				path: path1,
+				rootScope: parentScope,
+				collectionNodes: graph.nodes,
+				cb: addEdge
+			});
+		}
+	}, parentScope, parentPath);
+	return {
+		graph,
+		nodeCollection,
+		nodesUsedInTemplate
+	};
+}
+function processTsx(params) {
+	let result;
+	function process(params$1) {
+		const { node, parentPath } = params$1;
+		const setupPath = traverseSetup({
+			node,
+			parentScope: parentPath.scope,
+			parentPath
+		});
+		setupPath.traverse({ ReturnStatement(path) {
+			if (path.node.argument && (path.node.argument.type === "ArrowFunctionExpression" || path.node.argument.type === "FunctionExpression") && (path.node.argument.body.type === "JSXElement" || path.node.argument.body.type === "JSXFragment")) result = processByReturnJSX(params$1);
+			else result = processByReturnNotJSX(params$1);
+		} });
+	}
+	traverse(params.node, { ExportDefaultDeclaration(path) {
+		if (params.type === "vue") {
+			if (path.node.declaration.type === "ObjectExpression") process({
+				...params,
+				node: path.node.declaration,
+				parentNode: path.node,
+				parentPath: path
+			});
+			else if (path.node.declaration.type === "CallExpression" && path.node.declaration.callee.type === "Identifier" && path.node.declaration.callee.name === "defineComponent" && path.node.declaration.arguments[0].type === "ObjectExpression") process({
+				...params,
+				node: path.node.declaration.arguments[0],
+				parentNode: path.node,
+				parentPath: path
+			});
+		}
+		if (params.type === "react") {
+			if ((path.node.declaration.type === "FunctionDeclaration" || path.node.declaration.type === "ArrowFunctionExpression") && path.node.declaration.body.type === "BlockStatement") {
+				const functionPath = path.get("declaration");
+				result = processByReact({
+					...params,
+					node: path.node.declaration.body,
+					parentNode: functionPath.node,
+					parentPath: functionPath,
+					parentScope: functionPath.scope
+				});
+			}
+			if (path.node.declaration.type === "ClassDeclaration") {
+				const renderFunction = path.node.declaration.body.body.find((node) => {
+					if (node.type === "ClassMethod" && node.key.type === "Identifier" && node.key.name === "render") return node;
+					return void 0;
+				});
+				if (!renderFunction) return;
+				const renderPath = path.get(`declaration.body.body.${path.node.declaration.body.body.indexOf(renderFunction)}`);
+				result = processByReact({
+					...params,
+					node: renderFunction.body,
+					parentNode: renderFunction,
+					parentPath: renderPath,
+					parentScope: renderPath.scope
+				});
+			}
+		}
+	} });
+	return result;
+}
+function analyze$4(content, type = "vue", lineOffset = 0, addInfo = true) {
+	const ast = (0, __vue_compiler_sfc.babelParse)(content, {
+		sourceType: "module",
+		plugins: ["typescript", "jsx"]
+	});
+	const { graph, nodeCollection, nodesUsedInTemplate } = processTsx({
+		node: ast,
+		type,
+		lineOffset,
+		addInfo
+	});
+	return {
+		graph: nodeCollection.map(graph),
+		nodesUsedInTemplate
+	};
+}
+
+//#endregion
+//#region src/mermaid.ts
+function getMermaidText(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__ */ new Set(), options = {}) {
+	const direction = options.direction || "TB";
+	const usedNodes = new Set([...nodesUsedInTemplate, ...nodesUsedInStyle]);
+	let mermaidText = `flowchart ${direction}
+    %% Legend:
+    %% () = variable node
+    %% [] = function node
+    %% * suffix = unused in template/style
+    %% A --> B means A depends on B\n`;
+	graph.nodes.forEach((node) => {
+		const shape = node.type === "var" ? "(" : "[";
+		const closeShape = node.type === "var" ? ")" : "]";
+		const unusedSuffix = !(usedNodes.has(node.label) || node.info?.used?.size) ? "*" : "";
+		mermaidText += `    ${node.label}${shape}${node.label}${unusedSuffix}${closeShape}\n`;
+	});
+	graph.edges.forEach((edge, key) => {
+		edge.forEach((to) => {
+			if (!to || !to.node.label) return;
+			mermaidText += `    ${key.label} --> ${to.node.label}\n`;
+		});
+	});
+	return mermaidText;
+}
+
+//#endregion
+//#region src/suggest/filter.ts
+/**
+* Filter out nodes that have no indegree.
+*/
+function noIndegreeFilter(graph) {
+	const nodes = Array.from(graph.keys());
+	const indegree = /* @__PURE__ */ new Map();
+	nodes.forEach((node) => {
+		indegree.set(node, 0);
+	});
+	graph.forEach((targets, node) => {
+		targets.forEach((target) => {
+			indegree.set(target.node, (indegree.get(target.node) || 0) + 1);
+		});
+	});
+	return nodes.filter((node) => indegree.get(node) === 0);
+}
+function findLinearPaths(graph) {
+	const linearPaths = [];
+	const visitedNodes = /* @__PURE__ */ new Set();
+	const nodeInDegrees = /* @__PURE__ */ new Map();
+	for (const [node, edges] of graph.entries()) {
+		if (!nodeInDegrees.has(node)) nodeInDegrees.set(node, 0);
+		for (const edge of edges) {
+			const inDegree = nodeInDegrees.get(edge.node) || 0;
+			nodeInDegrees.set(edge.node, inDegree + 1);
+		}
+	}
+	function dfs$1(node, path) {
+		if (visitedNodes.has(node)) return;
+		path.push(node);
+		visitedNodes.add(node);
+		const edges = graph.get(node) || /* @__PURE__ */ new Set();
+		if (edges.size === 0 || edges.size > 1) {
+			if (path.length > 1) addOrUpdatePath([...path]);
+		} else {
+			const nextNode = Array.from(edges)[0].node;
+			const nextNodeInDegree = nodeInDegrees.get(nextNode) || 0;
+			if (nextNodeInDegree === 1) dfs$1(nextNode, path);
+		}
+		path.pop();
+		visitedNodes.delete(node);
+	}
+	function addOrUpdatePath(newPath) {
+		let shouldAddNewPath = true;
+		for (let i = linearPaths.length - 1; i >= 0; i--) {
+			const existingPath = linearPaths[i];
+			if (isSubpath(existingPath, newPath)) linearPaths.splice(i, 1);
+			else if (isSubpath(newPath, existingPath)) {
+				shouldAddNewPath = false;
+				break;
+			}
+		}
+		if (shouldAddNewPath && newPath.length > 2) linearPaths.push(newPath);
+	}
+	function isSubpath(shortPath, longPath) {
+		if (shortPath.length >= longPath.length) return false;
+		for (let i = 0; i <= longPath.length - shortPath.length; i++) {
+			let isSub = true;
+			for (let j = 0; j < shortPath.length; j++) if (shortPath[j] !== longPath[i + j]) {
+				isSub = false;
+				break;
+			}
+			if (isSub) return true;
+		}
+		return false;
+	}
+	for (const node of graph.keys()) dfs$1(node, []);
+	return linearPaths;
+}
+function findArticulationPoints(graph) {
+	const noIndegreeNodes = noIndegreeFilter(graph);
+	let time = 0;
+	const low = /* @__PURE__ */ new Map();
+	const disc = /* @__PURE__ */ new Map();
+	const parent = /* @__PURE__ */ new Map();
+	const ap = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	function APUtil(graph$1, node) {
+		let children = 0;
+		disc.set(node, time);
+		low.set(node, time);
+		time++;
+		visited.add(node);
+		for (const neighbor of graph$1.get(node) || []) if (!visited.has(neighbor.node)) {
+			children++;
+			parent.set(neighbor.node, node);
+			APUtil(graph$1, neighbor.node);
+			low.set(node, Math.min(low.get(node), low.get(neighbor.node)));
+			if (parent.get(node) === null && children > 1) ap.add(node);
+			if (parent.get(node) !== null && low.get(neighbor.node) >= disc.get(node)) ap.add(node);
+		} else if (neighbor.node !== parent.get(node)) low.set(node, Math.min(low.get(node), disc.get(neighbor.node)));
+	}
+	for (const node of graph.keys()) if (!visited.has(node) && !noIndegreeNodes.includes(node)) APUtil(graph, node);
+	return ap;
+}
+
+//#endregion
+//#region src/suggest/split.ts
+function dfs(graph, node, targets, visited, component) {
+	component.add(node);
+	visited.add(node);
+	targets.forEach((target) => {
+		if (!visited.has(target.node)) dfs(graph, target.node, graph.get(target.node) || /* @__PURE__ */ new Set(), visited, component);
+	});
+}
+function haveIntersection(setA, setB) {
+	for (const item of setA) if (setB.has(item)) return true;
+	return false;
+}
+function mergeSets(arr) {
+	let result = [...arr];
+	for (let i = 0; i < result.length; i++) for (let j = i + 1; j < result.length; j++) if (haveIntersection(result[i], result[j])) {
+		const newSet = new Set([...result[i], ...result[j]]);
+		result.splice(j, 1);
+		result.splice(i, 1);
+		result = [...result, newSet];
+		return mergeSets(result);
+	}
+	return result;
+}
+function splitGraph(graph) {
+	const components = [];
+	const sorted = Array.from(graph).sort((a, b) => b[1].size - a[1].size);
+	new Map(sorted).forEach((targets, node) => {
+		const visited = /* @__PURE__ */ new Set();
+		if (!visited.has(node)) {
+			const component = /* @__PURE__ */ new Set();
+			dfs(graph, node, targets, visited, component);
+			components.push(component);
+		}
+	});
+	return mergeSets(components).map((component) => {
+		const subGraph = /* @__PURE__ */ new Map();
+		component.forEach((node) => {
+			const targets = graph.get(node);
+			if (targets) subGraph.set(node, targets);
+		});
+		return subGraph;
+	});
+}
+
+//#endregion
+//#region src/suggest/utils.ts
+function hasCycle(graph) {
+	const visited = /* @__PURE__ */ new Set();
+	const onStack = /* @__PURE__ */ new Set();
+	const stack = [];
+	let cycleNodes = [];
+	function dfs$1(node) {
+		if (visited.has(node)) {
+			if (onStack.has(node)) {
+				const idx = stack.indexOf(node);
+				const cycle = stack.slice(idx);
+				const allNotGet = cycle.every((curr, i) => {
+					const next = cycle[(i + 1) % cycle.length];
+					return Array.from(graph.get(curr) || []).some((edge) => edge.node === next && edge.type !== "get");
+				});
+				if (allNotGet) {
+					cycleNodes = cycle;
+					return true;
+				}
+				return false;
+			}
+			return false;
+		}
+		visited.add(node);
+		onStack.add(node);
+		stack.push(node);
+		for (const neighbor of graph.get(node) || /* @__PURE__ */ new Set()) {
+			if (neighbor.node === node && neighbor.type !== "get") {
+				cycleNodes = [node];
+				return true;
+			}
+			if (dfs$1(neighbor.node)) return true;
+		}
+		onStack.delete(node);
+		stack.pop();
+		return false;
+	}
+	for (const [node, targets] of graph) if (dfs$1(node)) return {
+		hasCycle: true,
+		cycleNodes
+	};
+	return {
+		hasCycle: false,
+		cycleNodes: []
+	};
+}
+
+//#endregion
+//#region src/suggest/index.ts
+let SuggestionType = /* @__PURE__ */ function(SuggestionType$1) {
+	SuggestionType$1["info"] = "info";
+	SuggestionType$1["warning"] = "warning";
+	SuggestionType$1["error"] = "error";
+	return SuggestionType$1;
+}({});
+function gen(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__ */ new Set()) {
+	const usedNodes = new Set([...nodesUsedInTemplate, ...nodesUsedInStyle]);
+	const suggestions = [];
+	const splitedGraph = splitGraph(graph.edges);
+	splitedGraph.forEach((g) => {
+		const nodes = Array.from(g.keys());
+		if (splitedGraph.length > 1) {
+			if (nodes.length > 2 && nodes.some((node) => !usedNodes.has(node.label))) suggestions.push({
+				type: SuggestionType.info,
+				message: `Nodes [${nodes.length > 10 ? `${nodes.slice(0, 10).map((node) => node.label).join(",")}...(${nodes.length})` : nodes.map((node) => node.label).join(",")}] are isolated, perhaps you can refactor them to an isolated file.`,
+				nodeInfo: nodes
+			});
+		}
+		if (nodes.length > 1 && nodes.every((node) => !usedNodes.has(node.label) && !node.info?.used?.size)) suggestions.push({
+			type: SuggestionType.info,
+			message: `Nodes [${nodes.length > 10 ? `${nodes.slice(0, 10).map((node) => node.label).join(",")}...` : nodes.map((node) => node.label).join(",")}] are not used, perhaps you can remove them.`,
+			nodeInfo: nodes
+		});
+		const hasCycleResult = hasCycle(g);
+		if (hasCycleResult.hasCycle) suggestions.push({
+			type: SuggestionType.error,
+			message: `There is a loop call in nodes [${hasCycleResult.cycleNodes.map((node) => node.label).join(",")}], perhaps you can refactor it.`,
+			nodeInfo: hasCycleResult.cycleNodes
+		});
+		const paths = findLinearPaths(g);
+		paths.forEach((path) => {
+			const firstUsedNodeIndex = path.findIndex((node) => usedNodes.has(node.label));
+			const reverseLastNotUsedNodeIndex = path.slice().reverse().findIndex((node) => !usedNodes.has(node.label));
+			const lastNotUsedNodeIndex = reverseLastNotUsedNodeIndex !== -1 ? path.length - 1 - reverseLastNotUsedNodeIndex : -1;
+			if (firstUsedNodeIndex > -1 && firstUsedNodeIndex < lastNotUsedNodeIndex) suggestions.push({
+				type: SuggestionType.warning,
+				message: `Nodes [${path.length > 10 ? `${path.slice(0, 10).map((node) => node.label).join(",")}...(${path.length})` : path.map((node) => node.label).join(",")}] are have function chain calls, perhaps you can refactor it.`,
+				nodeInfo: path
+			});
+		});
+		if (g.size > 5) {
+			const ap = findArticulationPoints(g);
+			ap.forEach((node) => {
+				if (node.type === NodeType.fun) suggestions.push({
+					type: SuggestionType.info,
+					message: `Node [${node.label}] is an articulation point, perhaps you need to pay special attention to this node.`,
+					nodeInfo: node
+				});
+			});
+		}
+	});
+	const noIndegreeNodes = noIndegreeFilter(graph.edges);
+	noIndegreeNodes.forEach((node) => {
+		if (!usedNodes.has(node.label) && !node.info?.used?.size) suggestions.push({
+			type: SuggestionType.info,
+			message: `Node [${node.label}] is not used, perhaps you can remove it.`,
+			nodeInfo: node
+		});
+	});
+	return suggestions;
+}
+
+//#endregion
+//#region src/vis.ts
+function filterNodeUserd(used) {
+	const usedArray = Array.from(used || []);
+	return new Set(usedArray.filter((u) => !["Assignment Expression", "Call Expression"].includes(u)));
+}
+function getVisData(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__ */ new Set()) {
+	const usedNodes = new Set([...nodesUsedInTemplate, ...nodesUsedInStyle]);
+	const nodes = [];
+	const edges = [];
+	const inDegreeMap = {};
+	const outDegreeMap = {};
+	graph.edges.forEach((edge) => {
+		edge.forEach((to) => {
+			if (to) inDegreeMap[to.node.label] = (inDegreeMap[to.node.label] || 0) + 1;
+		});
+	});
+	graph.edges.forEach((edge, key) => {
+		outDegreeMap[key.label] = edge.size;
+	});
+	graph.nodes.forEach((node) => {
+		const inDegree = inDegreeMap[node.label] || 0;
+		const outDegree = outDegreeMap[node.label] || 0;
+		nodes.push({
+			id: node.label,
+			label: node.label,
+			shape: node.type === "var" ? "dot" : "diamond",
+			group: usedNodes.has(node.label) || node.info?.used?.size ? "used" : "normal",
+			size: 20 + 1.6 ** (inDegree * .75 + outDegree * .25),
+			title: `${filterNodeUserd(node.info?.used).size ? `used by ${Array.from(filterNodeUserd(node.info?.used))?.map((i) => `\`${i}\``).join(",")}\n\n` : ""}${usedNodes.has(node.label) ? `used in ${[nodesUsedInStyle.has(node.label) ? "style" : "", nodesUsedInTemplate.has(node.label) ? "template" : ""].filter(Boolean).join(" and ")}\n\n` : ""}${node.info?.comment || ""}`.trim() || void 0,
+			info: node.info
+		});
+	});
+	graph.edges.forEach((edge, key) => {
+		edge.forEach((to) => {
+			if (!to) return;
+			edges.push({
+				from: key.label,
+				to: to.node.label,
+				arrows: { to: {
+					enabled: true,
+					scaleFactor: .8
+				} }
+			});
+		});
+	});
+	return {
+		nodes,
+		edges
+	};
+}
+
+//#endregion
+exports.SuggestionType = SuggestionType;
+exports.analyzeOptions = analyze;
+exports.analyzeSetupScript = analyze$1;
+exports.analyzeStyle = analyze$2;
+exports.analyzeTemplate = analyze$3;
+exports.analyzeTsx = analyze$4;
+exports.gen = gen;
+exports.getMermaidText = getMermaidText;
+exports.getVisData = getVisData;
+Object.defineProperty(exports, 'parse', {
+  enumerable: true,
+  get: function () {
+    return __vue_compiler_sfc.parse;
+  }
+});
+//# sourceMappingURL=index.cjs.map