@babel/traverse 8.0.0-alpha.2 → 8.0.0-alpha.4

package/lib/index.js

@@ -30,24 +30,24 @@ const ForAwaitStatement = ["ForOfStatement"];
 
 var virtualTypes = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  ReferencedIdentifier: ReferencedIdentifier,
-  ReferencedMemberExpression: ReferencedMemberExpression,
   BindingIdentifier: BindingIdentifier,
-  Statement: Statement,
-  Expression: Expression,
-  Scope: Scope$1,
-  Referenced: Referenced,
   BlockScoped: BlockScoped,
-  Var: Var,
-  User: User,
+  ExistentialTypeParam: ExistentialTypeParam,
+  Expression: Expression,
+  Flow: Flow,
+  ForAwaitStatement: ForAwaitStatement,
   Generated: Generated,
+  NumericLiteralTypeAnnotation: NumericLiteralTypeAnnotation,
   Pure: Pure,
-  Flow: Flow,
+  Referenced: Referenced,
+  ReferencedIdentifier: ReferencedIdentifier,
+  ReferencedMemberExpression: ReferencedMemberExpression,
   RestProperty: RestProperty,
+  Scope: Scope$1,
   SpreadProperty: SpreadProperty,
-  ExistentialTypeParam: ExistentialTypeParam,
-  NumericLiteralTypeAnnotation: NumericLiteralTypeAnnotation,
-  ForAwaitStatement: ForAwaitStatement
+  Statement: Statement,
+  User: User,
+  Var: Var
 });
 
 const {
@@ -257,10 +257,10 @@ function mergePair(dest, src) {
 
 var visitors = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  isExplodedVisitor: isExplodedVisitor,
   explode: explode,
-  verify: verify,
-  merge: merge
+  isExplodedVisitor: isExplodedVisitor,
+  merge: merge,
+  verify: verify
 });
 
 let pathsCache = new WeakMap();
