@babel/traverse 7.14.9 → 7.16.3

package/lib/path/inference/inferers.js

@@ -3,40 +3,64 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.VariableDeclarator = VariableDeclarator;
-exports.TypeCastExpression = TypeCastExpression;
-exports.NewExpression = NewExpression;
-exports.TemplateLiteral = TemplateLiteral;
-exports.UnaryExpression = UnaryExpression;
-exports.BinaryExpression = BinaryExpression;
-exports.LogicalExpression = LogicalExpression;
-exports.ConditionalExpression = ConditionalExpression;
-exports.SequenceExpression = SequenceExpression;
-exports.ParenthesizedExpression = ParenthesizedExpression;
+exports.ArrayExpression = ArrayExpression;
 exports.AssignmentExpression = AssignmentExpression;
-exports.UpdateExpression = UpdateExpression;
-exports.StringLiteral = StringLiteral;
-exports.NumericLiteral = NumericLiteral;
+exports.BinaryExpression = BinaryExpression;
 exports.BooleanLiteral = BooleanLiteral;
-exports.NullLiteral = NullLiteral;
-exports.RegExpLiteral = RegExpLiteral;
-exports.ObjectExpression = ObjectExpression;
-exports.ArrayExpression = ArrayExpression;
-exports.RestElement = RestElement;
-exports.ClassDeclaration = exports.ClassExpression = exports.FunctionDeclaration = exports.ArrowFunctionExpression = exports.FunctionExpression = Func;
 exports.CallExpression = CallExpression;
-exports.TaggedTemplateExpression = TaggedTemplateExpression;
+exports.ConditionalExpression = ConditionalExpression;
+exports.ClassDeclaration = exports.ClassExpression = exports.FunctionDeclaration = exports.ArrowFunctionExpression = exports.FunctionExpression = Func;
 Object.defineProperty(exports, "Identifier", {
   enumerable: true,
   get: function () {
     return _infererReference.default;
   }
 });
+exports.LogicalExpression = LogicalExpression;
+exports.NewExpression = NewExpression;
+exports.NullLiteral = NullLiteral;
+exports.NumericLiteral = NumericLiteral;
+exports.ObjectExpression = ObjectExpression;
+exports.ParenthesizedExpression = ParenthesizedExpression;
+exports.RegExpLiteral = RegExpLiteral;
+exports.RestElement = RestElement;
+exports.SequenceExpression = SequenceExpression;
+exports.StringLiteral = StringLiteral;
+exports.TaggedTemplateExpression = TaggedTemplateExpression;
+exports.TemplateLiteral = TemplateLiteral;
+exports.TypeCastExpression = TypeCastExpression;
+exports.UnaryExpression = UnaryExpression;
+exports.UpdateExpression = UpdateExpression;
+exports.VariableDeclarator = VariableDeclarator;
 
-var t = require("@babel/types");
+var _t = require("@babel/types");
 
 var _infererReference = require("./inferer-reference");
 
