js-code-detector 0.0.52 → 0.0.54

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

@@ -0,0 +1,31 @@
+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/collectDeclarationIdentifiers.ts
+var collectDeclarationIdentifiers_exports = {};
+__export(collectDeclarationIdentifiers_exports, {
+  default: () => collectDeclarationIdentifiers
+});
+module.exports = __toCommonJS(collectDeclarationIdentifiers_exports);
+var import_SHARED_CONSTANTS = require("../SHARED_CONSTANTS");
+function collectDeclarationIdentifiers(node, callback) {
+  if (!import_SHARED_CONSTANTS.EXPORT_DECLARATION_TYPES.includes(node.type))
+    return;
+  const id = node.id;
+  id && callback(id);
+}

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

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

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

@@ -0,0 +1,90 @@
+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/collectDependenceIds.ts
+var collectDependenceIds_exports = {};
+__export(collectDependenceIds_exports, {
+  default: () => collectDependenceIds
+});
+module.exports = __toCommonJS(collectDependenceIds_exports);
+var import_intrinsicElements = require("../intrinsicElements");
+var import_windowProperties = require("../windowProperties");
+var import_collectDependenceIdsOfExportMembers = __toESM(require("./collectDependenceIdsOfExportMembers"));
+var import_collectExpressionIdentifiersShallow = __toESM(require("./collectExpressionIdentifiersShallow"));
+function collectDependenceIds(node) {
+  const { _util } = node;
+  const { dependenceIds, holdingIdNameMap, children, dependenceIdsNoScope, holdingIds } = _util;
+  children.forEach((child) => {
+    if (child._util.dependenceIdsNoScope.size > 0) {
+      child._util.dependenceIdsNoScope.forEach((id) => dependenceIds.add(id));
+    }
+    (0, import_collectDependenceIdsOfExportMembers.default)(child, (id) => dependenceIds.add(id));
+    (0, import_collectExpressionIdentifiersShallow.default)(child, (exp) => {
+      var _a, _b;
+      if (exp.type === "ThisExpression" || exp._util.holdingIdType || ["imported", "exported"].includes(exp._util.parentProperty))
+        return;
+      if (exp.type === "Identifier") {
+        if ((exp._util.parentProperty === "property" || exp._util.parentProperty === "key") && !((_a = exp._util.parent) == null ? void 0 : _a.computed))
+          return;
+      }
+      if (exp.type === "JSXIdentifier" && ((_b = exp._util.parent) == null ? void 0 : _b.type) === "JSXAttribute")
+        return;
+      dependenceIds.add(exp);
+    });
+  });
+  for (const dependenceId of [...dependenceIds]) {
+    if (!dependenceId._util) {
+      continue;
+    }
+    if (holdingIds.has(dependenceId)) {
+      dependenceIds.delete(dependenceId);
+      continue;
+    }
+    if (dependenceId._util.variableScope.length === 0 && typeof dependenceId.name === "string" && holdingIdNameMap.has(dependenceId.name)) {
+      dependenceId._util.variableScope.push(...holdingIdNameMap.get(dependenceId.name));
+      const firstPick = dependenceId._util.variableScope[0];
+      if (firstPick && firstPick._util.uuid !== dependenceId._util.uuid) {
+        firstPick._util.occupation.add(dependenceId);
+      }
+    }
+    if (dependenceId._util.variableScope.length === 0) {
+      dependenceIdsNoScope.add(dependenceId);
+    }
+  }
+  if (node.type === "Program") {
+    for (const dependenceId of [...dependenceIdsNoScope]) {
+      if (dependenceId.type === "JSXIdentifier" && import_intrinsicElements.intrinsicElements.includes(dependenceId.name)) {
+        dependenceIdsNoScope.delete(dependenceId);
+        dependenceIds.delete(dependenceId);
+      } else if (dependenceId.type === "Identifier" && import_windowProperties.windowProperties.includes(dependenceId.name)) {
+        dependenceIdsNoScope.delete(dependenceId);
+        dependenceIds.delete(dependenceId);
+      }
+    }
+  }
+}

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

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

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

@@ -0,0 +1,44 @@
+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/collectDependenceIdsOfExportMembers.ts
+var collectDependenceIdsOfExportMembers_exports = {};
+__export(collectDependenceIdsOfExportMembers_exports, {
+  default: () => collectDependenceIdsOfExportMembers
+});
+module.exports = __toCommonJS(collectDependenceIdsOfExportMembers_exports);
+function collectDependenceIdsOfExportMembers(node, callback) {
+  if (node.type === "ExportNamedDeclaration") {
+    const { declaration, specifiers } = node;
+    if ((declaration == null ? void 0 : declaration.type) === "Identifier") {
+      callback(declaration);
+    }
+    for (const specifier of specifiers) {
+      const { local } = specifier;
+      if ((local == null ? void 0 : local.type) === "Identifier") {
+        callback(local);
+      }
+    }
+  }
+  if (node.type === "ExportDefaultDeclaration") {
+    const declaration = node.declaration;
+    if ((declaration == null ? void 0 : declaration.type) === "Identifier") {
+      callback(declaration);
+    }
+  }
+}

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

