js-code-detector 0.0.51 → 0.0.53

package/dist/cjs/util/ast_util/helper/deepFirstTravel.js

@@ -0,0 +1,142 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/ast_util/helper/deepFirstTravel.ts
+var deepFirstTravel_exports = {};
+__export(deepFirstTravel_exports, {
+  default: () => deepFirstTravel
+});
+module.exports = __toCommonJS(deepFirstTravel_exports);
+var import_SHARED_CONSTANTS = require("../SHARED_CONSTANTS");
+var import_isValidNodeCollect = __toESM(require("./isValidNodeCollect"));
+var import_isValidArrayNodeCollect = __toESM(require("./isValidArrayNodeCollect"));
+var import_updateLoc = __toESM(require("./updateLoc"));
+var import_collectDependenceIds = __toESM(require("./collectDependenceIds"));
+var import_collectEffectId = __toESM(require("./collectEffectId"));
+var import_collectHoldingIds = __toESM(require("./collectHoldingIds"));
+var import_updateImportedAndExportedMember = __toESM(require("./updateImportedAndExportedMember"));
+function deepFirstTravel(node, visitedNodeSet, extra) {
+  visitedNodeSet.add(node);
+  const { filePath, depth, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet, stopTravelCallback } = 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(),
+    dependenceIdsNoScope: /* @__PURE__ */ new Set(),
+    holdingIdType: null,
+    holdingIds: /* @__PURE__ */ new Set(),
+    holdingIdNameMap: /* @__PURE__ */ new Map(),
+    inject: /* @__PURE__ */ new Set(),
+    provide: /* @__PURE__ */ new Set(),
+    effectIds: /* @__PURE__ */ new Set(),
+    occupation: /* @__PURE__ */ new Set(),
+    importedMember: [],
+    exportedMember: []
+  };
+  node._util = _util;
+  const { nodeCollection, children } = _util;
+  const stopTravel = stopTravelCallback == null ? void 0 : stopTravelCallback(node);
+  if (stopTravel) {
+    return node;
+  }
+  Object.keys(node).forEach((nodeKey) => {
+    if (import_SHARED_CONSTANTS.INVALID_NODE_KEY.includes(nodeKey)) {
+      return;
+    }
+    const nodeValue = node[nodeKey];
+    if (visitedNodeSet.has(nodeValue) || !nodeValue) {
+      return;
+    }
+    if ((0, import_isValidNodeCollect.default)(nodeValue)) {
+      const childNode = deepFirstTravel(nodeValue, visitedNodeSet, { filePath, depth: depth + 1, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet, stopTravelCallback });
+      nodeCollection.push(childNode, ...childNode._util.nodeCollection);
+      children.push(childNode);
+      childNode._util.parentProperty = nodeKey;
+    } else if ((0, import_isValidArrayNodeCollect.default)(nodeValue)) {
+      const validNodeArray = nodeValue.filter((nodeItem) => (0, import_isValidNodeCollect.default)(nodeItem)).map((v) => {
+        return deepFirstTravel(v, visitedNodeSet, { filePath, depth: depth + 1, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet, stopTravelCallback });
+      });
+      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;
+      });
+    }
+  });
+  try {
+    children.forEach((child) => child._util.parent = node);
+    nodeCollection.forEach((nodeItem) => {
+      !nodeItem._util.ancestors.includes(node) && nodeItem._util.ancestors.unshift(node);
+    });
+  } catch (e) {
+    console.error("parent ancestors update", e.message);
+  }
+  try {
+    const skip = nodeCollection.some((nodeItem) => stopTravelCallback == null ? void 0 : stopTravelCallback(nodeItem));
+    if (!skip) {
+      (0, import_collectHoldingIds.default)(node);
+    }
+  } catch (e) {
+    console.error("收集持有的 identifier 出错", e.message);
+  }
+  try {
+    (0, import_collectDependenceIds.default)(node);
+  } catch (e) {
+    console.error("收集使用的标识符号", e.message);
+  }
+  if (node.type === "Program") {
+    try {
+      nodeCollection.forEach((child) => (0, import_collectEffectId.default)(child));
+    } catch (e) {
+      console.error("collectEffectId", e.message);
+    }
+    try {
+      node.body.forEach((child) => (0, import_updateImportedAndExportedMember.default)(child, node));
+    } catch (e) {
+      console.error("收集导入、导出成员信息报错", e.message);
+    }
+  }
+  try {
+    (0, import_updateLoc.default)(node, { mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet });
+  } catch (e) {
+    console.error("updateLoc", e.message);
+  }
+  return node;
+}

package/dist/cjs/util/ast_util/helper/deepSearchParamsIdentifier.d.ts