+const {
+  BOOLEAN_BINARY_OPERATORS,
+  BOOLEAN_UNARY_OPERATORS,
+  NUMBER_BINARY_OPERATORS,
+  NUMBER_UNARY_OPERATORS,
+  STRING_UNARY_OPERATORS,
+  anyTypeAnnotation,
+  arrayTypeAnnotation,
+  booleanTypeAnnotation,
+  buildMatchMemberExpression,
+  createFlowUnionType,
+  createTSUnionType,
+  createUnionTypeAnnotation,
+  genericTypeAnnotation,
+  identifier,
+  isTSTypeAnnotation,
+  nullLiteralTypeAnnotation,
+  numberTypeAnnotation,
+  stringTypeAnnotation,
+  tupleTypeAnnotation,
+  unionTypeAnnotation,
+  voidTypeAnnotation
+} = _t;
+
 function VariableDeclarator() {
   var _type;
 
@@ -64,75 +88,75 @@ TypeCastExpression.validParent = true;
 
 function NewExpression(node) {
   if (this.get("callee").isIdentifier()) {
-    return t.genericTypeAnnotation(node.callee);
+    return genericTypeAnnotation(node.callee);
   }
 }
 
 function TemplateLiteral() {
-  return t.stringTypeAnnotation();
+  return stringTypeAnnotation();
 }
 
 function UnaryExpression(node) {
   const operator = node.operator;
 
   if (operator === "void") {
-    return t.voidTypeAnnotation();
-  } else if (t.NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {
-    return t.numberTypeAnnotation();
-  } else if (t.STRING_UNARY_OPERATORS.indexOf(operator) >= 0) {
-    return t.stringTypeAnnotation();
-  } else if (t.BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) {
-    return t.booleanTypeAnnotation();
+    return voidTypeAnnotation();
+  } else if (NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return numberTypeAnnotation();
+  } else if (STRING_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return stringTypeAnnotation();
+  } else if (BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return booleanTypeAnnotation();
   }
 }
 
 function BinaryExpression(node) {
   const operator = node.operator;
 
-  if (t.NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
-    return t.numberTypeAnnotation();
-  } else if (t.BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {
-    return t.booleanTypeAnnotation();
+  if (NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
+    return numberTypeAnnotation();
+  } else if (BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {
+    return booleanTypeAnnotation();
   } else if (operator === "+") {
     const right = this.get("right");
     const left = this.get("left");
 
     if (left.isBaseType("number") && right.isBaseType("number")) {
-      return t.numberTypeAnnotation();
+      return numberTypeAnnotation();
     } else if (left.isBaseType("string") || right.isBaseType("string")) {
-      return t.stringTypeAnnotation();
+      return stringTypeAnnotation();
     }
 
-    return t.unionTypeAnnotation([t.stringTypeAnnotation(), t.numberTypeAnnotation()]);
+    return unionTypeAnnotation([stringTypeAnnotation(), numberTypeAnnotation()]);
   }
 }
 
 function LogicalExpression() {
   const argumentTypes = [this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()];
 
-  if (t.isTSTypeAnnotation(argumentTypes[0]) && t.createTSUnionType) {
-    return t.createTSUnionType(argumentTypes);
+  if (isTSTypeAnnotation(argumentTypes[0]) && createTSUnionType) {
+    return createTSUnionType(argumentTypes);
   }
 
-  if (t.createFlowUnionType) {
-    return t.createFlowUnionType(argumentTypes);
+  if (createFlowUnionType) {
+    return createFlowUnionType(argumentTypes);
   }
 
-  return t.createUnionTypeAnnotation(argumentTypes);
+  return createUnionTypeAnnotation(argumentTypes);
 }
 
 function ConditionalExpression() {
   const argumentTypes = [this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()];
 
-  if (t.isTSTypeAnnotation(argumentTypes[0]) && t.createTSUnionType) {
-    return t.createTSUnionType(argumentTypes);
+  if (isTSTypeAnnotation(argumentTypes[0]) && createTSUnionType) {
+    return createTSUnionType(argumentTypes);
   }
 
-  if (t.createFlowUnionType) {
-    return t.createFlowUnionType(argumentTypes);
+  if (createFlowUnionType) {
+    return createFlowUnionType(argumentTypes);
   }
 
-  return t.createUnionTypeAnnotation(argumentTypes);
+  return createUnionTypeAnnotation(argumentTypes);
 }
 
 function SequenceExpression() {
@@ -151,36 +175,36 @@ function UpdateExpression(node) {
   const operator = node.operator;
 
   if (operator === "++" || operator === "--") {
-    return t.numberTypeAnnotation();
+    return numberTypeAnnotation();
   }
 }
 
 function StringLiteral() {
-  return t.stringTypeAnnotation();
+  return stringTypeAnnotation();
 }
 
 function NumericLiteral() {
-  return t.numberTypeAnnotation();
+  return numberTypeAnnotation();
 }
 
 function BooleanLiteral() {
-  return t.booleanTypeAnnotation();
+  return booleanTypeAnnotation();
 }
 
 function NullLiteral() {
-  return t.nullLiteralTypeAnnotation();
+  return nullLiteralTypeAnnotation();
 }
 
 function RegExpLiteral() {
-  return t.genericTypeAnnotation(t.identifier("RegExp"));
+  return genericTypeAnnotation(identifier("RegExp"));
 }
 
 function ObjectExpression() {
-  return t.genericTypeAnnotation(t.identifier("Object"));
+  return genericTypeAnnotation(identifier("Object"));
 }
 
 function ArrayExpression() {
-  return t.genericTypeAnnotation(t.identifier("Array"));
+  return genericTypeAnnotation(identifier("Array"));
 }
 
 function RestElement() {
@@ -190,13 +214,13 @@ function RestElement() {
 RestElement.validParent = true;
 
 function Func() {
-  return t.genericTypeAnnotation(t.identifier("Function"));
+  return genericTypeAnnotation(identifier("Function"));
 }
 
-const isArrayFrom = t.buildMatchMemberExpression("Array.from");
-const isObjectKeys = t.buildMatchMemberExpression("Object.keys");
-const isObjectValues = t.buildMatchMemberExpression("Object.values");
-const isObjectEntries = t.buildMatchMemberExpression("Object.entries");
+const isArrayFrom = buildMatchMemberExpression("Array.from");
+const isObjectKeys = buildMatchMemberExpression("Object.keys");
+const isObjectValues = buildMatchMemberExpression("Object.values");
+const isObjectEntries = buildMatchMemberExpression("Object.entries");
 
 function CallExpression() {
   const {
@@ -204,11 +228,11 @@ function CallExpression() {
   } = this.node;
 
   if (isObjectKeys(callee)) {
-    return t.arrayTypeAnnotation(t.stringTypeAnnotation());
+    return arrayTypeAnnotation(stringTypeAnnotation());
   } else if (isArrayFrom(callee) || isObjectValues(callee)) {
-    return t.arrayTypeAnnotation(t.anyTypeAnnotation());
+    return arrayTypeAnnotation(anyTypeAnnotation());
   } else if (isObjectEntries(callee)) {
-    return t.arrayTypeAnnotation(t.tupleTypeAnnotation([t.stringTypeAnnotation(), t.anyTypeAnnotation()]));
+    return arrayTypeAnnotation(tupleTypeAnnotation([stringTypeAnnotation(), anyTypeAnnotation()]));
   }
 
   return resolveCall(this.get("callee"));
@@ -224,9 +248,9 @@ function resolveCall(callee) {
   if (callee.isFunction()) {
     if (callee.is("async")) {
       if (callee.is("generator")) {
-        return t.genericTypeAnnotation(t.identifier("AsyncIterator"));
+        return genericTypeAnnotation(identifier("AsyncIterator"));
       } else {
-        return t.genericTypeAnnotation(t.identifier("Promise"));
+        return genericTypeAnnotation(identifier("Promise"));
       }
     } else {
       if (callee.node.returnType) {

package/lib/path/introspection.js

@@ -3,31 +3,43 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.matchesPattern = matchesPattern;
-exports.has = has;
-exports.isStatic = isStatic;
-exports.isnt = isnt;
-exports.equals = equals;
-exports.isNodeType = isNodeType;
+exports._guessExecutionStatusRelativeTo = _guessExecutionStatusRelativeTo;
+exports._guessExecutionStatusRelativeToDifferentFunctions = _guessExecutionStatusRelativeToDifferentFunctions;
+exports._resolve = _resolve;
 exports.canHaveVariableDeclarationOrExpression = canHaveVariableDeclarationOrExpression;
 exports.canSwapBetweenExpressionAndStatement = canSwapBetweenExpressionAndStatement;
+exports.equals = equals;
+exports.getSource = getSource;
+exports.has = has;
+exports.is = void 0;
 exports.isCompletionRecord = isCompletionRecord;
+exports.isConstantExpression = isConstantExpression;
+exports.isInStrictMode = isInStrictMode;
+exports.isNodeType = isNodeType;
 exports.isStatementOrBlock = isStatementOrBlock;
+exports.isStatic = isStatic;
+exports.isnt = isnt;
+exports.matchesPattern = matchesPattern;
 exports.referencesImport = referencesImport;
-exports.getSource = getSource;
-exports.willIMaybeExecuteBefore = willIMaybeExecuteBefore;
-exports._guessExecutionStatusRelativeTo = _guessExecutionStatusRelativeTo;
-exports._guessExecutionStatusRelativeToDifferentFunctions = _guessExecutionStatusRelativeToDifferentFunctions;
 exports.resolve = resolve;
-exports._resolve = _resolve;
-exports.isConstantExpression = isConstantExpression;
-exports.isInStrictMode = isInStrictMode;
-exports.is = void 0;
+exports.willIMaybeExecuteBefore = willIMaybeExecuteBefore;
+
+var _t = require("@babel/types");
 
-var t = require("@babel/types");
+const {
+  STATEMENT_OR_BLOCK_KEYS,
+  VISITOR_KEYS,
+  isBlockStatement,
+  isExpression,
+  isIdentifier,
+  isLiteral,
+  isStringLiteral,
+  isType,
+  matchesPattern: _matchesPattern
+} = _t;
 
 function matchesPattern(pattern, allowPartial) {
-  return t.matchesPattern(this.node, pattern, allowPartial);
+  return _matchesPattern(this.node, pattern, allowPartial);
 }
 
 function has(key) {
@@ -56,7 +68,7 @@ function equals(key, value) {
 }
 
 function isNodeType(type) {
-  return t.isType(this.type, type);
+  return isType(this.type, type);
 }
 
 function canHaveVariableDeclarationOrExpression() {
@@ -69,9 +81,9 @@ function canSwapBetweenExpressionAndStatement(replacement) {
   }
 
   if (this.isExpression()) {
-    return t.isBlockStatement(replacement);
+    return isBlockStatement(replacement);
   } else if (this.isBlockStatement()) {
-    return t.isExpression(replacement);
+    return isExpression(replacement);
   }
 
   return false;
@@ -99,16 +111,16 @@ function isCompletionRecord(allowInsideFunction) {
 }
 
 function isStatementOrBlock() {
-  if (this.parentPath.isLabeledStatement() || t.isBlockStatement(this.container)) {
+  if (this.parentPath.isLabeledStatement() || isBlockStatement(this.container)) {
     return false;
   } else {
-    return t.STATEMENT_OR_BLOCK_KEYS.includes(this.key);
+    return STATEMENT_OR_BLOCK_KEYS.includes(this.key);
   }
 }
 
 function referencesImport(moduleSource, importName) {
   if (!this.isReferencedIdentifier()) {
-    if ((this.isMemberExpression() || this.isOptionalMemberExpression()) && (this.node.computed ? t.isStringLiteral(this.node.property, {
+    if ((this.isMemberExpression() || this.isOptionalMemberExpression()) && (this.node.computed ? isStringLiteral(this.node.property, {
       value: importName
     }) : this.node.property.name === importName)) {
       const object = this.get("object");
@@ -138,7 +150,7 @@ function referencesImport(moduleSource, importName) {
     return true;
   }
 
-  if (path.isImportSpecifier() && t.isIdentifier(path.node.imported, {
+  if (path.isImportSpecifier() && isIdentifier(path.node.imported, {
     name: importName
   })) {
     return true;
@@ -266,7 +278,7 @@ function _guessExecutionStatusRelativeTo(target) {
     return divergence.target.key > divergence.this.key ? "before" : "after";
   }
 
-  const keys = t.VISITOR_KEYS[commonPath.type];
+  const keys = VISITOR_KEYS[commonPath.type];
   const keyPosition = {
     this: keys.indexOf(divergence.this.parentKey),
     target: keys.indexOf(divergence.target.parentKey)
@@ -339,7 +351,7 @@ function _resolve(dangerous, resolved) {
     return this.get("expression").resolve(dangerous, resolved);
   } else if (dangerous && this.isMemberExpression()) {
     const targetKey = this.toComputedKey();
-    if (!t.isLiteral(targetKey)) return;
+    if (!isLiteral(targetKey)) return;
     const targetName = targetKey.value;
     const target = this.get("object").resolve(dangerous, resolved);
 

package/lib/path/lib/hoister.js

@@ -5,11 +5,21 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var t = require("@babel/types");
-
+var _t = require("@babel/types");
+
+var _t2 = _t;
+const {
+  react
+} = _t;
+const {
+  cloneNode,
+  jsxExpressionContainer,
+  variableDeclaration,
+  variableDeclarator
+} = _t2;
 const referenceVisitor = {
   ReferencedIdentifier(path, state) {
-    if (path.isJSXIdentifier() && t.react.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
+    if (path.isJSXIdentifier() && react.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
       return;
     }
 
@@ -178,16 +188,16 @@ class PathHoister {
     if (!attachTo) return;
     if (attachTo.getFunctionParent() === this.path.getFunctionParent()) return;
     let uid = attachTo.scope.generateUidIdentifier("ref");
-    const declarator = t.variableDeclarator(uid, this.path.node);
+    const declarator = variableDeclarator(uid, this.path.node);
     const insertFn = this.attachAfter ? "insertAfter" : "insertBefore";
-    const [attached] = attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : t.variableDeclaration("var", [declarator])]);
+    const [attached] = attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : variableDeclaration("var", [declarator])]);
     const parent = this.path.parentPath;
 
     if (parent.isJSXElement() && this.path.container === parent.node.children) {
-      uid = t.jsxExpressionContainer(uid);
+      uid = jsxExpressionContainer(uid);
     }
 
-    this.path.replaceWith(t.cloneNode(uid));
+    this.path.replaceWith(cloneNode(uid));
     return attachTo.isVariableDeclarator() ? attached.get("init") : attached.get("declarations.0.init");
   }
 

package/lib/path/lib/virtual-types.js

@@ -3,10 +3,34 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.ForAwaitStatement = exports.NumericLiteralTypeAnnotation = exports.ExistentialTypeParam = exports.SpreadProperty = exports.RestProperty = exports.Flow = exports.Pure = exports.Generated = exports.User = exports.Var = exports.BlockScoped = exports.Referenced = exports.Scope = exports.Expression = exports.Statement = exports.BindingIdentifier = exports.ReferencedMemberExpression = exports.ReferencedIdentifier = void 0;
-
-var t = require("@babel/types");
-
+exports.Var = exports.User = exports.Statement = exports.SpreadProperty = exports.Scope = exports.RestProperty = exports.ReferencedMemberExpression = exports.ReferencedIdentifier = exports.Referenced = exports.Pure = exports.NumericLiteralTypeAnnotation = exports.Generated = exports.ForAwaitStatement = exports.Flow = exports.Expression = exports.ExistentialTypeParam = exports.BlockScoped = exports.BindingIdentifier = void 0;
+
+var _t = require("@babel/types");
+
+const {
+  isBinding,
+  isBlockScoped,
+  isExportDeclaration,
+  isExpression,
+  isFlow,
+  isForStatement,
+  isForXStatement,
+  isIdentifier,
+  isImportDeclaration,
+  isImportSpecifier,
+  isJSXIdentifier,
+  isJSXMemberExpression,
+  isMemberExpression,
+  isReferenced,
+  isScope,
+  isStatement,
+  isVar,
+  isVariableDeclaration,
+  react
+} = _t;
+const {
+  isCompatTag
+} = react;
 const ReferencedIdentifier = {
   types: ["Identifier", "JSXIdentifier"],
 
@@ -16,15 +40,15 @@ const ReferencedIdentifier = {
       parent
     } = path;
 
-    if (!t.isIdentifier(node, opts) && !t.isJSXMemberExpression(parent, opts)) {
-      if (t.isJSXIdentifier(node, opts)) {
-        if (t.react.isCompatTag(node.name)) return false;
+    if (!isIdentifier(node, opts) && !isJSXMemberExpression(parent, opts)) {
+      if (isJSXIdentifier(node, opts)) {
+        if (isCompatTag(node.name)) return false;
       } else {
         return false;
       }
     }
 
-    return t.isReferenced(node, parent, path.parentPath.parent);
+    return isReferenced(node, parent, path.parentPath.parent);
   }
 
 };
@@ -36,7 +60,7 @@ const ReferencedMemberExpression = {
     node,
     parent
   }) {
-    return t.isMemberExpression(node) && t.isReferenced(node, parent);
+    return isMemberExpression(node) && isReferenced(node, parent);
   }
 
 };
@@ -50,7 +74,7 @@ const BindingIdentifier = {
       parent
     } = path;
     const grandparent = path.parentPath.parent;
-    return t.isIdentifier(node) && t.isBinding(node, parent, grandparent);
+    return isIdentifier(node) && isBinding(node, parent, grandparent);
   }
 
 };
@@ -62,12 +86,12 @@ const Statement = {
     node,
     parent
   }) {
-    if (t.isStatement(node)) {
-      if (t.isVariableDeclaration(node)) {
-        if (t.isForXStatement(parent, {
+    if (isStatement(node)) {
+      if (isVariableDeclaration(node)) {
+        if (isForXStatement(parent, {
           left: node
         })) return false;
-        if (t.isForStatement(parent, {
+        if (isForStatement(parent, {
           init: node
         })) return false;
       }
@@ -87,7 +111,7 @@ const Expression = {
     if (path.isIdentifier()) {
       return path.isReferencedIdentifier();
     } else {
-      return t.isExpression(path.node);
+      return isExpression(path.node);
     }
   }
 
@@ -97,21 +121,21 @@ const Scope = {
   types: ["Scopable", "Pattern"],
 
   checkPath(path) {
-    return t.isScope(path.node, path.parent);
+    return isScope(path.node, path.parent);
   }
 
 };
 exports.Scope = Scope;
 const Referenced = {
   checkPath(path) {
-    return t.isReferenced(path.node, path.parent);
+    return isReferenced(path.node, path.parent);
   }
 
 };
 exports.Referenced = Referenced;
 const BlockScoped = {
   checkPath(path) {
-    return t.isBlockScoped(path.node);
+    return isBlockScoped(path.node);
   }
 
 };
@@ -120,7 +144,7 @@ const Var = {
   types: ["VariableDeclaration"],
 
   checkPath(path) {
-    return t.isVar(path.node);
+    return isVar(path.node);
   }
 
 };
@@ -152,13 +176,13 @@ const Flow = {
   checkPath({
     node
   }) {
-    if (t.isFlow(node)) {
+    if (isFlow(node)) {
       return true;
-    } else if (t.isImportDeclaration(node)) {
+    } else if (isImportDeclaration(node)) {
       return node.importKind === "type" || node.importKind === "typeof";
-    } else if (t.isExportDeclaration(node)) {
+    } else if (isExportDeclaration(node)) {
       return node.exportKind === "type";
-    } else if (t.isImportSpecifier(node)) {
+    } else if (isImportSpecifier(node)) {
       return node.importKind === "type" || node.importKind === "typeof";
     } else {
       return false;