vue-hook-optimizer 0.0.83 → 0.0.85

package/dist/index.cjs

@@ -142,6 +142,408 @@ function getRelationType(path) {
 	return "get";
 }
 
+//#endregion
+//#region src/analyze/hook.ts
+const traverse$4 = __babel_traverse.default.default?.default || __babel_traverse.default.default || __babel_traverse.default;
+const watchHooks$1 = [
+	"watch",
+	"watchArray",
+	"watchAtMost",
+	"watchDebounced",
+	"watchDeep",
+	"watchIgnorable",
+	"watchImmediate",
+	"watchOnce",
+	"watchPausable",
+	"watchThrottled",
+	"watchTriggerable",
+	"watchWithFilter"
+];
+const reactEffects = [
+	"useEffect",
+	"useLayoutEffect",
+	"useInsertionEffect",
+	"useMemo",
+	"useCallback"
+];
+const allEffectHooks = [
+	...watchHooks$1,
+	"watchEffect",
+	...reactEffects
+];
+function processHookFunction(functionPath, lineOffset = 0, externalHookName = "", framework = "vue") {
+	const nodeCollection = new NodeCollection(lineOffset);
+	const nodesUsedInReturn = /* @__PURE__ */ new Set();
+	const graph = {
+		nodes: /* @__PURE__ */ new Set(),
+		edges: /* @__PURE__ */ new Map()
+	};
+	const functionNode = functionPath.node;
+	const hookName = externalHookName || (functionNode.type === "FunctionDeclaration" && functionNode.id ? functionNode.id.name : "");
+	const bodyNode = functionNode.body;
+	if (bodyNode.type !== "BlockStatement") return {
+		graph,
+		nodeCollection,
+		nodesUsedInReturn,
+		hookName
+	};
+	const functionScope = functionPath.scope;
+	if (functionNode.params) functionNode.params.forEach((param) => {
+		if (param.type === "Identifier") {
+			graph.nodes.add(param.name);
+			nodeCollection.addNode(param.name, param, { comment: "" });
+			if (!graph.edges.get(param.name)) graph.edges.set(param.name, /* @__PURE__ */ new Set());
+		} else if (param.type === "AssignmentPattern" && param.left.type === "Identifier") {
+			graph.nodes.add(param.left.name);
+			nodeCollection.addNode(param.left.name, param.left, { comment: "" });
+			if (!graph.edges.get(param.left.name)) graph.edges.set(param.left.name, /* @__PURE__ */ new Set());
+		} else if (param.type === "ObjectPattern") param.properties.forEach((prop) => {
+			if (prop.type === "ObjectProperty" && prop.value.type === "Identifier") {
+				graph.nodes.add(prop.value.name);
+				nodeCollection.addNode(prop.value.name, prop.value, { comment: "" });
+				if (!graph.edges.get(prop.value.name)) graph.edges.set(prop.value.name, /* @__PURE__ */ new Set());
+			} else if (prop.type === "RestElement" && prop.argument.type === "Identifier") {
+				graph.nodes.add(prop.argument.name);
+				nodeCollection.addNode(prop.argument.name, prop.argument, { comment: "" });
+				if (!graph.edges.get(prop.argument.name)) graph.edges.set(prop.argument.name, /* @__PURE__ */ new Set());
+			}
+		});
+		else if (param.type === "ArrayPattern") param.elements.forEach((element) => {
+			if (element?.type === "Identifier") {
+				graph.nodes.add(element.name);
+				nodeCollection.addNode(element.name, element, { comment: "" });
+				if (!graph.edges.get(element.name)) graph.edges.set(element.name, /* @__PURE__ */ new Set());
+			}
+		});
+	});
+	traverse$4(bodyNode, {
+		VariableDeclaration(path) {
+			path.node.declarations.forEach((declaration) => {
+				if (declaration.id.type === "Identifier") {
+					const name = declaration.id.name;
+					const binding = path.scope.getBinding(name);
+					if (binding && binding.scope === functionScope) {
+						graph.nodes.add(name);
+						nodeCollection.addNode(name, declaration, { comment: getComment(path.node) });
+						if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+					}
+				} else 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 && binding.scope === functionScope) {
+							graph.nodes.add(name);
+							nodeCollection.addNode(name, property.value, { comment: getComment(property) });
+							if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+						}
+					} else if (property.type === "RestElement" && property.argument.type === "Identifier") {
+						const name = property.argument.name;
+						const binding = path.scope.getBinding(name);
+						if (binding && binding.scope === functionScope) {
+							graph.nodes.add(name);
+							nodeCollection.addNode(name, property.argument, { comment: getComment(property) });
+							if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+						}
+					}
+				});
+				else 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 && binding.scope === functionScope) {
+							graph.nodes.add(name);
+							nodeCollection.addNode(name, element, { comment: getComment(path.node) });
+							if (!graph.edges.get(name)) graph.edges.set(name, /* @__PURE__ */ new Set());
+						}
+					}
+				});
+			});
+		},
+		FunctionDeclaration(path) {
+			const name = path.node.id?.name;
+			if (name) {
+				const binding = path.scope.getBinding(name);
+				if (binding && binding.scope === functionScope) {
+					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());
+				}
+			}
+		}
+	}, functionScope, functionPath);
+	function traverseHooks(node, parentScope) {
+		if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.type === "Identifier" || node.type === "CallExpression" && node.callee.type === "Identifier") {
+			const hookName$1 = (() => {
+				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$1) return;
+			const hookBinding = parentScope.getBinding(hookName$1);
+			if (!(hookBinding === void 0 || hookBinding?.scope === functionScope)) return;
+			const expression = node.type === "ExpressionStatement" ? node.expression : node;
+			const watchArgs = /* @__PURE__ */ new Set();
+			if (watchHooks$1.includes(hookName$1)) {
+				if (expression.arguments[0]?.type === "Identifier") {
+					const binding = parentScope.getBinding(expression.arguments[0].name);
+					if (binding && graph.nodes.has(expression.arguments[0].name) && binding.scope === functionScope) watchArgs.add(expression.arguments[0]);
+				} else if (expression.arguments[0]) traverse$4(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 === functionScope) watchArgs.add(path1.node);
+				} }, parentScope, node);
+			}
+			expression.arguments.forEach((argNode, index) => {
+				if (watchHooks$1.includes(hookName$1) && index === 0 && argNode.type === "Identifier") {
+					const _node = nodeCollection.getNode(argNode.name);
+					if (_node?.info?.used) _node?.info?.used?.add(hookName$1);
+					else if (_node) _node.info = {
+						..._node?.info,
+						used: new Set([hookName$1])
+					};
+					return;
+				}
+				if (argNode.type === "Identifier") {
+					const binding = parentScope.getBinding(argNode.name);
+					if (binding && graph.nodes.has(argNode.name) && binding.scope === functionScope) {
+						const _node = nodeCollection.getNode(argNode.name);
+						if (_node?.info?.used) _node?.info?.used?.add(hookName$1);
+						else if (_node) _node.info = {
+							..._node?.info,
+							used: new Set([hookName$1])
+						};
+					}
+				} else traverse$4(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 === functionScope) {
+						if ([...watchHooks$1].includes(hookName$1) && 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$1);
+						else if (_node) _node.info = {
+							..._node?.info,
+							used: new Set([hookName$1])
+						};
+					}
+				} }, parentScope, node);
+			});
+		}
+	}
+	traverse$4(bodyNode, {
+		FunctionDeclaration(path) {
+			const name = path.node.id?.name;
+			if (name && graph.nodes.has(name) && path.scope.getBinding(name)?.scope === functionScope) traverse$4(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 === functionScope) graph.edges.get(name)?.add({
+					label: path1.node.name,
+					type: getRelationType(path1)
+				});
+			} }, path.scope, path);
+		},
+		VariableDeclarator(path) {
+			if (path.node.init) {
+				if (path.node.id.type === "Identifier") {
+					const name = path.node.id.name;
+					if (name && graph.nodes.has(name) && path.scope.getBinding(name)?.scope === functionScope) {
+						if (path.node.init.type === "CallExpression" && path.node.init.callee.type === "Identifier" && allEffectHooks.includes(path.node.init.callee.name)) traverseHooks(path.node.init, path.scope);
+						traverse$4(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 === functionScope) graph.edges.get(name)?.add({
+								label: path1.node.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;
+						const isValidNode = name && graph.nodes.has(name) && path.node.init && path.scope.getBinding(name)?.scope === functionScope;
+						if (isValidNode) traverse$4(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 === functionScope) graph.edges.get(name)?.add({
+								label: path1.node.name,
+								type: getRelationType(path1)
+							});
+						} }, path.scope, path);
+					}
+				});
+				else if (path.node.id.type === "ArrayPattern") path.node.id.elements.forEach((element) => {
+					if (element?.type === "Identifier") {
+						const name = element.name;
+						const isValidNode = name && graph.nodes.has(name) && path.node.init && path.scope.getBinding(name)?.scope === functionScope;
+						if (isValidNode) traverse$4(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 === functionScope) 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$4(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 === functionScope) graph.edges.get(name)?.add({
+						label: path1.node.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$4(path.node.value, { Identifier(path1) {
+					if (path1.node.name === name) return;
+					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 === functionScope) graph.edges.get(name)?.add({
+						label: path1.node.name,
+						type: getRelationType(path1)
+					});
+				} }, path.scope, path);
+			}
+		},
+		ExpressionStatement(path) {
+			if (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.getBinding(name)?.scope === functionScope) {
+					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.node.expression.type === "AssignmentExpression" && path.node.expression.right.type === "CallExpression" && path.node.expression.right.callee.type === "Identifier") traverseHooks(path.node.expression.right, path.scope);
+		}
+	}, functionScope, functionPath);
+	traverse$4(bodyNode, { ReturnStatement(path) {
+		const fnParent = path.findParent((p) => p.isFunction());
+		if (fnParent && fnParent.node !== functionNode) return;
+		if (path.node.argument?.type === "ObjectExpression") {
+			const returnNode = path.node.argument;
+			traverse$4(returnNode, {
+				ObjectProperty(path3) {
+					if (path3.parent === returnNode) {
+						if (path3.node.key.type === "Identifier" && path3.node.value.type === "Identifier") nodesUsedInReturn.add(path3.node.value.name);
+					}
+				},
+				SpreadElement(path3) {
+					if (path3.node.argument.type === "Identifier") nodesUsedInReturn.add(path3.node.argument.name);
+				}
+			}, path.scope, path);
+		} else if (path.node.argument?.type === "ArrayExpression") path.node.argument.elements.forEach((element) => {
+			if (element?.type === "Identifier") nodesUsedInReturn.add(element.name);
+		});
+		else if (path.node.argument?.type === "Identifier") nodesUsedInReturn.add(path.node.argument.name);
+	} }, functionScope, functionPath);
+	return {
+		graph,
+		nodeCollection,
+		nodesUsedInReturn,
+		hookName
+	};
+}
+function analyzeHook(content, lineOffset = 0, framework = "vue") {
+	const ast = (0, __vue_compiler_sfc.babelParse)(content, {
+		sourceType: "module",
+		plugins: ["typescript", "jsx"]
+	});
+	const results = [];
+	function walkCallExpressionChain(node, path, pathSegments) {
+		if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") try {
+			return path.get(pathSegments.join("."));
+		} catch {
+			return void 0;
+		}
+		if (node.type === "CallExpression") for (let i = 0; i < node.arguments.length; i++) {
+			const arg = node.arguments[i];
+			if (arg.type === "ArrowFunctionExpression" || arg.type === "FunctionExpression") try {
+				return path.get([
+					...pathSegments,
+					"arguments",
+					i
+				].join("."));
+			} catch {}
+			else if (arg.type === "CallExpression") {
+				const result = walkCallExpressionChain(arg, path, [
+					...pathSegments,
+					"arguments",
+					i
+				]);
+				if (result) return result;
+			}
+		}
+		return void 0;
+	}
+	function extractHookFromDeclarator(decl, varPath) {
+		const init = decl.init;
+		const hookName = decl.id.type === "Identifier" ? decl.id.name : "";
+		if (!init) return;
+		const funcPath = walkCallExpressionChain(init, varPath, ["init"]);
+		if (funcPath) results.push(processHookFunction(funcPath, lineOffset, hookName, framework));
+	}
+	traverse$4(ast, {
+		ExportDefaultDeclaration(path) {
+			const declaration = path.node.declaration;
+			if (declaration.type === "FunctionDeclaration" && declaration.id?.name.startsWith("use")) {
+				const funcPath = path.get("declaration");
+				results.push(processHookFunction(funcPath, lineOffset, "", framework));
+			}
+		},
+		ExportNamedDeclaration(path) {
+			const declaration = path.node.declaration;
+			if (declaration?.type === "FunctionDeclaration" && declaration.id?.name.startsWith("use")) {
+				const funcPath = path.get("declaration");
+				results.push(processHookFunction(funcPath, lineOffset, "", framework));
+			} else if (declaration?.type === "VariableDeclaration") declaration.declarations.forEach((decl) => {
+				if (decl.id.type === "Identifier" && decl.id.name.startsWith("use")) {
+					const varPath = path.get("declaration.declarations").find((p) => {
+						const node = p.node;
+						const nodeId = node.id;
+						return nodeId.type === "Identifier" && nodeId.name === decl.id.name;
+					});
+					if (varPath) extractHookFromDeclarator(decl, varPath);
+				}
+			});
+		},
+		FunctionDeclaration(path) {
+			if (path.node.id?.name.startsWith("use") && path.parent.type === "Program") results.push(processHookFunction(path, lineOffset, "", framework));
+		},
+		VariableDeclaration(path) {
+			if (path.parent.type === "Program") path.node.declarations.forEach((decl) => {
+				if (decl.id.type === "Identifier" && decl.id.name.startsWith("use")) {
+					const declName = decl.id.name;
+					const varPath = path.get("declarations").find((p) => {
+						const node = p.node;
+						const nodeId = node.id;
+						return nodeId.type === "Identifier" && nodeId.name === declName;
+					});
+					if (varPath) extractHookFromDeclarator(decl, varPath);
+				}
+			});
+		}
+	});
+	return results.map((result) => ({
+		graph: result.nodeCollection.map(result.graph),
+		nodesUsedInReturn: result.nodesUsedInReturn,
+		hookName: result.hookName
+	}));
+}
+
 //#endregion
 //#region src/analyze/setupScript.ts
 const traverse$3 = __babel_traverse.default.default?.default || __babel_traverse.default.default || __babel_traverse.default;