@@ -0,0 +1,2 @@
+import { AstNode } from "../AstUtil";
+export default function deepSearchParamsIdentifier(id: AstNode | null, callback: (identifier: AstNode) => void): void;

package/dist/cjs/util/ast_util/helper/deepSearchParamsIdentifier.js

@@ -0,0 +1,55 @@
+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/helper/deepSearchParamsIdentifier.ts
+var deepSearchParamsIdentifier_exports = {};
+__export(deepSearchParamsIdentifier_exports, {
+  default: () => deepSearchParamsIdentifier
+});
+module.exports = __toCommonJS(deepSearchParamsIdentifier_exports);
+function deepSearchParamsIdentifier(id, callback) {
+  if (!id) {
+    return;
+  }
+  if (id.type === "Identifier") {
+    callback(id);
+  }
+  if (id.type === "AssignmentPattern") {
+    const left = id.left;
+    deepSearchParamsIdentifier(left, callback);
+  }
+  if (id.type === "RestElement") {
+    deepSearchParamsIdentifier(id.argument, callback);
+  }
+  if (id.type === "ObjectProperty") {
+    const value = id.value;
+    deepSearchParamsIdentifier(value, callback);
+  }
+  if (id.type === "ObjectPattern") {
+    const properties = id.properties;
+    for (const property of properties) {
+      deepSearchParamsIdentifier(property, callback);
+    }
+  }
+  if (id.type === "ArrayPattern") {
+    const elements = id.elements;
+    for (const element of elements) {
+      deepSearchParamsIdentifier(element, callback);
+    }
+  }
+}

package/dist/cjs/util/ast_util/helper/findOrCreateExportedMember.d.ts

@@ -0,0 +1,9 @@
+import { AstNode } from "../AstUtil";
+export default function findOrCreateExportedMember(exportedMember: AstNode['_util']['exportedMember'], sourceValue: string): {
+    sourcePath: string;
+    members: {
+        exportedName: string;
+        localName: string;
+    }[];
+    ExportAllDeclaration: boolean;
+};

package/dist/cjs/util/ast_util/helper/findOrCreateExportedMember.js

@@ -0,0 +1,32 @@
+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/helper/findOrCreateExportedMember.ts
+var findOrCreateExportedMember_exports = {};
+__export(findOrCreateExportedMember_exports, {
+  default: () => findOrCreateExportedMember
+});
+module.exports = __toCommonJS(findOrCreateExportedMember_exports);
+function findOrCreateExportedMember(exportedMember, sourceValue) {
+  let target = exportedMember.find((v) => v.sourcePath === sourceValue);
+  if (!target) {
+    target = { sourcePath: sourceValue, members: [], ExportAllDeclaration: false };
+    exportedMember.push(target);
+  }
+  return target;
+}

package/dist/cjs/util/ast_util/helper/findOrCreateImportedMember.d.ts

@@ -0,0 +1,8 @@
+import { AstNode } from "../AstUtil";
+export default function findOrCreateImportedMember(importedMember: AstNode['_util']['importedMember'], sourceValue: string): {
+    sourcePath: string;
+    members: {
+        importedName: string;
+        localName: string;
+    }[];
+};

package/dist/cjs/util/ast_util/helper/findOrCreateImportedMember.js

@@ -0,0 +1,32 @@
+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/helper/findOrCreateImportedMember.ts
+var findOrCreateImportedMember_exports = {};
+__export(findOrCreateImportedMember_exports, {
+  default: () => findOrCreateImportedMember
+});
+module.exports = __toCommonJS(findOrCreateImportedMember_exports);
+function findOrCreateImportedMember(importedMember, sourceValue) {
+  let target = importedMember.find((v) => v.sourcePath === sourceValue);
+  if (!target) {
+    target = { sourcePath: sourceValue, members: [] };
+    importedMember.push(target);
+  }
+  return target;
+}

package/dist/cjs/util/ast_util/helper/getExportedNameOfAncestor.d.ts

@@ -0,0 +1,2 @@
+import { AstNode } from "../AstUtil";
+export default function getExportedNameOfAncestor(node: AstNode | undefined | null): string[];

package/dist/cjs/util/ast_util/helper/getExportedNameOfAncestor.js