@@ -0,0 +1,2 @@
+import { AstNode } from "../AstUtil";
+export default function collectEffectId(child: AstNode): void;

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

@@ -0,0 +1,26 @@
+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/collectEffectId.ts
+var collectEffectId_exports = {};
+__export(collectEffectId_exports, {
+  default: () => collectEffectId
+});
+module.exports = __toCommonJS(collectEffectId_exports);
+function collectEffectId(child) {
+}

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

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

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

@@ -0,0 +1,39 @@
+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/collectExpressionIdentifiersShallow.ts
+var collectExpressionIdentifiersShallow_exports = {};
+__export(collectExpressionIdentifiersShallow_exports, {
+  default: () => collectExpressionIdentifiersShallow
+});
+module.exports = __toCommonJS(collectExpressionIdentifiersShallow_exports);
+function collectExpressionIdentifiersShallow(exp, callback) {
+  var _a, _b;
+  if (!exp || exp.type === "ThisExpression" || exp._util.holdingIdType)
+    return;
+  if (exp.type === "Identifier") {
+    if ((exp._util.parentProperty === "property" || exp._util.parentProperty === "key") && !((_a = exp._util.parent) == null ? void 0 : _a.computed))
+      return;
+    callback(exp);
+    return;
+  }
+  if (exp.type === "JSXIdentifier" && ((_b = exp._util.parent) == null ? void 0 : _b.type) !== "JSXAttribute") {
+    callback(exp);
+    return;
+  }
+}

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

@@ -0,0 +1,4 @@
+import { AstNode } from "../AstUtil";
+export default function collectHoldingIds(node: AstNode & {
+    body: AstNode | null;
+}): void;

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

@@ -0,0 +1,110 @@
+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/collectHoldingIds.ts
+var collectHoldingIds_exports = {};
+__export(collectHoldingIds_exports, {
+  default: () => collectHoldingIds
+});
+module.exports = __toCommonJS(collectHoldingIds_exports);
+var import_SHARED_CONSTANTS = require("../SHARED_CONSTANTS");
+var import_collectDeclarationIdentifiers = __toESM(require("./collectDeclarationIdentifiers"));
+var import_collectImportDeclarationIdentifiers = __toESM(require("./collectImportDeclarationIdentifiers"));
+var import_collectVariableDeclarationIdentifiers = __toESM(require("./collectVariableDeclarationIdentifiers"));
+var import_deepSearchParamsIdentifier = __toESM(require("./deepSearchParamsIdentifier"));
+function collectHoldingIds(node) {
+  const { holdingIds, holdingIdNameMap } = node._util;
+  if (import_SHARED_CONSTANTS.FUNCTION_TYPES.includes(node.type)) {
+    const { params, id } = node;
+    if (Array.isArray(params) && params.length > 0) {
+      params.forEach((param) => (0, import_deepSearchParamsIdentifier.default)(param, (id2) => {
+        holdingIds.add(id2 || node);
+        id2._util.variableScope = [id2];
+        id2._util.holdingIdType = "Param";
+      }));
+    }
+    if (node.body && node.body.type === "BlockStatement") {
+      node.body._util.holdingIds.forEach((id2) => {
+        holdingIds.add(id2);
+      });
+    }
+  }
+  (0, import_collectImportDeclarationIdentifiers.default)(node, (id) => {
+    holdingIds.add(id);
+    id._util.variableScope = [id];
+    id._util.holdingIdType = "Import";
+  });
+  if (["BlockStatement", "Program"].includes(node.type)) {
+    const body = node.body;
+    Array.isArray(body) && body.forEach((bodyChild) => {
+      (0, import_collectVariableDeclarationIdentifiers.default)(bodyChild, (id) => {
+        holdingIds.add(id);
+        id._util.variableScope = [id];
+        id._util.holdingIdType = "Variable";
+      });
+      if (import_SHARED_CONSTANTS.EXPORT_DECLARATION_TYPES.includes(bodyChild.type)) {
+        (0, import_collectDeclarationIdentifiers.default)(bodyChild, (id) => {
+          var _a, _b;
+          holdingIds.add(id);
+          (_b = (_a = id._util.parent) == null ? void 0 : _a._util.holdingIds) == null ? void 0 : _b.add(id);
+          id._util.variableScope = [id];
+          id._util.holdingIdType = node.type.replace("Declaration", "");
+        });
+      }
+      if (["ExportNamedDeclaration", "ExportDefaultDeclaration"].includes(bodyChild.type)) {
+        const declaration = bodyChild.declaration;
+        if (declaration) {
+          if (declaration.type === "VariableDeclaration") {
+            (0, import_collectVariableDeclarationIdentifiers.default)(declaration, (id) => {
+              holdingIds.add(id);
+              id._util.variableScope = [id];
+              id._util.holdingIdType = "Variable";
+            });
+          } else {
+            (0, import_collectDeclarationIdentifiers.default)(declaration, (id) => {
+              var _a, _b;
+              holdingIds.add(id);
+              (_b = (_a = id._util.parent) == null ? void 0 : _a._util.holdingIds) == null ? void 0 : _b.add(id);
+              id._util.variableScope = [id];
+              id._util.holdingIdType = declaration.type.replace("Declaration", "");
+            });
+          }
+        }
+      }
+    });
+  }
+  ;
+  holdingIds.forEach((holdingId) => {
+    const holdingIdName = holdingId.name;
+    if (typeof holdingIdName !== "string")
+      return;
+    const nodeSetOfIdName = holdingIdNameMap.get(holdingIdName) || /* @__PURE__ */ new Set();
+    nodeSetOfIdName.add(holdingId);
+    holdingIdNameMap.set(holdingIdName, nodeSetOfIdName);
+  });
+}

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

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

