js-code-detector 0.0.52 → 0.0.53

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

@@ -0,0 +1,51 @@
+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/getTopScopeNodesByLineNumberRange.ts
+var getTopScopeNodesByLineNumberRange_exports = {};
+__export(getTopScopeNodesByLineNumberRange_exports, {
+  default: () => getTopScopeNodesByLineNumberRange
+});
+module.exports = __toCommonJS(getTopScopeNodesByLineNumberRange_exports);
+function getTopScopeNodesByLineNumberRange(mapFileLineToNodeSet, lineNumberStart, lineNumberEnd, loose = false) {
+  const nodeSet = /* @__PURE__ */ new Set();
+  for (let i = lineNumberStart; i <= lineNumberEnd; i++) {
+    const astNode = mapFileLineToNodeSet.get(i);
+    if (!astNode) {
+      continue;
+    }
+    let added = false;
+    for (const nodeItem of astNode) {
+      const { startLine, endLine } = nodeItem._util;
+      if (startLine >= lineNumberStart && endLine <= lineNumberEnd) {
+        if (!["File", "Program"].includes(nodeItem.type)) {
+          nodeSet.add(nodeItem);
+        }
+        added = true;
+      }
+    }
+    if (!added && loose) {
+      const firstNode = [...astNode][0];
+      if (!["File", "Program"].includes(firstNode.type)) {
+        nodeSet.add(firstNode);
+      }
+    }
+  }
+  const collections = [...nodeSet].map((e) => e._util.nodeCollection).flat();
+  return [...nodeSet].filter((e) => !collections.includes(e));
+}

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

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

package/dist/cjs/util/ast_util/helper/isIdentifierUntracked.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/isIdentifierUntracked.ts
+var isIdentifierUntracked_exports = {};
+__export(isIdentifierUntracked_exports, {
+  default: () => isIdentifierUntracked
+});
+module.exports = __toCommonJS(isIdentifierUntracked_exports);
+var import_windowProperties = require("../windowProperties");
+var import_intrinsicElements = require("../intrinsicElements");
+function isIdentifierUntracked(id) {
+  return id._util.variableScope.length === 0 && !isPropertyOfGlobal(id) && !isIntrinsicElement(id) && !isStandardAttribute(id);
+}
+function isPropertyOfGlobal(node) {
+  return node.type === "Identifier" && !node._util.variableScope.length && typeof node.name === "string" && import_windowProperties.windowProperties.includes(node.name);
+}
+function isIntrinsicElement(node) {
+  var _a;
+  return node.type === "JSXIdentifier" && ((_a = node._util.parent) == null ? void 0 : _a.type) && ["JSXOpeningElement", "JSXClosingElement"].includes(node._util.parent.type) && typeof node.name === "string" && import_intrinsicElements.intrinsicElements.includes(node.name);
+}
+function isStandardAttribute(node) {
+  return node._util.parent.type === "JSXAttribute" && typeof node.name === "string" && import_intrinsicElements.standardAttributes.includes(node.name);
+}

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

@@ -0,0 +1,2 @@
+import { AstNode } from "../AstUtil";
+export default function isValidArrayNodeCollect(astNode: any): astNode is AstNode[];

package/dist/cjs/util/ast_util/helper/isValidArrayNodeCollect.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/isValidArrayNodeCollect.ts
+var isValidArrayNodeCollect_exports = {};
+__export(isValidArrayNodeCollect_exports, {
+  default: () => isValidArrayNodeCollect
+});
+module.exports = __toCommonJS(isValidArrayNodeCollect_exports);
+function isValidArrayNodeCollect(astNode) {
+  return Array.isArray(astNode) && astNode.some((v) => typeof (v == null ? void 0 : v.type) === "string");
+}

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

@@ -0,0 +1,2 @@
+import { AstNode } from "../AstUtil";
+export default function isValidNodeCollect(astNode: AstNode): astNode is AstNode;