@@ -0,0 +1,113 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/ast_util/helper/getExportedNameOfAncestor.ts
+var getExportedNameOfAncestor_exports = {};
+__export(getExportedNameOfAncestor_exports, {
+  default: () => getExportedNameOfAncestor
+});
+module.exports = __toCommonJS(getExportedNameOfAncestor_exports);
+var import_SHARED_CONSTANTS = require("../SHARED_CONSTANTS");
+var import_getExportedNameOfDeclarationIdentifier = __toESM(require("./getExportedNameOfDeclarationIdentifier"));
+var import_collectVariableDeclarationIdentifiers = __toESM(require("./collectVariableDeclarationIdentifiers"));
+var import_deepSearchParamsIdentifier = __toESM(require("./deepSearchParamsIdentifier"));
+function getExportedNameOfAncestor(node) {
+  var _a, _b;
+  if (!node) {
+    console.warn("获取 上级导出成员名字报错: node is null");
+    return [];
+  }
+  const ancestors = node._util.ancestors;
+  const nodeArray = [...ancestors, node];
+  const nameList = /* @__PURE__ */ new Set();
+  outer:
+    for (const ancestor of nodeArray) {
+      if (ancestor.type === "VElement") {
+        nameList.add("default");
+        break outer;
+      }
+      if (ancestor.type === "ExportDefaultDeclaration") {
+        const { declaration } = ancestor;
+        if (declaration) {
+          nameList.add("default");
+          break outer;
+        }
+      }
+      if (ancestor.type === "ExportNamedDeclaration") {
+        const declarationType = (_a = ancestor.declaration) == null ? void 0 : _a.type;
+        if (import_SHARED_CONSTANTS.EXPORT_DECLARATION_TYPES.includes(declarationType)) {
+          const nameToAdd = ancestor.declaration.id.name;
+          if (nameToAdd) {
+            nameList.add(nameToAdd);
+          }
+          break outer;
+        } else if (["VariableDeclaration"].includes(declarationType)) {
+          (0, import_collectVariableDeclarationIdentifiers.default)(ancestor.declaration, (identifier) => {
+            nameList.add(identifier.name);
+          });
+          break outer;
+        } else if (declarationType) {
+          console.log("未处理的 declarationType :", declarationType);
+        }
+        const specifiers = ancestor.specifiers;
+        if (Array.isArray(specifiers)) {
+          for (const specifier of specifiers) {
+            if (specifier.type === "ExportSpecifier" || specifier.type === "ExportNamespaceSpecifier") {
+              nameList.add(specifier.exported.name);
+            }
+          }
+        }
+        break outer;
+      }
+      if (["FunctionDeclaration", "ClassDeclaration"].includes(ancestor.type) && "Program" === ((_b = ancestor._util.parent) == null ? void 0 : _b.type)) {
+        const ancestorId = ancestor.id;
+        if (ancestorId) {
+          const nameToAdd = (0, import_getExportedNameOfDeclarationIdentifier.default)(ancestorId);
+          if (nameToAdd) {
+            nameList.add(nameToAdd);
+          }
+        }
+        break outer;
+      }
+      if (["VariableDeclarator"].includes(ancestor.type)) {
+        const id = ancestor.id;
+        const varIdentifierSet = /* @__PURE__ */ new Set();
+        (0, import_deepSearchParamsIdentifier.default)(id, (identifier) => {
+          varIdentifierSet.add(identifier);
+        });
+        for (const identifier of varIdentifierSet) {
+          const nameToAdd = (0, import_getExportedNameOfDeclarationIdentifier.default)(identifier);
+          if (nameToAdd) {
+            nameList.add(nameToAdd);
+          }
+        }
+        break outer;
+      }
+    }
+  return Array.from(nameList);
+}

package/dist/cjs/util/ast_util/helper/getExportedNameOfDeclarationIdentifier.d.ts

@@ -0,0 +1,2 @@
+import { AstNode } from "../AstUtil";
+export default function getExportedNameOfDeclarationIdentifier(id: AstNode): any;

package/dist/cjs/util/ast_util/helper/getExportedNameOfDeclarationIdentifier.js

@@ -0,0 +1,40 @@
+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/helper/getExportedNameOfDeclarationIdentifier.ts
+var getExportedNameOfDeclarationIdentifier_exports = {};
+__export(getExportedNameOfDeclarationIdentifier_exports, {
+  default: () => getExportedNameOfDeclarationIdentifier
+});
+module.exports = __toCommonJS(getExportedNameOfDeclarationIdentifier_exports);
+function getExportedNameOfDeclarationIdentifier(id) {
+  var _a;
+  const occupationInExport = [...id._util.occupation].filter((op) => {
+    var _a2;
+    return ["ExportSpecifier", "ExportDefaultDeclaration"].includes((_a2 = op._util.parent) == null ? void 0 : _a2.type);
+  });
+  for (const op of occupationInExport) {
+    const occupationParentType = (_a = op._util.parent) == null ? void 0 : _a.type;
+    if (occupationParentType === "ExportSpecifier") {
+      return op._util.parent.exported.name;
+    }
+    if (occupationParentType === "ExportDefaultDeclaration") {
+      return "default";
+    }
+  }
+}

