@babel/traverse 7.18.2 → 7.18.8

package/lib/context.js

@@ -31,17 +31,19 @@ class TraversalContext {
     if (!(keys != null && keys.length)) return false;
 
     for (const key of keys) {
-      if (node[key]) return true;
+      if (node[key]) {
+        return true;
+      }
     }
 
     return false;
   }
 
-  create(node, obj, key, listKey) {
+  create(node, container, key, listKey) {
     return _path.default.get({
       parentPath: this.parentPath,
       parent: node,
-      container: obj,
+      container,
       key: key,
       listKey
     });

package/lib/path/context.js

@@ -181,7 +181,10 @@ function _resyncParent() {
 
 function _resyncKey() {
   if (!this.container) return;
-  if (this.node === this.container[this.key]) return;
+
+  if (this.node === this.container[this.key]) {
+    return;
+  }
 
   if (Array.isArray(this.container)) {
     for (let i = 0; i < this.container.length; i++) {

package/lib/path/conversion.js

@@ -251,10 +251,11 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
     const flatSuperProps = superProps.reduce((acc, superProp) => acc.concat(standardizeSuperProperty(superProp)), []);
     flatSuperProps.forEach(superProp => {
       const key = superProp.node.computed ? "" : superProp.get("property").node.name;
-      const isAssignment = superProp.parentPath.isAssignmentExpression({
+      const superParentPath = superProp.parentPath;
+      const isAssignment = superParentPath.isAssignmentExpression({
         left: superProp.node
       });
-      const isCall = superProp.parentPath.isCallExpression({
+      const isCall = superParentPath.isCallExpression({
         callee: superProp.node
       });
       const superBinding = getSuperPropBinding(thisEnvFn, isAssignment, key);
@@ -265,18 +266,18 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
       }
 
       if (isAssignment) {
-        const value = superProp.parentPath.node.right;
+        const value = superParentPath.node.right;
         args.push(value);
       }
 
       const call = callExpression(identifier(superBinding), args);
 
       if (isCall) {
-        superProp.parentPath.unshiftContainer("arguments", thisExpression());
+        superParentPath.unshiftContainer("arguments", thisExpression());
         superProp.replaceWith(memberExpression(call, identifier("call")));
-        thisPaths.push(superProp.parentPath.get("arguments.0"));
+        thisPaths.push(superParentPath.get("arguments.0"));
       } else if (isAssignment) {
-        superProp.parentPath.replaceWith(call);
+        superParentPath.replaceWith(call);
       } else {
         superProp.replaceWith(call);
       }

package/lib/path/evaluation.js

@@ -8,6 +8,14 @@ exports.evaluateTruthy = evaluateTruthy;
 const VALID_CALLEES = ["String", "Number", "Math"];
 const INVALID_METHODS = ["random"];
 
+function isValidCallee(val) {
+  return VALID_CALLEES.includes(val);
+}
+
+function isInvalidMethod(val) {
+  return INVALID_METHODS.includes(val);
+}
+
 function evaluateTruthy() {
   const res = this.evaluate();
   if (res.confident) return !!res.value;
@@ -336,7 +344,7 @@ function _evaluate(path, state) {
     let context;
     let func;
 
-    if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && VALID_CALLEES.indexOf(callee.node.name) >= 0) {
+    if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && isValidCallee(callee.node.name)) {
       func = global[callee.node.name];
     }
 
@@ -344,7 +352,7 @@ function _evaluate(path, state) {
       const object = callee.get("object");
       const property = callee.get("property");
 
-      if (object.isIdentifier() && property.isIdentifier() && VALID_CALLEES.indexOf(object.node.name) >= 0 && INVALID_METHODS.indexOf(property.node.name) < 0) {
+      if (object.isIdentifier() && property.isIdentifier() && isValidCallee(object.node.name) && !isInvalidMethod(property.node.name)) {
         context = global[object.node.name];
         func = context[property.node.name];
       }

package/lib/path/index.js

@@ -227,6 +227,9 @@ class NodePath {
 }
 
 Object.assign(NodePath.prototype, NodePath_ancestry, NodePath_inference, NodePath_replacement, NodePath_evaluation, NodePath_conversion, NodePath_introspection, NodePath_context, NodePath_removal, NodePath_modification, NodePath_family, NodePath_comments);
+{
+  NodePath.prototype._guessExecutionStatusRelativeToDifferentFunctions = NodePath_introspection._guessExecutionStatusRelativeTo;
+}
 
 for (const type of t.TYPES) {
   const typeKey = `is${type}`;

package/lib/path/inference/index.js

@@ -17,6 +17,7 @@ var _t = require("@babel/types");
 const {
   anyTypeAnnotation,
   isAnyTypeAnnotation,
+  isArrayTypeAnnotation,
   isBooleanTypeAnnotation,
   isEmptyTypeAnnotation,
   isFlowBaseAnnotation,
@@ -25,6 +26,10 @@ const {
   isMixedTypeAnnotation,
   isNumberTypeAnnotation,
   isStringTypeAnnotation,
+  isTSArrayType,
+  isTSTypeAnnotation,
+  isTSTypeReference,
+  isTupleTypeAnnotation,
   isTypeAnnotation,
   isUnionTypeAnnotation,
   isVoidTypeAnnotation,
@@ -40,7 +45,11 @@ function getTypeAnnotation() {
   }
 
   type = this._getTypeAnnotation() || anyTypeAnnotation();
-  if (isTypeAnnotation(type)) type = type.typeAnnotation;
+
+  if (isTypeAnnotation(type) || isTSTypeAnnotation(type)) {
+    type = type.typeAnnotation;
+  }
+
   this.setData("typeAnnotation", type);
   return type;
 }
@@ -156,7 +165,16 @@ function baseTypeStrictlyMatches(rightArg) {
 
 function isGenericType(genericName) {
   const type = this.getTypeAnnotation();
+
+  if (genericName === "Array") {
+    if (isTSArrayType(type) || isArrayTypeAnnotation(type) || isTupleTypeAnnotation(type)) {
+      return true;
+    }
+  }
+
   return isGenericTypeAnnotation(type) && isIdentifier(type.id, {
     name: genericName
+  }) || isTSTypeReference(type) && isIdentifier(type.typeName, {
+    name: genericName
   });
 }

package/lib/path/inference/inferer-reference.js

@@ -7,13 +7,11 @@ exports.default = _default;
 
 var _t = require("@babel/types");
 
+var _util = require("./util");
+
 const {
   BOOLEAN_NUMBER_BINARY_OPERATORS,
-  createFlowUnionType,
-  createTSUnionType,
   createTypeAnnotationBasedOnTypeof,
-  createUnionTypeAnnotation,
-  isTSTypeAnnotation,
   numberTypeAnnotation,
   voidTypeAnnotation
 } = _t;
@@ -61,15 +59,7 @@ function getTypeAnnotationBindingConstantViolations(binding, path, name) {
     return;
   }
 
-  if (isTSTypeAnnotation(types[0]) && createTSUnionType) {
-    return createTSUnionType(types);
-  }
-
-  if (createFlowUnionType) {
-    return createFlowUnionType(types);
-  }
-
-  return createUnionTypeAnnotation(types);
+  return (0, _util.createUnionType)(types);
 }
 
 function getConstantViolationsBefore(binding, path, functions) {
@@ -182,25 +172,11 @@ function getConditionalAnnotation(binding, path, name) {
   }
 
   if (types.length) {
-    if (isTSTypeAnnotation(types[0]) && createTSUnionType) {
-      return {
-        typeAnnotation: createTSUnionType(types),
-        ifStatement
-      };
-    }
-
-    if (createFlowUnionType) {
-      return {
-        typeAnnotation: createFlowUnionType(types),
-        ifStatement
-      };
-    }
-
     return {
-      typeAnnotation: createUnionTypeAnnotation(types),
+      typeAnnotation: (0, _util.createUnionType)(types),
       ifStatement
     };
   }
 
-  return getConditionalAnnotation(ifStatement, name);
+  return getConditionalAnnotation(binding, ifStatement, name);
 }

package/lib/path/inference/inferers.js

@@ -26,6 +26,8 @@ exports.RegExpLiteral = RegExpLiteral;
 exports.RestElement = RestElement;
 exports.SequenceExpression = SequenceExpression;
 exports.StringLiteral = StringLiteral;
+exports.TSAsExpression = TSAsExpression;
+exports.TSNonNullExpression = TSNonNullExpression;
 exports.TaggedTemplateExpression = TaggedTemplateExpression;
 exports.TemplateLiteral = TemplateLiteral;
 exports.TypeCastExpression = TypeCastExpression;
@@ -37,6 +39,8 @@ var _t = require("@babel/types");
 
 var _infererReference = require("./inferer-reference");
 
+var _util = require("./util");
+
 const {
   BOOLEAN_BINARY_OPERATORS,
   BOOLEAN_UNARY_OPERATORS,
@@ -47,37 +51,20 @@ const {
   arrayTypeAnnotation,
   booleanTypeAnnotation,
   buildMatchMemberExpression,
-  createFlowUnionType,
-  createTSUnionType,
-  createUnionTypeAnnotation,
   genericTypeAnnotation,
   identifier,
-  isTSTypeAnnotation,
   nullLiteralTypeAnnotation,
   numberTypeAnnotation,
   stringTypeAnnotation,
   tupleTypeAnnotation,
   unionTypeAnnotation,
-  voidTypeAnnotation
+  voidTypeAnnotation,
+  isIdentifier
 } = _t;
 
 function VariableDeclarator() {
-  var _type;
-
-  const id = this.get("id");
-  if (!id.isIdentifier()) return;
-  const init = this.get("init");
-  let type = init.getTypeAnnotation();
-
-  if (((_type = type) == null ? void 0 : _type.type) === "AnyTypeAnnotation") {
-    if (init.isCallExpression() && init.get("callee").isIdentifier({
-      name: "Array"
-    }) && !init.scope.hasBinding("Array", true)) {
-      type = ArrayExpression();
-    }
-  }
-
-  return type;
+  if (!this.get("id").isIdentifier()) return;
+  return this.get("init").getTypeAnnotation();
 }
 
 function TypeCastExpression(node) {
@@ -86,8 +73,18 @@ function TypeCastExpression(node) {
 
 TypeCastExpression.validParent = true;
 
+function TSAsExpression(node) {
+  return node.typeAnnotation;
+}
+
+TSAsExpression.validParent = true;
+
+function TSNonNullExpression() {
+  return this.get("expression").getTypeAnnotation();
+}
+
 function NewExpression(node) {
-  if (this.get("callee").isIdentifier()) {
+  if (node.callee.type === "Identifier") {
     return genericTypeAnnotation(node.callee);
   }
 }
@@ -133,30 +130,12 @@ function BinaryExpression(node) {
 
 function LogicalExpression() {
   const argumentTypes = [this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()];
-
-  if (isTSTypeAnnotation(argumentTypes[0]) && createTSUnionType) {
-    return createTSUnionType(argumentTypes);
-  }
-
-  if (createFlowUnionType) {
-    return createFlowUnionType(argumentTypes);
-  }
-
-  return createUnionTypeAnnotation(argumentTypes);
+  return (0, _util.createUnionType)(argumentTypes);
 }
 
 function ConditionalExpression() {
   const argumentTypes = [this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()];
-
-  if (isTSTypeAnnotation(argumentTypes[0]) && createTSUnionType) {
-    return createTSUnionType(argumentTypes);
-  }
-
-  if (createFlowUnionType) {
-    return createFlowUnionType(argumentTypes);
-  }
-
-  return createUnionTypeAnnotation(argumentTypes);
+  return (0, _util.createUnionType)(argumentTypes);
 }
 
 function SequenceExpression() {
@@ -229,7 +208,9 @@ function CallExpression() {
 
   if (isObjectKeys(callee)) {
     return arrayTypeAnnotation(stringTypeAnnotation());
-  } else if (isArrayFrom(callee) || isObjectValues(callee)) {
+  } else if (isArrayFrom(callee) || isObjectValues(callee) || isIdentifier(callee, {
+    name: "Array"
+  })) {
     return arrayTypeAnnotation(anyTypeAnnotation());
   } else if (isObjectEntries(callee)) {
     return arrayTypeAnnotation(tupleTypeAnnotation([stringTypeAnnotation(), anyTypeAnnotation()]));
@@ -246,14 +227,20 @@ function resolveCall(callee) {
   callee = callee.resolve();
 
   if (callee.isFunction()) {
-    if (callee.is("async")) {
-      if (callee.is("generator")) {
+    const {
+      node
+    } = callee;
+
+    if (node.async) {
+      if (node.generator) {
         return genericTypeAnnotation(identifier("AsyncIterator"));
       } else {
         return genericTypeAnnotation(identifier("Promise"));
       }
     } else {
-      if (callee.node.returnType) {
+      if (node.generator) {
+        return genericTypeAnnotation(identifier("Iterator"));
+      } else if (callee.node.returnType) {
         return callee.node.returnType;
       } else {}
     }

package/lib/path/inference/util.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createUnionType = createUnionType;
+
+var _t = require("@babel/types");
+
+const {
+  createFlowUnionType,
+  createTSUnionType,
+  createUnionTypeAnnotation,
+  isFlowType,
+  isTSType
+} = _t;
+
+function createUnionType(types) {
+  {
+    if (isFlowType(types[0])) {
+      if (createFlowUnionType) {
+        return createFlowUnionType(types);
+      }
+
+      return createUnionTypeAnnotation(types);
+    } else {
+      if (createTSUnionType) {
+        return createTSUnionType(types);
+      }
+    }
+  }
+}

package/lib/path/introspection.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports._guessExecutionStatusRelativeTo = _guessExecutionStatusRelativeTo;
-exports._guessExecutionStatusRelativeToDifferentFunctions = _guessExecutionStatusRelativeToDifferentFunctions;
 exports._resolve = _resolve;
 exports.canHaveVariableDeclarationOrExpression = canHaveVariableDeclarationOrExpression;
 exports.canSwapBetweenExpressionAndStatement = canSwapBetweenExpressionAndStatement;
@@ -232,20 +231,24 @@ function isExecutionUncertainInList(paths, maxIndex) {
 }
 
 function _guessExecutionStatusRelativeTo(target) {
+  return _guessExecutionStatusRelativeToCached(this, target, new Map());
+}
+
+function _guessExecutionStatusRelativeToCached(base, target, cache) {
   const funcParent = {
-    this: getOuterFunction(this),
+    this: getOuterFunction(base),
     target: getOuterFunction(target)
   };
 
   if (funcParent.target.node !== funcParent.this.node) {
-    return this._guessExecutionStatusRelativeToDifferentFunctions(funcParent.target);
+    return _guessExecutionStatusRelativeToDifferentFunctionsCached(base, funcParent.target, cache);
   }
 
   const paths = {
     target: target.getAncestry(),
-    this: this.getAncestry()
+    this: base.getAncestry()
   };
-  if (paths.target.indexOf(this) >= 0) return "after";
+  if (paths.target.indexOf(base) >= 0) return "after";
   if (paths.this.indexOf(target) >= 0) return "before";
   let commonPath;
   const commonIndex = {
@@ -289,9 +292,9 @@ function _guessExecutionStatusRelativeTo(target) {
   return keyPosition.target > keyPosition.this ? "before" : "after";
 }
 
-const executionOrderCheckedNodes = new WeakSet();
+const executionOrderCheckedNodes = new Set();
 
-function _guessExecutionStatusRelativeToDifferentFunctions(target) {
+function _guessExecutionStatusRelativeToDifferentFunctionsInternal(base, target, cache) {
   if (!target.isFunctionDeclaration() || target.parentPath.isExportDeclaration()) {
     return "unknown";
   }
@@ -312,20 +315,37 @@ function _guessExecutionStatusRelativeToDifferentFunctions(target) {
     if (executionOrderCheckedNodes.has(path.node)) continue;
     executionOrderCheckedNodes.add(path.node);
 
-    const status = this._guessExecutionStatusRelativeTo(path);
-
-    executionOrderCheckedNodes.delete(path.node);
+    try {
+      const status = _guessExecutionStatusRelativeToCached(base, path, cache);
 
-    if (allStatus && allStatus !== status) {
-      return "unknown";
-    } else {
-      allStatus = status;
+      if (allStatus && allStatus !== status) {
+        return "unknown";
+      } else {
+        allStatus = status;
+      }
+    } finally {
+      executionOrderCheckedNodes.delete(path.node);
     }
   }
 
   return allStatus;
 }
 
+function _guessExecutionStatusRelativeToDifferentFunctionsCached(base, target, cache) {
+  let nodeMap = cache.get(base.node);
+
+  if (!nodeMap) {
+    cache.set(base.node, nodeMap = new Map());
+  } else if (nodeMap.has(target.node)) {
+    return nodeMap.get(target.node);
+  }
+
+  const result = _guessExecutionStatusRelativeToDifferentFunctionsInternal(base, target, cache);
+
+  nodeMap.set(target.node, result);
+  return result;
+}
+
 function resolve(dangerous, resolved) {
   return this._resolve(dangerous, resolved) || this;
 }

package/lib/path/lib/removal-hooks.js

@@ -4,6 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.hooks = void 0;
+
+var _ = require("..");
+
 const hooks = [function (self, parent) {
   const removeParent = self.key === "test" && (parent.isWhile() || parent.isSwitchCase()) || self.key === "declaration" && parent.isExportDeclaration() || self.key === "body" && parent.isLabeledStatement() || self.listKey === "declarations" && parent.isVariableDeclaration() && parent.node.declarations.length === 1 || self.key === "expression" && parent.isExpressionStatement();
 

package/lib/path/replacement.js

@@ -69,10 +69,11 @@ function replaceWithMultiple(nodes) {
 
 function replaceWithSourceString(replacement) {
   this.resync();
+  let ast;
 
   try {
     replacement = `(${replacement})`;
-    replacement = (0, _parser.parse)(replacement);
+    ast = (0, _parser.parse)(replacement);
   } catch (err) {
     const loc = err.loc;
 
@@ -89,23 +90,21 @@ function replaceWithSourceString(replacement) {
     throw err;
   }
 
-  replacement = replacement.program.body[0].expression;
+  const expressionAST = ast.program.body[0].expression;
 
-  _index.default.removeProperties(replacement);
+  _index.default.removeProperties(expressionAST);
 
-  return this.replaceWith(replacement);
+  return this.replaceWith(expressionAST);
 }
 
-function replaceWith(replacement) {
+function replaceWith(replacementPath) {
   this.resync();
 
   if (this.removed) {
     throw new Error("You can't replace this node, we've already removed it");
   }
 
-  if (replacement instanceof _index2.default) {
-    replacement = replacement.node;
-  }
+  let replacement = replacementPath instanceof _index2.default ? replacementPath.node : replacementPath;
 
   if (!replacement) {
     throw new Error("You passed `path.replaceWith()` a falsy node, use `path.remove()` instead");

package/lib/scope/index.js

@@ -38,9 +38,11 @@ const {
   isMethod,
   isModuleDeclaration,
   isModuleSpecifier,
+  isNullLiteral,
   isObjectExpression,
   isProperty,
   isPureish,
+  isRegExpLiteral,
   isSuper,
   isTaggedTemplateExpression,
   isTemplateLiteral,
@@ -75,7 +77,7 @@ function gatherNodeParts(node, parts) {
         }
       } else if (isModuleSpecifier(node)) {
         gatherNodeParts(node.local, parts);
-      } else if (isLiteral(node)) {
+      } else if (isLiteral(node) && !isNullLiteral(node) && !isRegExpLiteral(node) && !isTemplateLiteral(node)) {
         parts.push(node.value);
       }
 
@@ -185,7 +187,7 @@ function gatherNodeParts(node, parts) {
       break;
 
     case "JSXOpeningElement":
-      parts.push(node.name);
+      gatherNodeParts(node.name, parts);
       break;
 
     case "JSXFragment":

package/lib/scope/lib/renamer.js

@@ -9,17 +9,10 @@ var _binding = require("../binding");
 
 var _helperSplitExportDeclaration = require("@babel/helper-split-export-declaration");
 
-var _t = require("@babel/types");
+var t = require("@babel/types");
 
 var _helperEnvironmentVisitor = require("@babel/helper-environment-visitor");
 
-const {
-  assignmentExpression,
-  identifier,
-  toExpression,
-  variableDeclaration,
-  variableDeclarator
-} = _t;
 const renameVisitor = {
   ReferencedIdentifier({
     node
@@ -64,7 +57,17 @@ class Renamer {
       return;
     }
 
-    if (maybeExportDeclar.isExportDefaultDeclaration() && !maybeExportDeclar.get("declaration").node.id) {
+    if (maybeExportDeclar.isExportDefaultDeclaration()) {
+      const {
+        declaration
+      } = maybeExportDeclar.node;
+
+      if (t.isDeclaration(declaration) && !declaration.id) {
+        return;
+      }
+    }
+
+    if (maybeExportDeclar.isExportAllDeclaration()) {
       return;
     }
 
@@ -72,23 +75,11 @@ class Renamer {
   }
 
   maybeConvertFromClassFunctionDeclaration(path) {
-    return;
-    if (!path.isFunctionDeclaration() && !path.isClassDeclaration()) return;
-    if (this.binding.kind !== "hoisted") return;
-    path.node.id = identifier(this.oldName);
-    path.node._blockHoist = 3;
-    path.replaceWith(variableDeclaration("let", [variableDeclarator(identifier(this.newName), toExpression(path.node))]));
+    return path;
   }
 
   maybeConvertFromClassFunctionExpression(path) {
-    return;
-    if (!path.isFunctionExpression() && !path.isClassExpression()) return;
-    if (this.binding.kind !== "local") return;
-    path.node.id = identifier(this.oldName);
-    this.binding.scope.parent.push({
-      id: identifier(this.newName)
-    });
-    path.replaceWith(assignmentExpression("=", identifier(this.newName), path.node));
+    return path;
   }
 
   rename(block) {
@@ -128,8 +119,8 @@ class Renamer {
     }
 
     if (parentDeclar) {
-      this.maybeConvertFromClassFunctionDeclaration(parentDeclar);
-      this.maybeConvertFromClassFunctionExpression(parentDeclar);
+      this.maybeConvertFromClassFunctionDeclaration(path);
+      this.maybeConvertFromClassFunctionExpression(path);
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babel/traverse",
-  "version": "7.18.2",
+  "version": "7.18.8",
   "description": "The Babel Traverse module maintains the overall tree state, and is responsible for replacing, removing, and adding nodes",
   "author": "The Babel Team (https://babel.dev/team)",
   "homepage": "https://babel.dev/docs/en/next/babel-traverse",
@@ -16,21 +16,22 @@
   },
   "main": "./lib/index.js",
   "dependencies": {
-    "@babel/code-frame": "^7.16.7",
-    "@babel/generator": "^7.18.2",
-    "@babel/helper-environment-visitor": "^7.18.2",
-    "@babel/helper-function-name": "^7.17.9",
-    "@babel/helper-hoist-variables": "^7.16.7",
-    "@babel/helper-split-export-declaration": "^7.16.7",
-    "@babel/parser": "^7.18.0",
-    "@babel/types": "^7.18.2",
+    "@babel/code-frame": "^7.18.6",
+    "@babel/generator": "^7.18.7",
+    "@babel/helper-environment-visitor": "^7.18.6",
+    "@babel/helper-function-name": "^7.18.6",
+    "@babel/helper-hoist-variables": "^7.18.6",
+    "@babel/helper-split-export-declaration": "^7.18.6",
+    "@babel/parser": "^7.18.8",
+    "@babel/types": "^7.18.8",
     "debug": "^4.1.0",
     "globals": "^11.1.0"
   },
   "devDependencies": {
-    "@babel/helper-plugin-test-runner": "^7.16.7"
+    "@babel/helper-plugin-test-runner": "^7.18.6"
   },
   "engines": {
     "node": ">=6.9.0"
-  }
+  },
+  "type": "commonjs"
 }

package/scripts/generators/asserts.js

@@ -1,4 +1,4 @@
-import t from "@babel/types";
+import * as t from "@babel/types";
 
 export default function generateAsserts() {
   let output = `/*

package/scripts/generators/validators.js

@@ -1,5 +1,5 @@
-import t from "@babel/types";
-import virtualTypes from "../../lib/path/lib/virtual-types.js";
+import * as t from "@babel/types";
+import * as virtualTypes from "../../lib/path/lib/virtual-types.js";
 
 export default function generateValidators() {
   let output = `/*
@@ -18,6 +18,9 @@ export interface NodePathValidators {
   }
 
   for (const type of Object.keys(virtualTypes)) {
+    // TODO: Remove this check once we stop compiling to CJS
+    if (type === "default" || type === "__esModule") continue;
+
     const { types } = virtualTypes[type];
     if (type[0] === "_") continue;
     if (t.NODE_FIELDS[type] || t.FLIPPED_ALIAS_KEYS[type]) {

package/scripts/generators/virtual-types.js

@@ -1,4 +1,4 @@
-import virtualTypes from "../../lib/path/lib/virtual-types.js";
+import * as virtualTypes from "../../lib/path/lib/virtual-types.js";
 
 export default function generateValidators() {
   let output = `/*
@@ -11,6 +11,9 @@ export interface VirtualTypeAliases {
 `;
 
   for (const type of Object.keys(virtualTypes)) {
+    // TODO: Remove this check once we stop compiling to CJS
+    if (type === "default" || type === "__esModule") continue;
+
     output += `  ${type}: ${(virtualTypes[type].types || ["Node"])
       .map(t => `t.${t}`)
       .join(" | ")};`;