package/dist/cjs/util/ast_util/helper/isValidNodeCollect.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/isValidNodeCollect.ts
+var isValidNodeCollect_exports = {};
+__export(isValidNodeCollect_exports, {
+  default: () => isValidNodeCollect
+});
+module.exports = __toCommonJS(isValidNodeCollect_exports);
+function isValidNodeCollect(astNode) {
+  return typeof (astNode == null ? void 0 : astNode.type) === "string";
+}

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

@@ -0,0 +1,11 @@
+import { AstNode } from "../AstUtil";
+type Extra = {
+    visitedNodeSet: Set<AstNode>;
+    filePath: string;
+    mapUuidToNode: Map<string, AstNode>;
+    mapFileLineToNodeSet: Map<number, Set<AstNode>>;
+    mapPathToNodeSet: Map<string, Set<AstNode>>;
+    upstreamIdentifiers: AstNode[];
+};
+export default function syncTravel(astNode: AstNode, extra: Extra, travelFn: (astNode: AstNode) => void): void;
+export {};

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

@@ -0,0 +1,325 @@
+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/syncTravel.ts
+var syncTravel_exports = {};
+__export(syncTravel_exports, {
+  default: () => syncTravel
+});
+module.exports = __toCommonJS(syncTravel_exports);
+var import_SHARED_CONSTANTS = require("../SHARED_CONSTANTS");
+var import_isValidNodeCollect = __toESM(require("./isValidNodeCollect"));
+var import_isValidArrayNodeCollect = __toESM(require("./isValidArrayNodeCollect"));
+var import_createAstNodeExt = __toESM(require("./createAstNodeExt"));
+var import_deepSearchParamsIdentifier = __toESM(require("./deepSearchParamsIdentifier"));
+var import_updateImportedAndExportedMember = __toESM(require("./updateImportedAndExportedMember"));
+var import_updateLoc = __toESM(require("./updateLoc"));
+var import_intrinsicElements = require("../intrinsicElements");
+function syncTravel(astNode, extra, travelFn) {
+  if (!astNode)
+    return;
+  extra.upstreamIdentifiers = extra.upstreamIdentifiers || [];
+  const { visitedNodeSet, filePath } = extra;
+  astNode._util = (0, import_createAstNodeExt.default)({ filePath });
+  visitedNodeSet.add(astNode);
+  if (shouldWideTravel(astNode)) {
+    wideTravel([astNode], extra, travelFn);
+  } else {
+    deepTravel(astNode, extra, travelFn);
+  }
+}
+function wideTravel(wideTravelNodeList, extra, travelFn) {
+  const { visitedNodeSet, filePath } = extra;
+  const wideTravelNodes = [];
+  for (const wideTravelNode of wideTravelNodeList) {
+    if (!shouldWideTravel(wideTravelNode)) {
+      deepTravel(wideTravelNode, extra, travelFn);
+      continue;
+    }
+    const { children: childrenOfChild } = wideTravelNode._util;
+    Object.keys(wideTravelNode).forEach((childKey) => {
+      if (import_SHARED_CONSTANTS.INVALID_NODE_KEY.includes(childKey))
+        return;
+      const childValue = wideTravelNode[childKey];
+      if ((0, import_isValidNodeCollect.default)(childValue) && !visitedNodeSet.has(childValue)) {
+        visitedNodeSet.add(childValue);
+        childValue._util = (0, import_createAstNodeExt.default)({
+          filePath,
+          parent: wideTravelNode,
+          parentProperty: childKey,
+          indexOfProperty: null,
+          ancestors: [...wideTravelNode._util.ancestors, wideTravelNode]
+        });
+        childrenOfChild.push(childValue);
+        wideTravelNodes.push(childValue);
+      } else if ((0, import_isValidArrayNodeCollect.default)(childValue)) {
+        childValue.forEach((childInArray, index) => {
+          if (visitedNodeSet.has(childInArray) || !(0, import_isValidNodeCollect.default)(childInArray))
+            return;
+          visitedNodeSet.add(childInArray);
+          childInArray._util = (0, import_createAstNodeExt.default)({
+            filePath,
+            parent: wideTravelNode,
+            parentProperty: childKey,
+            indexOfProperty: index,
+            ancestors: [...wideTravelNode._util.ancestors, wideTravelNode]
+          });
+          childrenOfChild.push(childInArray);
+          wideTravelNodes.push(childInArray);
+        });
+      }
+    });
+  }
+  const { hoistedNodeList, exportDeclarations, notHoistedNodes } = resortNodes(wideTravelNodes);
+  const holdingIdentifiers = [...extra.upstreamIdentifiers];
+  for (const ele of [...hoistedNodeList, ...exportDeclarations]) {
+    collectHoldingIdentifiers(ele, holdingIdentifiers, exportDeclarations);
+  }
+  for (const ele of wideTravelNodes) {
+    if (notHoistedNodes.includes(ele)) {
+      collectHoldingIdentifiers(ele, holdingIdentifiers, exportDeclarations);
+    }
+    const mergedExtra = { ...extra, upstreamIdentifiers: [...holdingIdentifiers] };
+    const holdingIdentifierSet = new Set(holdingIdentifiers);
+    ele._util.holdingIds = holdingIdentifierSet;
+    if (shouldWideTravel(ele)) {
+      wideTravel([ele], mergedExtra, travelFn);
+    } else {
+      deepTravel(ele, mergedExtra, travelFn);
+    }
+    if (!ele._util.uuid) {
+      (0, import_updateLoc.default)(ele, extra);
+    }
+    if (ele.type === "Program") {
+      console.log("需要处理兜底 Programs");
+    }
+    addIdentifiersToAncestors([ele], ele._util.ancestors);
+  }
+}
+function deepTravel(deepTravelNode, extra, travelFn) {
+  const { upstreamIdentifiers } = extra;
+  const holdingIdentifiers = [...upstreamIdentifiers];
+  collectParamsIdentifier(deepTravelNode, holdingIdentifiers);
+  updateVariableScopeAndOccupation(deepTravelNode, holdingIdentifiers);
+  const { visitedNodeSet, filePath } = extra;
+  const { children } = deepTravelNode._util;
+  const ancestors = [...deepTravelNode._util.ancestors, deepTravelNode];
+  Object.keys(deepTravelNode).forEach((childKey) => {
+    if (import_SHARED_CONSTANTS.INVALID_NODE_KEY.includes(childKey))
+      return;
+    const commonNodeExt = {
+      parentProperty: childKey,
+      filePath,
+      parent: deepTravelNode,
+      ancestors
+    };
+    const childValue = deepTravelNode[childKey];
+    if ((0, import_isValidNodeCollect.default)(childValue) && !visitedNodeSet.has(childValue)) {
+      visitedNodeSet.add(childValue);
+      childValue._util = (0, import_createAstNodeExt.default)({
+        indexOfProperty: null,
+        ...commonNodeExt
+      });
+      children.push(childValue);
+    } else if ((0, import_isValidArrayNodeCollect.default)(childValue)) {
+      childValue.forEach((childInArray, index) => {
+        if (visitedNodeSet.has(childInArray) || !(0, import_isValidNodeCollect.default)(childInArray))
+          return;
+        visitedNodeSet.add(childInArray);
+        childInArray._util = (0, import_createAstNodeExt.default)({
+          indexOfProperty: index,
+          ...commonNodeExt
+        });
+        children.push(childInArray);
+      });
+    }
+  });
+  const mergedExtra = { ...extra, upstreamIdentifiers: holdingIdentifiers };
+  travelFn(deepTravelNode);
+  for (const child of children) {
+    if (shouldWideTravel(child)) {
+      wideTravel([child], mergedExtra, travelFn);
+    } else {
+      deepTravel(child, mergedExtra, travelFn);
+    }
+    if (child.type === "Program") {
+      child.body.forEach((bodyElement) => (0, import_updateImportedAndExportedMember.default)(bodyElement, child));
+    }
+    if (!child._util.uuid) {
+      (0, import_updateLoc.default)(child, extra);
+    }
+    addIdentifiersToAncestors([child], ancestors);
+  }
+}
+function resortNodes(nodes) {
+  var _a, _b;
+  const hoistedNodeList = [];
+  const exportDeclarations = [];
+  for (const astNode of nodes) {
+    if (["ImportDeclaration", "FunctionDeclaration", "TSEnumDeclaration", "TSInterfaceDeclaration", "TSTypeAliasDeclaration"].includes(astNode.type)) {
+      hoistedNodeList.push(astNode);
+    }
+    if (["ExportNamedDeclaration", "ExportDefaultDeclaration"].includes(astNode.type)) {
+      const decType = (_a = astNode.declaration) == null ? void 0 : _a.type;
+      const decId = (_b = astNode.declaration) == null ? void 0 : _b.id;
+      if (["FunctionDeclaration", "TSEnumDeclaration", "TSInterfaceDeclaration", "TSTypeAliasDeclaration"].includes(decType) && decId) {
+        exportDeclarations.push(astNode);
+      }
+    }
+  }
+  const notHoistedNodes = nodes.filter((node) => ![...hoistedNodeList, ...exportDeclarations].includes(node));
+  return {
+    hoistedNodeList,
+    exportDeclarations,
+    notHoistedNodes
+  };
+}
+function shouldWideTravel(astNode) {
+  return ["BlockStatement", "Program"].includes(astNode.type);
+}
+function updateHoldingIdMap(holdingIdentifiers, holdingIdNameMap) {
+  [...holdingIdentifiers].reverse().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);
+  });
+}
+function collectParamsIdentifier(deepTravelNode, holdingIdentifiers) {
+  if (import_SHARED_CONSTANTS.FUNCTION_TYPES.includes(deepTravelNode.type)) {
+    const params = deepTravelNode.params;
+    Array.isArray(params) && params.forEach((param) => {
+      (0, import_deepSearchParamsIdentifier.default)(param, (identifier) => {
+        holdingIdentifiers.push(identifier);
+      });
+    });
+  }
+}
+function collectHoldingIdentifiers(ele, holdingIdentifiers, exportDeclarations) {
+  var _a, _b, _c;
+  if (ele.type === "ImportDeclaration") {
+    const specifiers = ele.specifiers;
+    for (const specifier of specifiers) {
+      holdingIdentifiers.push(specifier.local);
+    }
+  }
+  if (import_SHARED_CONSTANTS.EXPORT_DECLARATION_TYPES.includes(ele.type)) {
+    const id = ele.id;
+    if (id) {
+      holdingIdentifiers.push(id);
+    }
+  }
+  if (import_SHARED_CONSTANTS.EXPORT_DECLARATION_TYPES.includes((_a = ele.declaration) == null ? void 0 : _a.type)) {
+    const id = (_b = ele.declaration) == null ? void 0 : _b.id;
+    if (id) {
+      holdingIdentifiers.push(id);
+    }
+  }
+  if (exportDeclarations.includes(ele)) {
+    const id = (_c = ele == null ? void 0 : ele.declaration) == null ? void 0 : _c.id;
+    if (id) {
+      holdingIdentifiers.push(id);
+    }
+  }
+  if (ele.type === "VariableDeclaration") {
+    Array.from(new Set(ele.declarations)).forEach((declaration) => {
+      const id = declaration.id;
+      if (id) {
+        (0, import_deepSearchParamsIdentifier.default)(id, (identifier) => holdingIdentifiers.push(identifier));
+      }
+    });
+  }
+  if (ele.declaration && ele.declaration.type === "VariableDeclaration") {
+    Array.from(new Set(ele.declaration.declarations)).forEach((declaration) => {
+      const id = declaration.id;
+      if (id) {
+        (0, import_deepSearchParamsIdentifier.default)(id, (identifier) => holdingIdentifiers.push(identifier));
+      }
+    });
+  }
+}
+function isValidIdentifierOrJSXIdentifier(node) {
+  if (node.type === "Identifier" && !isImportedOrExported(node) && !isLiteralPropertyNode(node)) {
+    return true;
+  } else if (node.type === "JSXIdentifier" && isJsxElementIdentifier(node)) {
+    if (isJsxElementNameIdentifier(node)) {
+      return !import_intrinsicElements.intrinsicElements.includes(node.name);
+    }
+    return true;
+  }
+  return false;
+}
+function updateVariableScopeAndOccupation(deepTravelNode, holdingIdentifiers) {
+  var _a;
+  const holdingIdentifierSet = new Set(holdingIdentifiers);
+  deepTravelNode._util.holdingIds = holdingIdentifierSet;
+  updateHoldingIdMap(holdingIdentifiers, deepTravelNode._util.holdingIdNameMap);
+  const nodeName = deepTravelNode.name;
+  if (typeof nodeName !== "string") {
+    return;
+  }
+  const valid = isValidIdentifierOrJSXIdentifier(deepTravelNode);
+  if (!valid) {
+    return;
+  }
+  !holdingIdentifierSet.has(deepTravelNode) && deepTravelNode._util.ancestors.forEach((ancestor) => {
+    ancestor._util.dependenceIds.add(deepTravelNode);
+  });
+  deepTravelNode._util.variableScope = [...deepTravelNode._util.holdingIdNameMap.get(nodeName) || []];
+  const firstPick = deepTravelNode._util.variableScope[0];
+  if (firstPick && firstPick !== deepTravelNode) {
+    if (firstPick._util) {
+      firstPick._util.occupation.add(deepTravelNode);
+    } else {
+      console.log(deepTravelNode._util.filePath, (_a = deepTravelNode.loc) == null ? void 0 : _a.start.line, deepTravelNode.type, deepTravelNode.name);
+    }
+  }
+}
+function isLiteralPropertyNode(exp) {
+  var _a;
+  return (exp._util.parentProperty === "property" || exp._util.parentProperty === "key") && !((_a = exp._util.parent) == null ? void 0 : _a.computed);
+}
+function isJsxElementNameIdentifier(deepTravelNode) {
+  return deepTravelNode._util.parentProperty === "name" && typeof deepTravelNode.name === "string";
+}
+function isJsxElementIdentifier(deepTravelNode) {
+  var _a;
+  return ((_a = deepTravelNode._util.parent) == null ? void 0 : _a.type) !== "JSXAttribute" || isJsxElementNameIdentifier(deepTravelNode);
+}
+function isImportedOrExported(deepTravelNode) {
+  return deepTravelNode._util.parentProperty === "imported" || deepTravelNode._util.parentProperty === "exported";
+}
+function addIdentifiersToAncestors(children, ancestors) {
+  for (const child of children) {
+    ancestors.forEach((ancestor) => {
+      !ancestor._util.nodeCollection.includes(child) && ancestor._util.nodeCollection.push(child);
+    });
+  }
+}

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

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

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