package/dist/cjs/util/ast_util/helper/getImpactedNode.d.ts

@@ -0,0 +1,2 @@
+import { AstNode } from "../AstUtil";
+export default function getImpactedNode(ancestor: AstNode): AstNode | null;

package/dist/cjs/util/ast_util/helper/getImpactedNode.js

@@ -0,0 +1,50 @@
+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/helper/getImpactedNode.ts
+var getImpactedNode_exports = {};
+__export(getImpactedNode_exports, {
+  default: () => getImpactedNode
+});
+module.exports = __toCommonJS(getImpactedNode_exports);
+function getImpactedNode(ancestor) {
+  const { type } = ancestor;
+  if (type === "JSXOpeningElement") {
+    const { name } = ancestor.name;
+    if (name && typeof name === "object") {
+      return name;
+    }
+  }
+  if (type === "JSXElement") {
+    const { openingElement } = ancestor;
+    const { name } = openingElement;
+    if (name && typeof name === "object") {
+      return name;
+    }
+  }
+  if (type === "VariableDeclarator") {
+    return ancestor.id;
+  }
+  if (type === "AssignmentExpression") {
+    return ancestor.left;
+  }
+  if (type === "FunctionDeclaration") {
+    return ancestor.id || ancestor;
+  }
+  return null;
+}

package/dist/cjs/util/ast_util/helper/getNearestImpactedNode.d.ts

@@ -0,0 +1,2 @@
+import { AstNode } from "../AstUtil";
+export default function getNearestImpactedNode(ancestors: AstNode[]): AstNode | undefined;

package/dist/cjs/util/ast_util/helper/getNearestImpactedNode.js

@@ -0,0 +1,43 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/ast_util/helper/getNearestImpactedNode.ts
+var getNearestImpactedNode_exports = {};
+__export(getNearestImpactedNode_exports, {
+  default: () => getNearestImpactedNode
+});
+module.exports = __toCommonJS(getNearestImpactedNode_exports);
+var import_getImpactedNode = __toESM(require("./getImpactedNode"));
+function getNearestImpactedNode(ancestors) {
+  for (const ancestor of ancestors) {
+    const impactedNode = (0, import_getImpactedNode.default)(ancestor);
+    if (impactedNode) {
+      return impactedNode;
+    }
+  }
+}

package/dist/cjs/util/ast_util/helper/getNodePath.d.ts

@@ -0,0 +1,2 @@
+import { AstNode } from "../AstUtil";
+export default function getNodePath(node: AstNode): string;

package/dist/cjs/util/ast_util/helper/getNodePath.js

@@ -0,0 +1,27 @@
+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/helper/getNodePath.ts
+var getNodePath_exports = {};
+__export(getNodePath_exports, {
+  default: () => getNodePath
+});
+module.exports = __toCommonJS(getNodePath_exports);
+function getNodePath(node) {
+  return [...node._util.ancestors, node].map((n) => n.type).join(":") + ":" + node.name;
+}

package/dist/cjs/util/ast_util/helper/getShortNodeMsg.d.ts

@@ -0,0 +1,2 @@
+import { AstNode } from "../AstUtil";
+export default function getShortNodeMsg(node: AstNode, hideParentProperty?: boolean): string;

package/dist/cjs/util/ast_util/helper/getShortNodeMsg.js

@@ -0,0 +1,38 @@
+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/helper/getShortNodeMsg.ts
+var getShortNodeMsg_exports = {};
+__export(getShortNodeMsg_exports, {
+  default: () => getShortNodeMsg
+});
+module.exports = __toCommonJS(getShortNodeMsg_exports);
+function getShortNodeMsg(node, hideParentProperty = false) {
+  const { _util: { startLine, startColumn, endLine, endColumn, parentProperty, indexOfProperty } } = node;
+  let type = node.type;
+  let name = node.name;
+  if (name && typeof name === "object") {
+    type = name.type;
+    name = name.name;
+  }
+  const msg = [
+    hideParentProperty ? [] : [parentProperty, indexOfProperty !== null ? String(indexOfProperty) : null],
+    [type, name]
+  ].map((e) => e.filter(Boolean).join(":")).filter(Boolean).join(" ");
+  return `${msg}「${startLine}:${startColumn}, ${endLine}:${endColumn}」`;
+}

package/dist/cjs/util/ast_util/helper/getTopScopeNodesByLineNumberRange.d.ts

@@ -0,0 +1,2 @@
+import { AstNode } from "../AstUtil";
+export default function getTopScopeNodesByLineNumberRange(mapFileLineToNodeSet: Map<number, Set<AstNode>>, lineNumberStart: number, lineNumberEnd: number, loose?: boolean): AstNode[];