vue-hook-optimizer 0.0.77 → 0.0.79

package/dist/index.mjs

@@ -1,2500 +0,0 @@
-// src/analyze/options.ts
-import _traverse2 from "@babel/traverse";
-import { babelParse as babelParse2 } from "@vue/compiler-sfc";
-
-// src/analyze/setupScript.ts
-import _traverse from "@babel/traverse";
-import { babelParse } from "@vue/compiler-sfc";
-
-// src/analyze/utils.ts
-var NodeType = /* @__PURE__ */ ((NodeType3) => {
-  NodeType3["var"] = "var";
-  NodeType3["fun"] = "fun";
-  return NodeType3;
-})(NodeType || {});
-var NodeCollection = class {
-  lineOffset = 0;
-  addInfo = true;
-  constructor(_lineOffset = 0, _addInfo = true) {
-    this.lineOffset = _lineOffset;
-    this.addInfo = _addInfo;
-  }
-  nodes = /* @__PURE__ */ new Map();
-  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: "fun" /* 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: "var" /* 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()}
-`;
-    }
-  });
-  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()}
-`;
-    } else {
-      comment += `${_comment.value.trim()}
-`;
-    }
-  });
-  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";
-}
-
-// src/analyze/setupScript.ts
-var traverse = _traverse.default?.default || _traverse.default || _traverse;
-var ignoreFunctionsName = ["defineProps", "defineEmits", "withDefaults"];
-var watchHooks = [
-  "watch",
-  // from `@vueuse/core`
-  "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(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, /* @__PURE__ */ 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, /* @__PURE__ */ 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(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: /* @__PURE__ */ 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(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(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: /* @__PURE__ */ 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: /* @__PURE__ */ new Set([hookName])
-              };
-            }
-          }
-        } else {
-          traverse(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: /* @__PURE__ */ new Set([hookName])
-                  };
-                }
-              }
-            }
-          }, patentScope, node);
-        }
-      });
-    }
-  }
-  traverse(ast, {
-    FunctionDeclaration(path) {
-      const name = path.node.id?.name;
-      if (name && graph.nodes.has(name)) {
-        traverse(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(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(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(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(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(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(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: /* @__PURE__ */ 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(content, lineOffset = 0, jsx = false) {
-  const ast = babelParse(content, { sourceType: "module", plugins: [
-    "typescript",
-    ...jsx ? ["jsx"] : []
-  ] });
-  const { graph, nodeCollection } = processSetup(ast, void 0, void 0, void 0, lineOffset);
-  return nodeCollection.map(graph);
-}
-
-// src/analyze/options.ts
-var traverse2 = _traverse2.default?.default || _traverse2.default || _traverse2;
-var vueLifeCycleHooks = [
-  "beforeCreate",
-  "created",
-  "beforeMount",
-  "mounted",
-  "beforeUpdate",
-  "updated",
-  "beforeDestroy",
-  "destroyed",
-  "activated",
-  "deactivated",
-  "errorCaptured",
-  "renderTracked",
-  "renderTriggered",
-  "provide"
-];
-function analyze2(content, lineOffset = 0, jsx = false) {
-  const ast = babelParse2(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()
-  };
-  const nodesUsedInTemplate = /* @__PURE__ */ new Set();
-  function process(node, path) {
-    traverse2(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;
-            traverse2(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")) {
-            traverse2(path1.node.value, {
-              ReturnStatement(path2) {
-                const templateNode = path2.node;
-                traverse2(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 = [];
-            traverse2(setupNode, {
-              ReturnStatement(path2) {
-                if (path2.node.argument?.type === "ObjectExpression") {
-                  const returnNode = path2.node.argument;
-                  traverse2(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;
-                  traverse2(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);
-            traverse2(setupNode, {
-              ReturnStatement(path2) {
-                if (path2.scope !== path1.scope) {
-                  return;
-                }
-                if (path2.node.argument?.type === "ObjectExpression") {
-                  const returnNode = path2.node.argument;
-                  traverse2(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, /* @__PURE__ */ 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, /* @__PURE__ */ 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;
-            traverse2(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") {
-            traverse2(path1.node, {
-              ReturnStatement(path2) {
-                const templateNode = path2.node;
-                traverse2(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);
-    traverse2(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;
-            traverse2(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: /* @__PURE__ */ 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;
-                  traverse2(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") {
-                      traverse2(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;
-                  traverse2(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: /* @__PURE__ */ new Set([hookName])
-                    };
-                  }
-                  traverse2(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 {
-              traverse2(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: /* @__PURE__ */ new Set([hookName])
-                      };
-                    }
-                  }
-                }
-              }, path1.scope, path1);
-            }
-          }
-        }
-      }
-    }, path.scope, path);
-  }
-  traverse2(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
-  };
-}
-
-// src/analyze/style.ts
-function lexBinding(content, start) {
-  let state = 0 /* inParens */;
-  let parenDepth = 0;
-  for (let i = start; i < content.length; i++) {
-    const char = content.charAt(i);
-    switch (state) {
-      case 0 /* inParens */:
-        if (char === "'") {
-          state = 1 /* inSingleQuoteString */;
-        } else if (char === '"') {
-          state = 2 /* inDoubleQuoteString */;
-        } else if (char === "(") {
-          parenDepth++;
-        } else if (char === ")") {
-          if (parenDepth > 0) {
-            parenDepth--;
-          } else {
-            return i;
-          }
-        }
-        break;
-      case 1 /* inSingleQuoteString */:
-        if (char === "'") {
-          state = 0 /* inParens */;
-        }
-        break;
-      case 2 /* inDoubleQuoteString */:
-        if (char === '"') {
-          state = 0 /* 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;
-}
-var vBindRE = /v-bind\s*\(/g;
-function analyze3(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;
-}
-
-// src/analyze/template.ts
-import _traverse3 from "@babel/traverse";
-import { babelParse as babelParse3, compileTemplate } from "@vue/compiler-sfc";
-var traverse3 = _traverse3.default?.default || _traverse3.default || _traverse3;
-function analyze4(content) {
-  const id = "template";
-  const { code } = compileTemplate({
-    id,
-    source: content,
-    filename: `${id}.js`
-  });
-  const ast = babelParse3(code, { sourceType: "module", plugins: [
-    "typescript"
-  ] });
-  const nodes = /* @__PURE__ */ new Set();
-  traverse3(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);
-          }
-        }
-      }
-    },
-    // component
-    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;
-}
-
-// src/analyze/tsx.ts
-import { babelParse as babelParse4 } from "@vue/compiler-sfc";
-
-// src/utils/traverse.ts
-import _traverse4 from "@babel/traverse";
-var traverse4 = _traverse4.default?.default || _traverse4.default || _traverse4;
-function rescureObjectPattern({ node, rootScope, res, parentScope, parentPath }) {
-  traverse4(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);
-}
-function rescureArrayPattern({ node, rootScope, res, parentScope, parentPath }) {
-  traverse4(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;
-      traverse4(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);
-    traverse4(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);
-    traverse4(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;
-    traverse4(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 && // return () => (<div></div>)
-  // return function() (<div></div>)
-  ((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;
-  traverse4(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;
-        traverse4(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;
-        traverse4(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, /* @__PURE__ */ 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, /* @__PURE__ */ 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;
-        traverse4(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, /* @__PURE__ */ 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, /* @__PURE__ */ new Set([keyName]));
-          }
-        } else if (prop.type === "SpreadElement") {
-          console.warn("not support spread in spread");
-        }
-      });
-    }
-  }
-}
-
-// 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: node2, path, scope }, commentParentNode) {
-    const binding = path.scope.getBinding(name);
-    if (scope === binding?.scope) {
-      graph.nodes.add(name);
-      nodeCollection.addNode(name, node2, {
-        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: parentPath2 }) {
-    const binding = path.scope.getBinding(name);
-    if (binding?.scope === parentPath2.scope) {
-      nodesUsedInTemplate.add(name);
-    }
-  }
-  const setupPath = traverseSetup({ node, parentScope: parentPath.scope, parentPath });
-  const setupScope = setupPath.scope;
-  const setupNode = setupPath.node;
-  traverse4(setupNode, {
-    VariableDeclarator(path1) {
-      parseNodeIdentifierPattern({
-        path: path1,
-        rootScope: setupScope,
-        cb: (params2) => {
-          if (!spread.includes(params2.name)) {
-            addNode(params2, path1.node);
-          } else {
-            addGraphBySpreadIdentifier({
-              path: path1,
-              graph,
-              nodeCollection,
-              iname: params2.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
-      });
-    }
-  });
-  traverse4(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: node2, path, scope }, commentParentNode) {
-    const binding = path.scope.getBinding(name);
-    if (scope === binding?.scope) {
-      graph.nodes.add(name);
-      nodeCollection.addNode(name, node2, {
-        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: parentPath2 }) {
-    const binding = path.scope.getBinding(name);
-    if (binding?.scope === parentPath2.scope) {
-      nodesUsedInTemplate.add(name);
-    }
-  }
-  traverse4(node, {
-    VariableDeclarator(path1) {
-      parseNodeIdentifierPattern({
-        path: path1,
-        rootScope: parentScope,
-        cb: (params2) => {
-          addNode(params2, 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);
-  traverse4(node, {
-    ReturnStatement(path2) {
-      parseReturnJsxPattern({
-        path: path2,
-        parentPath,
-        cb: addUsed
-      });
-    }
-  }, parentScope, parentPath);
-  traverse4(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(params2) {
-    const { node, parentPath } = params2;
-    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(params2);
-        } else {
-          result = processByReturnNotJSX(params2);
-        }
-      }
-    });
-  }
-  traverse4(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 analyze5(content, type = "vue", lineOffset = 0, addInfo = true) {
-  const ast = babelParse4(content, { sourceType: "module", plugins: [
-    "typescript",
-    "jsx"
-  ] });
-  const { graph, nodeCollection, nodesUsedInTemplate } = processTsx({
-    node: ast,
-    type,
-    lineOffset,
-    addInfo
-  });
-  return {
-    graph: nodeCollection.map(graph),
-    nodesUsedInTemplate
-  };
-}
-
-// src/mermaid.ts
-function getMermaidText(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__ */ new Set(), options = {}) {
-  const direction = options.direction || "TB";
-  const usedNodes = /* @__PURE__ */ 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
-`;
-  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}
-`;
-  });
-  graph.edges.forEach((edge, key) => {
-    edge.forEach((to) => {
-      if (!to || !to.node.label) {
-        return;
-      }
-      mermaidText += `    ${key.label} --> ${to.node.label}
-`;
-    });
-  });
-  return mermaidText;
-}
-
-// src/suggest/filter.ts
-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 dfs2(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) {
-        dfs2(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()) {
-    dfs2(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(graph2, node) {
-    let children = 0;
-    disc.set(node, time);
-    low.set(node, time);
-    time++;
-    visited.add(node);
-    for (const neighbor of graph2.get(node) || []) {
-      if (!visited.has(neighbor.node)) {
-        children++;
-        parent.set(neighbor.node, node);
-        APUtil(graph2, 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;
-}
-
-// 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 = /* @__PURE__ */ 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;
-  });
-}
-
-// src/suggest/utils.ts
-function hasCycle(graph) {
-  const visited = /* @__PURE__ */ new Set();
-  const onStack = /* @__PURE__ */ new Set();
-  const stack = [];
-  let cycleNodes = [];
-  function dfs2(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 (dfs2(neighbor.node)) {
-        return true;
-      }
-    }
-    onStack.delete(node);
-    stack.pop();
-    return false;
-  }
-  for (const [node, targets] of graph) {
-    if (dfs2(node)) {
-      return { hasCycle: true, cycleNodes };
-    }
-  }
-  return { hasCycle: false, cycleNodes: [] };
-}
-
-// src/suggest/index.ts
-var SuggestionType = /* @__PURE__ */ ((SuggestionType2) => {
-  SuggestionType2["info"] = "info";
-  SuggestionType2["warning"] = "warning";
-  SuggestionType2["error"] = "error";
-  return SuggestionType2;
-})(SuggestionType || {});
-function gen(graph, nodesUsedInTemplate, nodesUsedInStyle = /* @__PURE__ */ new Set()) {
-  const usedNodes = /* @__PURE__ */ 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: "info" /* 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: "info" /* 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: "error" /* 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: "warning" /* 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 === "fun" /* fun */) {
-          suggestions.push({
-            type: "info" /* 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: "info" /* info */,
-        message: `Node [${node.label}] is not used, perhaps you can remove it.`,
-        nodeInfo: node
-      });
-    }
-  });
-  return suggestions;
-}
-
-// 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 = /* @__PURE__ */ 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 * 0.75 + outDegree * 0.25),
-      title: `${filterNodeUserd(node.info?.used).size ? `used by ${Array.from(filterNodeUserd(node.info?.used))?.map((i) => `\`${i}\``).join(",")}
-
-` : ""}${usedNodes.has(node.label) ? `used in ${[
-        nodesUsedInStyle.has(node.label) ? "style" : "",
-        nodesUsedInTemplate.has(node.label) ? "template" : ""
-      ].filter(Boolean).join(" and ")}
-
-` : ""}${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: 0.8
-          }
-        }
-      });
-    });
-  });
-  return {
-    nodes,
-    edges
-  };
-}
-
-// src/index.ts
-import { parse } from "@vue/compiler-sfc";
-export {
-  NodeType,
-  SuggestionType,
-  analyze2 as analyzeOptions,
-  analyze as analyzeSetupScript,
-  analyze3 as analyzeStyle,
-  analyze4 as analyzeTemplate,
-  analyze5 as analyzeTsx,
-  gen,
-  getMermaidText,
-  getVisData,
-  parse
-};
-//# sourceMappingURL=index.mjs.map