@@ -0,0 +1,135 @@
+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/updateImportedAndExportedMember.ts
+var updateImportedAndExportedMember_exports = {};
+__export(updateImportedAndExportedMember_exports, {
+  default: () => updateImportedAndExportedMember
+});
+module.exports = __toCommonJS(updateImportedAndExportedMember_exports);
+var import_SHARED_CONSTANTS = require("../SHARED_CONSTANTS");
+var import_findOrCreateExportedMember = __toESM(require("./findOrCreateExportedMember"));
+var import_findOrCreateImportedMember = __toESM(require("./findOrCreateImportedMember"));
+var import_collectVariableDeclarationIdentifiers = __toESM(require("./collectVariableDeclarationIdentifiers"));
+function updateImportedAndExportedMember(node, programNode) {
+  var _a;
+  const { type, source, declaration, specifiers, _util } = node;
+  const { filePath } = _util;
+  const sourceValue = (source == null ? void 0 : source.value) || filePath;
+  const { importedMember, exportedMember } = programNode._util;
+  if (type === "ImportDeclaration") {
+    specifiers.forEach((specifier) => {
+      const { local, imported } = specifier;
+      const target = (0, import_findOrCreateImportedMember.default)(importedMember, sourceValue);
+      if (specifier.type === "ImportNamespaceSpecifier") {
+        target.members.push({
+          localName: local.name,
+          importedName: "*"
+        });
+        return;
+      }
+      if (specifier.type === "ImportDefaultSpecifier") {
+        target.members.push({
+          localName: local.name,
+          importedName: "default"
+        });
+        return;
+      }
+      if (specifier.type === "ImportSpecifier") {
+        target.members.push({
+          localName: local.name,
+          importedName: imported.name
+        });
+      }
+    });
+  }
+  if (type === "ExportAllDeclaration") {
+    const target = exportedMember.find((v) => v.sourcePath === sourceValue);
+    if (!target) {
+      exportedMember.push({ sourcePath: sourceValue, members: [], ExportAllDeclaration: true });
+    }
+  }
+  if (type === "ExportNamedDeclaration") {
+    Array.isArray(specifiers) && specifiers.forEach((specifier) => {
+      const { local, exported } = specifier;
+      const target = (0, import_findOrCreateExportedMember.default)(exportedMember, sourceValue);
+      if (specifier.type === "ExportNamespaceSpecifier") {
+        target.members.push({
+          localName: "*",
+          exportedName: exported.name
+        });
+        return;
+      }
+      if (specifier.type === "ExportSpecifier") {
+        target.members.push({
+          localName: local.name,
+          exportedName: exported.name
+        });
+        return;
+      }
+    });
+    if (Array.isArray(declaration == null ? void 0 : declaration.declarations)) {
+      declaration == null ? void 0 : declaration.declarations.forEach((dec) => {
+        const target = (0, import_findOrCreateExportedMember.default)(exportedMember, sourceValue);
+        (0, import_collectVariableDeclarationIdentifiers.default)(dec, (identifier) => {
+          try {
+            const idName = identifier.name;
+            target.members.push({
+              localName: idName,
+              exportedName: idName
+            });
+          } catch (e) {
+            console.log("declaration?.declarations.forEach", e.message);
+          }
+        });
+      });
+    } else if (import_SHARED_CONSTANTS.EXPORT_DECLARATION_TYPES.includes(declaration == null ? void 0 : declaration.type)) {
+      const target = (0, import_findOrCreateExportedMember.default)(exportedMember, sourceValue);
+      try {
+        const idName = (_a = declaration.id) == null ? void 0 : _a.name;
+        target.members.push({
+          localName: idName,
+          exportedName: idName
+        });
+      } catch (e) {
+        console.log("declaration " + e.message);
+      }
+    }
+  }
+  if (type === "ExportDefaultDeclaration") {
+    let target = exportedMember.find((v) => v.sourcePath === filePath);
+    if (!target) {
+      target = { sourcePath: filePath, members: [], ExportAllDeclaration: false };
+      exportedMember.push(target);
+    }
+    target.members.push({
+      localName: "default",
+      exportedName: "default"
+    });
+  }
+}

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

@@ -0,0 +1,6 @@
+import { AstNode } from "../AstUtil";
+export default function updateLoc(astNode: AstNode, extra: {
+    mapUuidToNode: Map<string, AstNode>;
+    mapFileLineToNodeSet: Map<number, Set<AstNode>>;
+    mapPathToNodeSet: Map<string, Set<AstNode>>;
+}): void;