package/dist/cjs/util/ast_util/helper/collectImportDeclarationIdentifiers.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/collectImportDeclarationIdentifiers.ts
+var collectImportDeclarationIdentifiers_exports = {};
+__export(collectImportDeclarationIdentifiers_exports, {
+  default: () => collectImportDeclarationIdentifiers
+});
+module.exports = __toCommonJS(collectImportDeclarationIdentifiers_exports);
+function collectImportDeclarationIdentifiers(node, callback) {
+  if (node.type !== "Program")
+    return;
+  const { body } = node;
+  Array.isArray(body) && body.forEach((node2) => {
+    if (node2.type === "ImportDeclaration") {
+      const specifiers = node2.specifiers;
+      for (const specifier of specifiers) {
+        const local = specifier.local;
+        callback(local);
+      }
+    }
+  });
+}

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

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

package/dist/cjs/util/ast_util/helper/collectVariableDeclarationIdentifiers.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/collectVariableDeclarationIdentifiers.ts
+var collectVariableDeclarationIdentifiers_exports = {};
+__export(collectVariableDeclarationIdentifiers_exports, {
+  default: () => collectVariableDeclarationIdentifiers
+});
+module.exports = __toCommonJS(collectVariableDeclarationIdentifiers_exports);
+var import_deepSearchParamsIdentifier = __toESM(require("./deepSearchParamsIdentifier"));
+function collectVariableDeclarationIdentifiers(node, callback) {
+  if (node.type !== "VariableDeclaration")
+    return;
+  const declarations = node.declarations;
+  for (const declaration of declarations) {
+    (0, import_deepSearchParamsIdentifier.default)(declaration.id, callback);
+  }
+}

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

@@ -0,0 +1,40 @@
+import { AstNode } from "../AstUtil";
+export default function createAstNodeExt(ext: Partial<AstNode['_util']>): {
+    startLine: number;
+    endLine: number;
+    startColumn: number;
+    endColumn: number;
+    filePath: string;
+    parent: AstNode | null;
+    parentProperty: string;
+    indexOfProperty: number | null;
+    ancestors: AstNode[];
+    nodeCollection: AstNode[];
+    children: AstNode[];
+    uuid: string;
+    variableScope: AstNode[];
+    dependenceIds: Set<AstNode>;
+    dependenceIdsNoScope: Set<AstNode>;
+    holdingIds: Set<AstNode>;
+    holdingIdNameMap: Map<string, Set<AstNode>>;
+    holdingIdType: "Import" | "Variable" | "Function" | "Class" | "Param" | "Enum" | "Interface" | "TypeAlias" | null;
+    inject: Set<AstNode>;
+    provide: Set<AstNode>;
+    effectIds: Set<AstNode>;
+    occupation: Set<AstNode>;
+    importedMember: {
+        sourcePath: string;
+        members: {
+            importedName: string;
+            localName: string;
+        }[];
+    }[];
+    exportedMember: {
+        sourcePath: string;
+        members: {
+            exportedName: string;
+            localName: string;
+        }[];
+        ExportAllDeclaration: boolean;
+    }[];
+};

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

@@ -0,0 +1,54 @@
+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/createAstNodeExt.ts
+var createAstNodeExt_exports = {};
+__export(createAstNodeExt_exports, {
+  default: () => createAstNodeExt
+});
+module.exports = __toCommonJS(createAstNodeExt_exports);
+function createAstNodeExt(ext) {
+  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: []
+  };
+  Object.assign(_util, ext);
+  return _util;
+}

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

@@ -0,0 +1,9 @@
+import { AstNode } from "../AstUtil";
+export default function deepFirstTravel(node: AstNode, visitedNodeSet: Set<typeof node>, extra: {
+    filePath: string;
+    depth: number;
+    mapUuidToNode: Map<string, AstNode>;
+    mapFileLineToNodeSet: Map<number, Set<AstNode>>;
+    mapPathToNodeSet: Map<string, Set<AstNode>>;
+    stopTravelCallback?: (node: AstNode) => boolean | void;
+}): AstNode;