@@ -1802,7 +2204,6 @@ function buildWeightedGraph(graph, options = {}) {
 	const { semanticWeight = 1, similarityThreshold = .3 } = options;
 	const weighted = /* @__PURE__ */ new Map();
 	const allNodes = /* @__PURE__ */ new Set();
-	const connectedPairs = /* @__PURE__ */ new Set();
 	for (const [node, edges] of graph) {
 		allNodes.add(node);
 		for (const edge of edges) allNodes.add(edge.node);
@@ -1814,8 +2215,6 @@ function buildWeightedGraph(graph, options = {}) {
 		weighted.get(node).set(edge.node, Math.max(currentWeight, structuralWeight));
 		const reverseWeight = weighted.get(edge.node).get(node) || 0;
 		weighted.get(edge.node).set(node, Math.max(reverseWeight, structuralWeight));
-		const pairKey = [node.label, edge.node.label].sort().join("|");
-		connectedPairs.add(pairKey);
 	}
 	if (semanticWeight > 0) {
 		const nodeWordsCache = /* @__PURE__ */ new Map();
@@ -1842,14 +2241,11 @@ function buildWeightedGraph(graph, options = {}) {
 				const wordsB = nodeWordsCache.get(nodeB);
 				const similarity = calculateSemanticSimilarityCached(nodeA.label, nodeB.label, wordsA, wordsB);
 				if (similarity > similarityThreshold) {
-					const isConnected = connectedPairs.has(comparedKey);
 					const semanticEdgeWeight = similarity * semanticWeight;
-					const currentAB = weighted.get(nodeA).get(nodeB) || 0;
-					const newWeightAB = isConnected ? Math.max(currentAB, semanticEdgeWeight) : currentAB + semanticEdgeWeight;
-					weighted.get(nodeA).set(nodeB, Math.min(newWeightAB, 2));
-					const currentBA = weighted.get(nodeB).get(nodeA) || 0;
-					const newWeightBA = isConnected ? Math.max(currentBA, semanticEdgeWeight) : currentBA + semanticEdgeWeight;
-					weighted.get(nodeB).set(nodeA, Math.min(newWeightBA, 2));
+					const currentAB = weighted.get(nodeA).get(nodeB);
+					if (typeof currentAB === "number") weighted.get(nodeA).set(nodeB, Math.min(Math.max(currentAB, semanticEdgeWeight), 2));
+					const currentBA = weighted.get(nodeB).get(nodeA);
+					if (typeof currentBA === "number") weighted.get(nodeB).set(nodeA, Math.min(Math.max(currentBA, semanticEdgeWeight), 2));
 				}
 			}
 		}
@@ -2333,7 +2729,7 @@ 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()) {
+function getVisData(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__ */ new Set(), usedLabel) {
 	const usedNodes = new Set([...nodesUsedInTemplate, ...nodesUsedInStyle]);
 	const nodes = [];
 	const edges = [];
@@ -2356,7 +2752,7 @@ function getVisData(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__
 			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,
+			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) ? usedLabel || "template" : ""].filter(Boolean).join(" and ")}\n\n` : ""}${node.info?.comment || ""}`.trim() || void 0,
 			info: node.info
 		});
 	});
@@ -2381,6 +2777,7 @@ function getVisData(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__
 
 //#endregion
 exports.SuggestionType = SuggestionType;
+exports.analyzeHook = analyzeHook;
 exports.analyzeOptions = analyze;
 exports.analyzeSetupScript = analyze$1;
 exports.analyzeStyle = analyze$2;