@@ -289,13 +289,13 @@ function getOrCreateCachedPaths(hub, parent) {
 
 var cache = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  get path () { return pathsCache; },
-  get scope () { return scope; },
   clear: clear,
   clearPath: clearPath,
   clearScope: clearScope,
   getCachedPaths: getCachedPaths,
-  getOrCreateCachedPaths: getOrCreateCachedPaths
+  getOrCreateCachedPaths: getOrCreateCachedPaths,
+  get path () { return pathsCache; },
+  get scope () { return scope; }
 });
 
 const renameVisitor = {
@@ -412,9 +412,7 @@ class Binding {
     this.scope = scope;
     this.path = path;
     this.kind = kind;
-    if ((kind === "var" || kind === "hoisted") && isDeclaredInLoop(path || (() => {
-      throw new Error("Internal Babel error: unreachable ");
-    })())) {
+    if ((kind === "var" || kind === "hoisted") && isDeclaredInLoop(path)) {
       this.reassign(path);
     }
     this.clearValue();
@@ -509,7 +507,6 @@ const {
   memberExpression: memberExpression$1,
   numericLiteral: numericLiteral$2,
   toIdentifier,
-  unaryExpression: unaryExpression$2,
   variableDeclaration: variableDeclaration$1,
   variableDeclarator: variableDeclarator$1,
   isRecordExpression,
@@ -518,7 +515,8 @@ const {
   isTopicReference,
   isMetaProperty,
   isPrivateName,
-  isExportDeclaration: isExportDeclaration$1
+  isExportDeclaration: isExportDeclaration$1,
+  buildUndefinedNode
 } = _t;
 function gatherNodeParts(node, parts) {
   switch (node?.type) {
@@ -968,7 +966,7 @@ class Scope {
     }
   }
   buildUndefinedNode() {
-    return unaryExpression$2("void", numericLiteral$2(0), true);
+    return buildUndefinedNode();
   }
   registerConstantViolation(path) {
     const ids = path.getBindingIdentifiers();
@@ -1461,16 +1459,16 @@ function inType(...candidateTypes) {
 
 var NodePath_ancestry = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  findParent: findParent,
   find: find,
+  findParent: findParent,
+  getAncestry: getAncestry,
+  getDeepestCommonAncestorFrom: getDeepestCommonAncestorFrom,
+  getEarliestCommonAncestorFrom: getEarliestCommonAncestorFrom,
   getFunctionParent: getFunctionParent,
   getStatementParent: getStatementParent,
-  getEarliestCommonAncestorFrom: getEarliestCommonAncestorFrom,
-  getDeepestCommonAncestorFrom: getDeepestCommonAncestorFrom,
-  getAncestry: getAncestry,
+  inType: inType,
   isAncestor: isAncestor,
-  isDescendant: isDescendant,
-  inType: inType
+  isDescendant: isDescendant
 });
 
 const {
@@ -1802,36 +1800,36 @@ function resolveCall(callee) {
 
 var inferers = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  VariableDeclarator: VariableDeclarator,
-  TypeCastExpression: TypeCastExpression,
-  TSAsExpression: TSAsExpression,
-  TSNonNullExpression: TSNonNullExpression,
-  NewExpression: NewExpression,
-  TemplateLiteral: TemplateLiteral,
-  UnaryExpression: UnaryExpression,
-  BinaryExpression: BinaryExpression,
-  LogicalExpression: LogicalExpression,
-  ConditionalExpression: ConditionalExpression,
-  SequenceExpression: SequenceExpression,
-  ParenthesizedExpression: ParenthesizedExpression,
+  ArrayExpression: ArrayExpression,
+  ArrowFunctionExpression: Func,
   AssignmentExpression: AssignmentExpression,
-  UpdateExpression: UpdateExpression,
-  StringLiteral: StringLiteral,
-  NumericLiteral: NumericLiteral,
+  BinaryExpression: BinaryExpression,
   BooleanLiteral: BooleanLiteral,
+  CallExpression: CallExpression,
+  ClassDeclaration: Func,
+  ClassExpression: Func,
+  ConditionalExpression: ConditionalExpression,
+  FunctionDeclaration: Func,
+  FunctionExpression: Func,
+  Identifier: infererReference,
+  LogicalExpression: LogicalExpression,
+  NewExpression: NewExpression,
   NullLiteral: NullLiteral,
-  RegExpLiteral: RegExpLiteral,
+  NumericLiteral: NumericLiteral,
   ObjectExpression: ObjectExpression,
-  ArrayExpression: ArrayExpression,
+  ParenthesizedExpression: ParenthesizedExpression,
+  RegExpLiteral: RegExpLiteral,
   RestElement: RestElement,
-  FunctionExpression: Func,
-  ArrowFunctionExpression: Func,
-  FunctionDeclaration: Func,
-  ClassExpression: Func,
-  ClassDeclaration: Func,
-  CallExpression: CallExpression,
+  SequenceExpression: SequenceExpression,
+  StringLiteral: StringLiteral,
+  TSAsExpression: TSAsExpression,
+  TSNonNullExpression: TSNonNullExpression,
   TaggedTemplateExpression: TaggedTemplateExpression,
-  Identifier: infererReference
+  TemplateLiteral: TemplateLiteral,
+  TypeCastExpression: TypeCastExpression,
+  UnaryExpression: UnaryExpression,
+  UpdateExpression: UpdateExpression,
+  VariableDeclarator: VariableDeclarator
 });
 
 const {
@@ -1970,11 +1968,11 @@ function isGenericType(genericName) {
 
 var NodePath_inference = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  getTypeAnnotation: getTypeAnnotation,
   _getTypeAnnotation: _getTypeAnnotation,
-  isBaseType: isBaseType,
-  couldBeBaseType: couldBeBaseType,
   baseTypeStrictlyMatches: baseTypeStrictlyMatches,
+  couldBeBaseType: couldBeBaseType,
+  getTypeAnnotation: getTypeAnnotation,
+  isBaseType: isBaseType,
   isGenericType: isGenericType
 });
 
@@ -2164,18 +2162,22 @@ function replaceInline(nodes) {
 
 var NodePath_replacement = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  replaceWithMultiple: replaceWithMultiple,
-  replaceWithSourceString: replaceWithSourceString,
-  replaceWith: replaceWith,
   _replaceWith: _replaceWith,
   replaceExpressionWithStatements: replaceExpressionWithStatements,
-  replaceInline: replaceInline
+  replaceInline: replaceInline,
+  replaceWith: replaceWith,
+  replaceWithMultiple: replaceWithMultiple,
+  replaceWithSourceString: replaceWithSourceString
 });
 
-const VALID_CALLEES = ["String", "Number", "Math"];
+const VALID_OBJECT_CALLEES = ["Number", "String", "Math"];
+const VALID_IDENTIFIER_CALLEES = ["isFinite", "isNaN", "parseFloat", "parseInt", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", "btoa", "atob"];
 const INVALID_METHODS = ["random"];
-function isValidCallee(val) {
-  return VALID_CALLEES.includes(val);
+function isValidObjectCallee(val) {
+  return VALID_OBJECT_CALLEES.includes(val);
+}
+function isValidIdentifierCallee(val) {
+  return VALID_IDENTIFIER_CALLEES.includes(val);
 }
 function isInvalidMethod(val) {
   return INVALID_METHODS.includes(val);
@@ -2450,15 +2452,18 @@ function _evaluate(path, state) {
     const callee = path.get("callee");
     let context;
     let func;
-    if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && isValidCallee(callee.node.name)) {
+    if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && (isValidObjectCallee(callee.node.name) || isValidIdentifierCallee(callee.node.name))) {
       func = global[callee.node.name];
     }
     if (callee.isMemberExpression()) {
       const object = callee.get("object");
       const property = callee.get("property");
-      if (object.isIdentifier() && property.isIdentifier() && isValidCallee(object.node.name) && !isInvalidMethod(property.node.name)) {
+      if (object.isIdentifier() && property.isIdentifier() && isValidObjectCallee(object.node.name) && !isInvalidMethod(property.node.name)) {
         context = global[object.node.name];
-        func = context[property.node.name];
+        const key = property.node.name;
+        if (Object.hasOwnProperty.call(context, key)) {
+          func = context[key];
+        }
       }
       if (object.isLiteral() && property.isIdentifier()) {
         const type = typeof object.node.value;
@@ -2506,8 +2511,8 @@ function evaluate() {
 
 var NodePath_evaluation = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  evaluateTruthy: evaluateTruthy,
-  evaluate: evaluate
+  evaluate: evaluate,
+  evaluateTruthy: evaluateTruthy
 });
 
 const {
@@ -2959,10 +2964,10 @@ function getScopeInformation(fnPath) {
 
 var NodePath_conversion = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  toComputedKey: toComputedKey,
+  arrowFunctionToExpression: arrowFunctionToExpression,
   ensureBlock: ensureBlock,
-  unwrapFunctionEnvironment: unwrapFunctionEnvironment,
-  arrowFunctionToExpression: arrowFunctionToExpression
+  toComputedKey: toComputedKey,
+  unwrapFunctionEnvironment: unwrapFunctionEnvironment
 });
 
 const {
@@ -3325,25 +3330,25 @@ function isInStrictMode() {
 
 var NodePath_introspection = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  matchesPattern: matchesPattern,
-  has: has,
-  isStatic: isStatic,
-  is: is,
-  isnt: isnt,
-  equals: equals,
-  isNodeType: isNodeType,
+  _guessExecutionStatusRelativeTo: _guessExecutionStatusRelativeTo,
+  _resolve: _resolve,
   canHaveVariableDeclarationOrExpression: canHaveVariableDeclarationOrExpression,
   canSwapBetweenExpressionAndStatement: canSwapBetweenExpressionAndStatement,
+  equals: equals,
+  getSource: getSource,
+  has: has,
+  is: is,
   isCompletionRecord: isCompletionRecord,
+  isConstantExpression: isConstantExpression,
+  isInStrictMode: isInStrictMode,
+  isNodeType: isNodeType,
   isStatementOrBlock: isStatementOrBlock,
+  isStatic: isStatic,
+  isnt: isnt,
+  matchesPattern: matchesPattern,
   referencesImport: referencesImport,
-  getSource: getSource,
-  willIMaybeExecuteBefore: willIMaybeExecuteBefore,
-  _guessExecutionStatusRelativeTo: _guessExecutionStatusRelativeTo,
   resolve: resolve,
-  _resolve: _resolve,
-  isConstantExpression: isConstantExpression,
-  isInStrictMode: isInStrictMode
+  willIMaybeExecuteBefore: willIMaybeExecuteBefore
 });
 
 function call(key) {
@@ -3538,27 +3543,27 @@ function _getQueueContexts() {
 
 var NodePath_context = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  call: call,
   _call: _call,
-  isDenylisted: isDenylisted,
-  isBlacklisted: isDenylisted,
-  visit: visit,
-  skip: skip,
-  skipKey: skipKey,
-  stop: stop,
-  setScope: setScope,
-  setContext: setContext,
-  resync: resync,
-  _resyncParent: _resyncParent,
+  _getQueueContexts: _getQueueContexts,
   _resyncKey: _resyncKey,
   _resyncList: _resyncList,
+  _resyncParent: _resyncParent,
   _resyncRemoved: _resyncRemoved,
+  call: call,
+  isBlacklisted: isDenylisted,
+  isDenylisted: isDenylisted,
   popContext: popContext,
   pushContext: pushContext,
-  setup: setup,
-  setKey: setKey,
   requeue: requeue,
-  _getQueueContexts: _getQueueContexts
+  resync: resync,
+  setContext: setContext,
+  setKey: setKey,
+  setScope: setScope,
+  setup: setup,
+  skip: skip,
+  skipKey: skipKey,
+  stop: stop,
+  visit: visit
 });
 
 const hooks = [function (self, parent) {
@@ -3637,12 +3642,12 @@ function _assertUnremoved() {
 
 var NodePath_removal = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  remove: remove,
-  _removeFromScope: _removeFromScope,
+  _assertUnremoved: _assertUnremoved,
   _callRemovalHooks: _callRemovalHooks,
-  _remove: _remove,
   _markRemoved: _markRemoved,
-  _assertUnremoved: _assertUnremoved
+  _remove: _remove,
+  _removeFromScope: _removeFromScope,
+  remove: remove
 });
 
 const {
@@ -4012,16 +4017,16 @@ function hoist(scope = this.scope) {
 
 var NodePath_modification = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  insertBefore: insertBefore,
   _containerInsert: _containerInsert,
-  _containerInsertBefore: _containerInsertBefore,
   _containerInsertAfter: _containerInsertAfter,
-  insertAfter: insertAfter,
-  updateSiblingKeys: updateSiblingKeys,
+  _containerInsertBefore: _containerInsertBefore,
   _verifyNodeList: _verifyNodeList,
-  unshiftContainer: unshiftContainer,
+  hoist: hoist,
+  insertAfter: insertAfter,
+  insertBefore: insertBefore,
   pushContainer: pushContainer,
-  hoist: hoist
+  unshiftContainer: unshiftContainer,
+  updateSiblingKeys: updateSiblingKeys
 });
 
 const {
@@ -4340,20 +4345,20 @@ function getOuterBindingIdentifierPaths(duplicates = false) {
 
 var NodePath_family = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  getOpposite: getOpposite,
-  getCompletionRecords: getCompletionRecords,
-  getSibling: getSibling,
-  getPrevSibling: getPrevSibling,
-  getNextSibling: getNextSibling,
-  getAllNextSiblings: getAllNextSiblings,
-  getAllPrevSiblings: getAllPrevSiblings,
-  get: get,
   _getKey: _getKey,
   _getPattern: _getPattern,
+  get: get,
+  getAllNextSiblings: getAllNextSiblings,
+  getAllPrevSiblings: getAllPrevSiblings,
+  getBindingIdentifierPaths: getBindingIdentifierPaths,
   getBindingIdentifiers: getBindingIdentifiers,
+  getCompletionRecords: getCompletionRecords,
+  getNextSibling: getNextSibling,
+  getOpposite: getOpposite,
+  getOuterBindingIdentifierPaths: getOuterBindingIdentifierPaths,
   getOuterBindingIdentifiers: getOuterBindingIdentifiers,
-  getBindingIdentifierPaths: getBindingIdentifierPaths,
-  getOuterBindingIdentifierPaths: getOuterBindingIdentifierPaths
+  getPrevSibling: getPrevSibling,
+  getSibling: getSibling
 });
 
 const {
@@ -4402,9 +4407,9 @@ function addComments(type, comments) {
 
 var NodePath_comments = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  shareCommentsWithSiblings: shareCommentsWithSiblings,
   addComment: addComment,
-  addComments: addComments
+  addComments: addComments,
+  shareCommentsWithSiblings: shareCommentsWithSiblings
 });
 
 const {
@@ -4539,22 +4544,22 @@ function isForAwaitStatement() {
 
 var NodePath_virtual_types_validator = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  isReferencedIdentifier: isReferencedIdentifier,
-  isReferencedMemberExpression: isReferencedMemberExpression,
   isBindingIdentifier: isBindingIdentifier,
-  isStatement: isStatement,
-  isExpression: isExpression,
-  isScope: isScope,
-  isReferenced: isReferenced,
   isBlockScoped: isBlockScoped,
-  isVar: isVar,
-  isUser: isUser,
+  isExpression: isExpression,
+  isFlow: isFlow,
+  isForAwaitStatement: isForAwaitStatement,
   isGenerated: isGenerated,
   isPure: isPure,
-  isFlow: isFlow,
+  isReferenced: isReferenced,
+  isReferencedIdentifier: isReferencedIdentifier,
+  isReferencedMemberExpression: isReferencedMemberExpression,
   isRestProperty: isRestProperty,
+  isScope: isScope,
   isSpreadProperty: isSpreadProperty,
-  isForAwaitStatement: isForAwaitStatement
+  isStatement: isStatement,
+  isUser: isUser,
+  isVar: isVar
 });
 
 const {