js-code-detector 0.0.1

package/dist/cjs/util/ast_util/AstUtil.js

@@ -0,0 +1,571 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/ast_util/AstUtil.ts
+var AstUtil_exports = {};
+__export(AstUtil_exports, {
+  default: () => AstUtil
+});
+module.exports = __toCommonJS(AstUtil_exports);
+var import_windowProperties = require("./windowProperties");
+var AstUtil = class {
+  static getNodePath(node) {
+    return [...node._util.ancestors, node].map((n) => n.type).join(":") + ":" + node.name;
+  }
+  static deepFirstTravel(node, filePath, mapUuidToNode, mapFileLineToNodeSet) {
+    const visitedNodeSet = /* @__PURE__ */ new Set();
+    if (!node) {
+      return;
+    }
+    return this._deepFirstTravel(node, visitedNodeSet, { filePath, depth: 0, mapUuidToNode, mapFileLineToNodeSet });
+  }
+  static _deepFirstTravel(node, visitedNodeSet, extra) {
+    visitedNodeSet.add(node);
+    const { filePath, depth, mapUuidToNode, mapFileLineToNodeSet } = extra;
+    const _util = {
+      startLine: NaN,
+      endLine: NaN,
+      startColumn: NaN,
+      endColumn: NaN,
+      filePath,
+      parent: null,
+      parentProperty: "",
+      indexOfProperty: null,
+      ancestors: [],
+      nodeCollection: [],
+      children: [],
+      uuid: "",
+      variableScope: [],
+      dependenceIds: /* @__PURE__ */ new Set(),
+      holdingIds: /* @__PURE__ */ new Set(),
+      holdingIdNameMap: /* @__PURE__ */ new Map(),
+      inject: /* @__PURE__ */ new Set(),
+      provide: /* @__PURE__ */ new Set(),
+      effectIds: /* @__PURE__ */ new Set(),
+      crossScope: /* @__PURE__ */ new Set()
+    };
+    node._util = _util;
+    const { nodeCollection, children } = _util;
+    Object.keys(node).forEach((nodeKey) => {
+      if (this.invalidNodeKey.includes(nodeKey) || nodeKey.startsWith("TS") || nodeKey.endsWith("Annotation")) {
+        return;
+      }
+      const nodeValue = node[nodeKey];
+      if (visitedNodeSet.has(nodeValue) || !nodeValue) {
+        return;
+      }
+      if (this.isValidNodeCollect(nodeValue)) {
+        const childNode = this._deepFirstTravel(nodeValue, visitedNodeSet, { filePath, depth: depth + 1, mapUuidToNode, mapFileLineToNodeSet });
+        nodeCollection.push(childNode, ...childNode._util.nodeCollection);
+        children.push(childNode);
+        childNode._util.parentProperty = nodeKey;
+      } else if (this.isValidArrayNodeCollect(nodeValue)) {
+        const validNodeArray = nodeValue.filter((nodeItem) => this.isValidNodeCollect(nodeItem)).map((v) => {
+          return this._deepFirstTravel(v, visitedNodeSet, { filePath, depth: depth + 1, mapUuidToNode, mapFileLineToNodeSet });
+        });
+        nodeCollection.push(...validNodeArray.map((n) => [n, ...n._util.nodeCollection]).flat());
+        children.push(...validNodeArray);
+        validNodeArray.forEach((v, index) => {
+          v._util.parentProperty = nodeKey;
+          v._util.indexOfProperty = index;
+        });
+      }
+    });
+    children.forEach((child) => child._util.parent = node);
+    nodeCollection.forEach((nodeItem) => nodeItem._util.ancestors.unshift(node));
+    this.collectHoldingIds(node);
+    this.collectInjectProvide(node);
+    this.collectEffectId(node);
+    this.updateLoc(node, { mapUuidToNode, mapFileLineToNodeSet });
+    return node;
+  }
+  static collectInjectProvide(ast) {
+    const { type, _util: { inject, provide, holdingIds } } = ast;
+    if (type !== "Program" || !this.isBodyArray(ast)) {
+      return;
+    }
+    ast.body.forEach((node) => {
+      node.type === "ImportDeclaration" && this.findIdOfImport(node, (id) => inject.add(id));
+      if (node.type === "ExportAllDeclaration") {
+        const { exported } = node;
+        provide.add(exported);
+        return;
+      }
+      if (node.type === "ExportDefaultDeclaration") {
+        const declaration = node.declaration;
+        if (declaration.type === "Identifier") {
+          const theOne = [...holdingIds].find((e) => e.name === declaration.name);
+          theOne && provide.add(theOne);
+        } else {
+          this.deepFindIdOfExpression(declaration, (id) => provide.add(id));
+        }
+      }
+      if (node.type === "ExportNamedDeclaration") {
+        const { specifiers, declaration } = node;
+        for (const specifier of specifiers) {
+          const { exported } = specifier;
+          provide.add(exported);
+        }
+        if (declaration && Array.isArray(declaration.declarations)) {
+          for (const dec of declaration.declarations) {
+            provide.add(dec);
+          }
+        }
+      }
+    });
+  }
+  static collectHoldingIds(node) {
+    const { holdingIds, holdingIdNameMap } = node._util;
+    if (this.isBodyArray(node)) {
+      const { body } = node;
+      body.forEach((cur) => {
+        if (cur.type === "ImportDeclaration") {
+          this.findIdOfImport(cur, (id) => holdingIds.add(id));
+        } else if (cur.type === "FunctionDeclaration" || cur.type === "ClassDeclaration") {
+          const id = cur.id;
+          id && holdingIds.add(id);
+        } else if (cur.type === "VariableDeclaration") {
+          this.findIdOfVariable(cur, (id) => holdingIds.add(id));
+        }
+      });
+    }
+    if (node.body && this.isBodyArray(node.body)) {
+      const { body } = node.body;
+      body.forEach((cur) => {
+        this.findIdOfFunctionOrVariableOrClass(cur, (id) => holdingIds.add(id));
+      });
+    }
+    if (["FunctionDeclaration", "ArrowFunctionExpression", "FunctionExpression"].includes(node.type)) {
+      node.params.forEach((param) => this._deepFindIdentifier(param, (id) => holdingIds.add(id)));
+    }
+    holdingIds.forEach((holdingId) => {
+      const holdingIdName = holdingId.name;
+      const nodeSetOfIdName = holdingIdNameMap.get(holdingIdName) || /* @__PURE__ */ new Set();
+      nodeSetOfIdName.add(holdingId);
+      holdingIdNameMap.set(holdingIdName, nodeSetOfIdName);
+    });
+    this.collectDependenceIds(node);
+  }
+  static isVarInit(node) {
+    var _a;
+    return node._util.parentProperty === "init" && ((_a = node._util.parent) == null ? void 0 : _a.type) === "VariableDeclarator";
+  }
+  static isReturnArgument(node) {
+    var _a;
+    return node._util.parentProperty === "argument" && ((_a = node._util.parent) == null ? void 0 : _a.type) === "ReturnStatement";
+  }
+  static collectDependenceIds(node) {
+    const { nodeCollection, dependenceIds, holdingIdNameMap } = node._util;
+    nodeCollection.forEach((e) => {
+      this.deepFindIdOfExpression(e, (id) => dependenceIds.add(id));
+      this.findExportIdentifiers(e, (id) => dependenceIds.add(id));
+      if (e.type === "Identifier" && (this.isVarInit(e) || this.isReturnArgument(e))) {
+        dependenceIds.add(e);
+      }
+    });
+    for (const dependenceId of dependenceIds) {
+      if (dependenceId._util.variableScope.length === 0) {
+        const sameNameIds = [...holdingIdNameMap.get(dependenceId.name) || []];
+        dependenceId._util.variableScope.push(...sameNameIds);
+        const firstPick = sameNameIds[0];
+        if (firstPick) {
+          firstPick._util.effectIds.add(dependenceId);
+          this.markDependenceIdAsCrossScope(dependenceId, firstPick);
+        }
+      }
+    }
+  }
+  static markDependenceIdAsCrossScope(node, scopeId) {
+    var _a, _b, _c;
+    const isParamsElement = scopeId._util.parentProperty === "params";
+    const isCalleeId = ((_a = node._util.parent) == null ? void 0 : _a.type) === "CallExpression" && node._util.parentProperty === "callee";
+    if (isParamsElement && isCalleeId) {
+      const fn = scopeId._util.parent;
+      const isFn = fn.type === "FunctionExpression" || fn.type === "ArrowFunctionExpression";
+      const isFnInVarDec = fn._util.parentProperty === "init" && ((_b = fn._util.parent) == null ? void 0 : _b.type) === "VariableDeclarator";
+      const isFnInAssign = fn._util.parentProperty === "right" && ((_c = fn._util.parent) == null ? void 0 : _c.type) === "AssignmentExpression";
+      if (isFn && isFnInVarDec) {
+        const idHolderOfFn = fn._util.parent.id;
+        node._util.crossScope.add(idHolderOfFn);
+      } else if (isFn && isFnInAssign) {
+        const idHolderOfFn = fn._util.parent.left;
+        node._util.crossScope.add(idHolderOfFn);
+      } else if (fn.type === "FunctionDeclaration") {
+        node._util.crossScope.add(fn);
+      }
+    }
+  }
+  static isUseStateVarDec(node) {
+    if (node.type !== "VariableDeclarator")
+      return false;
+    const { id, init } = node;
+    if (init.type !== "CallExpression" || id.type !== "ArrayPattern")
+      return false;
+    const { callee } = init;
+    return callee.type === "Identifier" && callee.name === "useState";
+  }
+  static isUseMemoVarDec(node) {
+    if (node.type !== "VariableDeclarator")
+      return false;
+    const { id, init } = node;
+    if (init.type !== "CallExpression")
+      return false;
+    const { callee } = init;
+    return callee.type === "Identifier" && callee.name === "useMemo";
+  }
+  static isUseCallbackVarDec(node) {
+    if (node.type !== "VariableDeclarator")
+      return false;
+    const { id, init } = node;
+    if (init.type !== "CallExpression")
+      return false;
+    const { callee } = init;
+    return callee.type === "Identifier" && callee.name === "useCallback";
+  }
+  // todo 不断完善
+  static collectEffectId(node) {
+    if (node.type === "VariableDeclarator") {
+      this.collectEffectIdOfVarDec(node);
+    }
+    if (node.type === "AssignmentExpression") {
+      this.collectEffectIdOfAssign(node);
+      return;
+    }
+    const isDeleteOperator = "UnaryExpression" === node.type && node.operator === "delete";
+    if (isDeleteOperator || ["UpdateExpression"].includes(node.type)) {
+      this.collectEffectIdOfUnaryUpdate(node);
+    }
+  }
+  static collectEffectIdOfVarDec(node) {
+    const { id, init } = node;
+    if (!init) {
+      return;
+    }
+    if (this.isUseStateVarDec(node)) {
+      this.collectEffectIdOfUseState(node);
+      return;
+    }
+    if (this.isUseMemoVarDec(node)) {
+      this.collectEffectIdOfUseMemo(node);
+      return;
+    }
+    if (this.isUseCallbackVarDec(node)) {
+      this.collectEffectIdOfUseCallback(node);
+      return;
+    }
+    const idSet = /* @__PURE__ */ new Set();
+    this._deepFindIdentifier(id, (ele) => idSet.add(ele));
+    const createdExpIdSet = /* @__PURE__ */ new Set();
+    ["Identifier", "ArrowFunctionExpression", "FunctionExpression"].includes(init.type) ? createdExpIdSet.add(init) : this.deepFindIdOfExpression(init, (id2) => createdExpIdSet.add(id2));
+    for (const createdId of idSet) {
+      createdId._util.effectIds = /* @__PURE__ */ new Set([...createdExpIdSet, ...createdId._util.effectIds]);
+    }
+  }
+  static collectEffectIdOfUseState(node) {
+    const { id, init } = node;
+    const args = init.arguments;
+    const argsIdSet = /* @__PURE__ */ new Set();
+    this._deepFindIdentifier(args[0], (ele) => argsIdSet.add(ele));
+    const stateNode = id.elements[0];
+    const setStateNode = id.elements[1];
+    if (stateNode) {
+      const stateIdSet = /* @__PURE__ */ new Set();
+      this._deepFindIdentifier(stateNode, (ele) => stateIdSet.add(ele));
+      const setStateIdSet = /* @__PURE__ */ new Set();
+      if (setStateNode) {
+        this._deepFindIdentifier(setStateNode, (ele) => setStateIdSet.add(ele));
+      }
+      for (const stateId of stateIdSet) {
+        stateId._util.effectIds = /* @__PURE__ */ new Set([...argsIdSet, ...setStateIdSet]);
+      }
+    }
+  }
+  static collectEffectIdOfUseMemo(node) {
+    const { id, init } = node;
+    const args = init.arguments;
+    const depsIdSet = /* @__PURE__ */ new Set();
+    this._deepFindIdentifier(args[1], (ele) => depsIdSet.add(ele));
+    const memoIdSet = /* @__PURE__ */ new Set();
+    this._deepFindIdentifier(id, (ele) => memoIdSet.add(ele));
+    for (const memoId of memoIdSet) {
+      memoId._util.effectIds = /* @__PURE__ */ new Set([...depsIdSet, ...memoId._util.effectIds]);
+    }
+  }
+  static collectEffectIdOfUseCallback(node) {
+    const { id, init } = node;
+    const args = init.arguments;
+    const depsIdSet = /* @__PURE__ */ new Set();
+    this._deepFindIdentifier(args[1], (ele) => depsIdSet.add(ele));
+    if (id) {
+      id._util.effectIds = /* @__PURE__ */ new Set([...depsIdSet, ...id._util.effectIds]);
+    }
+  }
+  static collectEffectIdOfAssign(node) {
+    const { left, right } = node;
+    const idSetOfRight = /* @__PURE__ */ new Set();
+    this.deepFindIdOfExpression(right, (id) => idSetOfRight.add(id));
+    if (left.type === "Identifier") {
+      const { left: left2 } = node;
+      left2._util.effectIds = /* @__PURE__ */ new Set([...idSetOfRight, ...left2._util.effectIds]);
+    } else {
+      const { left: left2 } = node;
+      const idSetOfLeft = /* @__PURE__ */ new Set();
+      this.deepFindIdOfExpression(left2, (id) => idSetOfLeft.add(id));
+      for (const id of idSetOfLeft) {
+        id._util.effectIds = /* @__PURE__ */ new Set([...idSetOfRight, ...id._util.effectIds]);
+      }
+    }
+    ;
+  }
+  static collectEffectIdOfUnaryUpdate(node) {
+    const { argument } = node;
+    const idSetOfArgument = /* @__PURE__ */ new Set();
+    this.deepFindIdOfExpression(argument, (id) => idSetOfArgument.add(id));
+    argument._util.effectIds = /* @__PURE__ */ new Set([...argument._util.effectIds, ...idSetOfArgument]);
+  }
+  static isBodyArray(node) {
+    return ["BlockStatement", "Program"].includes(node.type) && Array.isArray(node.body);
+  }
+  static findExportIdentifiers(node, callback) {
+    var _a;
+    if (!node) {
+      return;
+    }
+    if (node.type === "ExportDefaultDeclaration" && ((_a = node.declaration) == null ? void 0 : _a.type) === "Identifier") {
+      callback(node.declaration);
+      return;
+    }
+    if (node.type === "ExportNamedDeclaration" && Array.isArray(node.specifiers)) {
+      for (const specifier of node.specifiers) {
+        if (specifier.type === "ExportSpecifier") {
+          const local = specifier.local;
+          callback(local);
+        }
+      }
+    }
+  }
+  static expressionTypeIsIdentifier(exp) {
+    return (exp == null ? void 0 : exp.type) === "Identifier";
+  }
+  static deepFindIdOfExpression(exp, callback) {
+    if (!exp || exp.type === "ThisExpression") {
+      return;
+    }
+    this._deepFindIdOfExpression(exp, callback);
+  }
+  static _deepFindIdOfExpression(exp, callback) {
+    if (!exp || exp.type === "ThisExpression") {
+      return;
+    }
+    if (exp.type === "SpreadElement") {
+      const { argument } = exp;
+      this.expressionTypeIsIdentifier(argument) && callback(argument);
+    } else if (exp.type === "JSXSpreadChild") {
+      const expression = exp.expression;
+      callback(expression);
+    } else if (exp.type === "MemberExpression" || exp.type === "JSXMemberExpression") {
+      const rootIdentifier = this.getRootIdentifierOfMemberExpression(exp);
+      this.expressionTypeIsIdentifier(rootIdentifier) && callback(rootIdentifier);
+    } else if (exp.type === "ObjectExpression") {
+      const properties = exp.properties;
+      for (const property of properties) {
+        if (property.type === "SpreadElement") {
+          this._deepFindIdOfExpression(property, callback);
+        } else {
+          const value = property.value;
+          this.expressionTypeIsIdentifier(value) ? callback(value) : this._deepFindIdOfExpression(value, callback);
+        }
+      }
+    } else if (exp.type === "ArrayExpression") {
+      const elements = exp.elements;
+      for (const element of elements) {
+        this.expressionTypeIsIdentifier(element) ? callback(element) : this._deepFindIdOfExpression(element, callback);
+      }
+    } else if (exp.type === "ArrowFunctionExpression") {
+      const body = exp.body;
+      this.expressionTypeIsIdentifier(body) ? callback(body) : this._deepFindIdOfExpression(body, callback);
+    } else if (exp.type === "CallExpression") {
+      const callee = exp.callee;
+      this.expressionTypeIsIdentifier(callee) ? callback(callee) : this._deepFindIdOfExpression(callee, callback);
+      const args = exp.arguments;
+      for (const argument of args) {
+        this.expressionTypeIsIdentifier(argument) ? callback(argument) : this._deepFindIdOfExpression(argument, callback);
+      }
+    } else if (exp.type === "AssignmentExpression" || exp.type === "BinaryExpression" || exp.type === "LogicalExpression") {
+      const { left, right } = exp;
+      [left, right].forEach((e) => this.expressionTypeIsIdentifier(e) ? callback(e) : this._deepFindIdOfExpression(e, callback));
+    } else if (exp.type === "UpdateExpression") {
+      const argument = exp.argument;
+      this.expressionTypeIsIdentifier(argument) ? callback(argument) : this._deepFindIdOfExpression(argument, callback);
+    } else if (exp.type === "SequenceExpression") {
+      const { expressions } = exp;
+      for (const expression of expressions) {
+        this.expressionTypeIsIdentifier(expression) ? callback(expression) : this._deepFindIdOfExpression(expression, callback);
+      }
+    } else if (exp.type === "ConditionalExpression") {
+      const { test, consequent, alternate } = exp;
+      [test, consequent, alternate].forEach((e) => this._deepFindIdOfExpression(e, callback));
+    } else if (exp.type === "JSXExpressionContainer") {
+      const { expression } = exp;
+      expression.name && callback(expression);
+    } else if (exp.type === "JSXIdentifier") {
+      callback(exp);
+    }
+  }
+  static getRootIdentifierOfMemberExpression(memExp) {
+    if (memExp.type === "MemberExpression" || memExp.type === "JSXMemberExpression") {
+      return this.getRootIdentifierOfMemberExpression(memExp.object);
+    }
+    return memExp;
+  }
+  static findIdOfImport(node, callback) {
+    const specifiers = node.specifiers;
+    for (const specifier of specifiers) {
+      const local = specifier.local;
+      callback(local);
+    }
+  }
+  static findIdOfFunctionOrVariableOrClass(node, callback) {
+    if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
+      const id = node.id;
+      id && callback(id);
+    } else if (node.type === "VariableDeclaration") {
+      this.findIdOfVariable(node, callback);
+    }
+  }
+  static findIdOfVariable(node, callback) {
+    if (node.type !== "VariableDeclaration") {
+      return;
+    }
+    const declarations = node.declarations;
+    if (!Array.isArray(declarations)) {
+      return;
+    }
+    for (const declaration of declarations) {
+      const id = declaration.id;
+      id && this._deepFindIdentifier(id, callback);
+    }
+  }
+  static _deepFindIdentifier(id, callback) {
+    if (!id) {
+      return;
+    }
+    if (id.type === "Identifier") {
+      callback(id);
+    }
+    if (id.type === "ObjectPattern") {
+      const properties = id.properties;
+      for (const property of properties) {
+        const value = property.value;
+        this._deepFindIdentifier(value, callback);
+      }
+    }
+    if (id.type === "ArrayPattern") {
+      const elements = id.elements;
+      for (const element of elements) {
+        this._deepFindIdentifier(element, callback);
+      }
+    }
+    if (id.type === "RestElement") {
+      this._deepFindIdentifier(id.argument, callback);
+    }
+  }
+  static updateLoc(astNode, extra) {
+    var _a, _b, _c, _d, _e;
+    const { _util, type, name } = astNode;
+    const { mapUuidToNode, mapFileLineToNodeSet } = extra;
+    const { nodeCollection, filePath } = _util;
+    _util.startLine = Math.min(...nodeCollection.map((n) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = n.loc) == null ? void 0 : _a2.start) == null ? void 0 : _b2.line;
+    }), (_a = astNode.loc) == null ? void 0 : _a.start.line);
+    _util.endLine = Math.max(...nodeCollection.map((n) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = n.loc) == null ? void 0 : _a2.end) == null ? void 0 : _b2.line;
+    }), (_b = astNode.loc) == null ? void 0 : _b.end.line);
+    _util.startColumn = Math.min(...nodeCollection.map((n) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = n.loc) == null ? void 0 : _a2.start) == null ? void 0 : _b2.column;
+    }), (_c = astNode.loc) == null ? void 0 : _c.start.column);
+    _util.endColumn = Math.max(...nodeCollection.map((n) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = n.loc) == null ? void 0 : _a2.end) == null ? void 0 : _b2.column;
+    }), (_d = astNode.loc) == null ? void 0 : _d.end.column);
+    _util.uuid = `${filePath}:${type}:${name}「${_util.startLine}:${_util.startColumn},${_util.endLine}:${_util.endColumn}」`;
+    mapUuidToNode.set(_util.uuid, astNode);
+    for (let i = _util.startLine; i <= _util.endLine; i++) {
+      mapFileLineToNodeSet.set(i, mapFileLineToNodeSet.get(i) || /* @__PURE__ */ new Set());
+      (_e = mapFileLineToNodeSet.get(i)) == null ? void 0 : _e.add(astNode);
+    }
+    if (astNode.type === "Program") {
+      mapUuidToNode.set(astNode.type, astNode);
+    }
+  }
+  static isValidArrayNodeCollect(astNode) {
+    return Array.isArray(astNode) && astNode.some((v) => typeof (v == null ? void 0 : v.type) === "string");
+  }
+  static isValidNodeCollect(astNode) {
+    return typeof (astNode == null ? void 0 : astNode.type) === "string";
+  }
+  static isPropertyOfGlobal(node) {
+    return node.type === "Identifier" && !node._util.variableScope.length && this.windowProperties.includes(node.name);
+  }
+  static getTopScopeNodesByLineNumberRange(mapFileLineToNodeSet, lineNumberStart, lineNumberEnd) {
+    const nodeSet = /* @__PURE__ */ new Set();
+    for (let i = lineNumberStart; i <= lineNumberEnd; i++) {
+      const astNode = mapFileLineToNodeSet.get(i);
+      if (!astNode) {
+        continue;
+      }
+      for (const nodeItem of astNode) {
+        const { startLine, endLine } = nodeItem._util;
+        if (startLine >= lineNumberStart && endLine <= lineNumberEnd) {
+          nodeSet.add(nodeItem);
+        }
+      }
+    }
+    const collections = [...nodeSet].map((e) => e._util.nodeCollection).flat();
+    return [...nodeSet].filter((e) => !collections.includes(e));
+  }
+  static getTopScopeNodesByLineNumber(mapFileLineToNodeSet, lineNumber) {
+    const astNode = mapFileLineToNodeSet.get(lineNumber);
+    const lineOfNodes = [...new Set(astNode)].filter((e) => {
+      const { startLine, endLine } = e._util;
+      return startLine === lineNumber && endLine === lineNumber;
+    });
+    const collections = [...lineOfNodes].map((e) => e._util.nodeCollection).flat();
+    return lineOfNodes.filter((e) => !collections.includes(e));
+  }
+  static isSubNodeOfVariableDeclarator(node) {
+    const { ancestors } = node._util;
+    const typeList = ancestors.map((e) => e.type);
+    const index = typeList.lastIndexOf("VariableDeclarator");
+    if (index === -1) {
+      return false;
+    }
+    return ancestors.slice(index).every((ancestor) => ["Identifier", "ObjectPattern", "ArrayPattern"].includes(ancestor.type));
+  }
+  static createScopeContent(node) {
+    return [node._util.filePath, ":", node._util.startLine, "-", node._util.endLine, ":[", node.name || node.value, "]"].join("");
+  }
+};
+AstUtil.invalidNodeKey = [
+  "comments",
+  "tokens"
+];
+AstUtil.windowProperties = import_windowProperties.windowProperties;

package/dist/cjs/util/ast_util/FileUtil.d.ts

@@ -0,0 +1,19 @@
+import * as babelParse from "@babel/parser";
+import * as vueParse from "vue-eslint-parser";
+import { AstNode } from "./AstUtil";
+export declare const extensionsOfJs: string[];
+export declare const extensions: string[];
+export type MapFilePathToDetail = Map<string, FileSegment & {
+    lines: string[];
+}>;
+export type FileSegment = {
+    filePath: string;
+    fileContent: string;
+};
+export default class FileUtil {
+    static parseVue(filePath: string, fileContent: string): vueParse.AST.ESLintProgram;
+    static parseJsxLike(filePath: string, fileContent: string): babelParse.ParseResult<import("@babel/types").File>;
+    static createMapFilePathToDetail(list: FileSegment[]): MapFilePathToDetail;
+    static parseFile(filePath: string, fileContent: string): [string, Omit<AstNode, '_util'> | null];
+    static getASTByFilePath(filePath: string): Omit<AstNode, "_util"> | null;
+}