@babel/traverse 8.0.0-alpha.3 → 8.0.0-alpha.5

package/lib/index.js

@@ -50,6 +50,156 @@ var virtualTypes = /*#__PURE__*/Object.freeze({
   Var: Var
 });
 
+const {
+  isBinding,
+  isBlockScoped: nodeIsBlockScoped,
+  isExportDeclaration: isExportDeclaration$1,
+  isExpression: nodeIsExpression,
+  isFlow: nodeIsFlow,
+  isForStatement,
+  isForXStatement,
+  isIdentifier: isIdentifier$6,
+  isImportDeclaration: isImportDeclaration$1,
+  isImportSpecifier,
+  isJSXIdentifier,
+  isJSXMemberExpression,
+  isMemberExpression,
+  isRestElement: nodeIsRestElement,
+  isReferenced: nodeIsReferenced,
+  isScope: nodeIsScope,
+  isStatement: nodeIsStatement,
+  isVar: nodeIsVar,
+  isVariableDeclaration: isVariableDeclaration$2,
+  react: react$1,
+  isForOfStatement
+} = _t;
+const {
+  isCompatTag
+} = react$1;
+function isReferencedIdentifier(opts) {
+  const {
+    node,
+    parent
+  } = this;
+  if (!isIdentifier$6(node, opts) && !isJSXMemberExpression(parent, opts)) {
+    if (isJSXIdentifier(node, opts)) {
+      if (isCompatTag(node.name)) return false;
+    } else {
+      return false;
+    }
+  }
+  return nodeIsReferenced(node, parent, this.parentPath.parent);
+}
+function isReferencedMemberExpression() {
+  const {
+    node,
+    parent
+  } = this;
+  return isMemberExpression(node) && nodeIsReferenced(node, parent);
+}
+function isBindingIdentifier() {
+  const {
+    node,
+    parent
+  } = this;
+  const grandparent = this.parentPath.parent;
+  return isIdentifier$6(node) && isBinding(node, parent, grandparent);
+}
+function isStatement$1() {
+  const {
+    node,
+    parent
+  } = this;
+  if (nodeIsStatement(node)) {
+    if (isVariableDeclaration$2(node)) {
+      if (isForXStatement(parent, {
+        left: node
+      })) return false;
+      if (isForStatement(parent, {
+        init: node
+      })) return false;
+    }
+    return true;
+  } else {
+    return false;
+  }
+}
+function isExpression$3() {
+  if (this.isIdentifier()) {
+    return this.isReferencedIdentifier();
+  } else {
+    return nodeIsExpression(this.node);
+  }
+}
+function isScope() {
+  return nodeIsScope(this.node, this.parent);
+}
+function isReferenced() {
+  return nodeIsReferenced(this.node, this.parent);
+}
+function isBlockScoped() {
+  return nodeIsBlockScoped(this.node);
+}
+function isVar() {
+  return nodeIsVar(this.node);
+}
+function isUser() {
+  return this.node && !!this.node.loc;
+}
+function isGenerated() {
+  return !this.isUser();
+}
+function isPure(constantsOnly) {
+  return this.scope.isPure(this.node, constantsOnly);
+}
+function isFlow() {
+  const {
+    node
+  } = this;
+  if (nodeIsFlow(node)) {
+    return true;
+  } else if (isImportDeclaration$1(node)) {
+    return node.importKind === "type" || node.importKind === "typeof";
+  } else if (isExportDeclaration$1(node)) {
+    return node.exportKind === "type";
+  } else if (isImportSpecifier(node)) {
+    return node.importKind === "type" || node.importKind === "typeof";
+  } else {
+    return false;
+  }
+}
+function isRestProperty() {
+  return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectPattern();
+}
+function isSpreadProperty() {
+  return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectExpression();
+}
+function isForAwaitStatement() {
+  return isForOfStatement(this.node, {
+    await: true
+  });
+}
+
+var NodePath_virtual_types_validator = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  isBindingIdentifier: isBindingIdentifier,
+  isBlockScoped: isBlockScoped,
+  isExpression: isExpression$3,
+  isFlow: isFlow,
+  isForAwaitStatement: isForAwaitStatement,
+  isGenerated: isGenerated,
+  isPure: isPure,
+  isReferenced: isReferenced,
+  isReferencedIdentifier: isReferencedIdentifier,
+  isReferencedMemberExpression: isReferencedMemberExpression,
+  isRestProperty: isRestProperty,
+  isScope: isScope,
+  isSpreadProperty: isSpreadProperty,
+  isStatement: isStatement$1,
+  isUser: isUser,
+  isVar: isVar
+});
+
 const {
   DEPRECATED_KEYS,
   DEPRECATED_ALIASES,
@@ -232,8 +382,10 @@ function ensureCallbackArrays(obj) {
   if (obj.exit && !Array.isArray(obj.exit)) obj.exit = [obj.exit];
 }
 function wrapCheck(nodeType, fn) {
+  const fnKey = `is${nodeType}`;
+  const validator = NodePath_virtual_types_validator[fnKey];
   const newFn = function (path) {
-    if (path[`is${nodeType}`]()) {
+    if (validator.call(path)) {
       return fn.apply(this, arguments);
     }
   };
@@ -476,7 +628,7 @@ const {
   NOT_LOCAL_BINDING,
   callExpression: callExpression$3,
   cloneNode: cloneNode$3,
-  getBindingIdentifiers: getBindingIdentifiers$1,
+  getBindingIdentifiers: getBindingIdentifiers$3,
   identifier: identifier$3,
   isArrayExpression,
   isBinary,
@@ -487,8 +639,8 @@ const {
   isExportDefaultDeclaration,
   isExportNamedDeclaration: isExportNamedDeclaration$1,
   isFunctionDeclaration,
-  isIdentifier: isIdentifier$6,
-  isImportDeclaration: isImportDeclaration$1,
+  isIdentifier: isIdentifier$5,
+  isImportDeclaration,
   isLiteral: isLiteral$1,
   isMethod,
   isModuleSpecifier,
@@ -515,16 +667,16 @@ const {
   isTopicReference,
   isMetaProperty,
   isPrivateName,
-  isExportDeclaration: isExportDeclaration$1,
-  buildUndefinedNode
+  isExportDeclaration,
+  buildUndefinedNode: buildUndefinedNode$1
 } = _t;
 function gatherNodeParts(node, parts) {
   switch (node?.type) {
     default:
-      if (isImportDeclaration$1(node) || isExportDeclaration$1(node)) {
-        if ((isExportAllDeclaration(node) || isExportNamedDeclaration$1(node) || isImportDeclaration$1(node)) && node.source) {
+      if (isImportDeclaration(node) || isExportDeclaration(node)) {
+        if ((isExportAllDeclaration(node) || isExportNamedDeclaration$1(node) || isImportDeclaration(node)) && node.source) {
           gatherNodeParts(node.source, parts);
-        } else if ((isExportNamedDeclaration$1(node) || isImportDeclaration$1(node)) && node.specifiers?.length) {
+        } else if ((isExportNamedDeclaration$1(node) || isImportDeclaration(node)) && node.specifiers?.length) {
           for (const e of node.specifiers) gatherNodeParts(e, parts);
         } else if ((isExportDefaultDeclaration(node) || isExportNamedDeclaration$1(node)) && node.declaration) {
           gatherNodeParts(node.declaration, parts);
@@ -684,7 +836,7 @@ const collectorVisitor = {
         binding?.reference(path);
       } else if (isVariableDeclaration$1(declar)) {
         for (const decl of declar.declarations) {
-          for (const name of Object.keys(getBindingIdentifiers$1(decl))) {
+          for (const name of Object.keys(getBindingIdentifiers$3(decl))) {
             const binding = scope.getBinding(name);
             binding?.reference(path);
           }
@@ -827,7 +979,7 @@ class Scope {
     if (isThisExpression(node) || isSuper$1(node) || isTopicReference(node)) {
       return true;
     }
-    if (isIdentifier$6(node)) {
+    if (isIdentifier$5(node)) {
       const binding = this.getBinding(node.name);
       if (binding) {
         return binding.constant;
@@ -894,7 +1046,7 @@ class Scope {
     console.log(sep);
   }
   toArray(node, i, arrayLikeIsIterable) {
-    if (isIdentifier$6(node)) {
+    if (isIdentifier$5(node)) {
       const binding = this.getBinding(node.name);
       if (binding?.constant && binding.path.isGenericType("Array")) {
         return node;
@@ -903,7 +1055,7 @@ class Scope {
     if (isArrayExpression(node)) {
       return node;
     }
-    if (isIdentifier$6(node, {
+    if (isIdentifier$5(node, {
       name: "arguments"
     })) {
       return callExpression$3(memberExpression$1(memberExpression$1(memberExpression$1(identifier$3("Array"), identifier$3("prototype")), identifier$3("slice")), identifier$3("call")), [node]);
@@ -966,7 +1118,7 @@ class Scope {
     }
   }
   buildUndefinedNode() {
-    return buildUndefinedNode();
+    return buildUndefinedNode$1();
   }
   registerConstantViolation(path) {
     const ids = path.getBindingIdentifiers();
@@ -1027,7 +1179,7 @@ class Scope {
     return !!this.getProgramParent().references[name];
   }
   isPure(node, constantsOnly) {
-    if (isIdentifier$6(node)) {
+    if (isIdentifier$5(node)) {
       const binding = this.getBinding(node.name);
       if (!binding) return false;
       if (constantsOnly) return binding.constant;
@@ -1649,7 +1801,7 @@ const {
   tupleTypeAnnotation,
   unionTypeAnnotation,
   voidTypeAnnotation: voidTypeAnnotation$1,
-  isIdentifier: isIdentifier$5
+  isIdentifier: isIdentifier$4
 } = _t;
 function VariableDeclarator() {
   if (!this.get("id").isIdentifier()) return;
@@ -1764,7 +1916,7 @@ function CallExpression() {
   } = this.node;
   if (isObjectKeys(callee)) {
     return arrayTypeAnnotation(stringTypeAnnotation$1());
-  } else if (isArrayFrom(callee) || isObjectValues(callee) || isIdentifier$5(callee, {
+  } else if (isArrayFrom(callee) || isObjectValues(callee) || isIdentifier$4(callee, {
     name: "Array"
   })) {
     return arrayTypeAnnotation(anyTypeAnnotation$1());
@@ -1840,7 +1992,7 @@ const {
   isEmptyTypeAnnotation,
   isFlowBaseAnnotation,
   isGenericTypeAnnotation,
-  isIdentifier: isIdentifier$4,
+  isIdentifier: isIdentifier$3,
   isMixedTypeAnnotation,
   isNumberTypeAnnotation,
   isStringTypeAnnotation,
@@ -1959,9 +2111,9 @@ function isGenericType(genericName) {
       return true;
     }
   }
-  return isGenericTypeAnnotation(type) && isIdentifier$4(type.id, {
+  return isGenericTypeAnnotation(type) && isIdentifier$3(type.id, {
     name: genericName
-  }) || isTSTypeReference(type) && isIdentifier$4(type.typeName, {
+  }) || isTSTypeReference(type) && isIdentifier$3(type.typeName, {
     name: genericName
   });
 }
@@ -1982,19 +2134,27 @@ const {
   assignmentExpression: assignmentExpression$2,
   awaitExpression,
   blockStatement: blockStatement$2,
+  buildUndefinedNode,
   callExpression: callExpression$2,
   cloneNode: cloneNode$2,
+  conditionalExpression: conditionalExpression$1,
   expressionStatement: expressionStatement$2,
+  getBindingIdentifiers: getBindingIdentifiers$2,
   identifier: identifier$1,
   inheritLeadingComments,
   inheritTrailingComments,
   inheritsComments,
-  isExpression: isExpression$3,
+  isBlockStatement: isBlockStatement$1,
+  isEmptyStatement,
+  isExpression: isExpression$2,
+  isExpressionStatement,
+  isIfStatement,
   isProgram,
-  isStatement: isStatement$1,
+  isStatement,
+  isVariableDeclaration,
   removeComments,
   returnStatement: returnStatement$1,
-  toSequenceExpression,
+  sequenceExpression: sequenceExpression$1,
   validate: validate$1,
   yieldExpression
 } = _t;
@@ -2058,13 +2218,13 @@ function replaceWith(replacementPath) {
     throw new Error("Don't use `path.replaceWith()` with a source string, use `path.replaceWithSourceString()`");
   }
   let nodePath = "";
-  if (this.isNodeType("Statement") && isExpression$3(replacement)) {
+  if (this.isNodeType("Statement") && isExpression$2(replacement)) {
     if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) {
       replacement = expressionStatement$2(replacement);
       nodePath = "expression";
     }
   }
-  if (this.isNodeType("Expression") && isStatement$1(replacement)) {
+  if (this.isNodeType("Expression") && isStatement(replacement)) {
     if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) {
       return this.replaceExpressionWithStatements([replacement]);
     }
@@ -2095,9 +2255,13 @@ function _replaceWith(node) {
 }
 function replaceExpressionWithStatements(nodes) {
   this.resync();
-  const nodesAsSequenceExpression = toSequenceExpression(nodes, this.scope);
-  if (nodesAsSequenceExpression) {
-    return this.replaceWith(nodesAsSequenceExpression)[0].get("expressions");
+  const declars = [];
+  const nodesAsSingleExpression = gatherSequenceExpressions(nodes, declars);
+  if (nodesAsSingleExpression) {
+    for (const id of declars) this.scope.push({
+      id
+    });
+    return this.replaceWith(nodesAsSingleExpression)[0].get("expressions");
   }
   const functionParent = this.getFunctionParent();
   const isParentAsync = functionParent?.is("async");
@@ -2144,6 +2308,53 @@ function replaceExpressionWithStatements(nodes) {
   }
   return newCallee.get("body.body");
 }
+function gatherSequenceExpressions(nodes, declars) {
+  const exprs = [];
+  let ensureLastUndefined = true;
+  for (const node of nodes) {
+    if (!isEmptyStatement(node)) {
+      ensureLastUndefined = false;
+    }
+    if (isExpression$2(node)) {
+      exprs.push(node);
+    } else if (isExpressionStatement(node)) {
+      exprs.push(node.expression);
+    } else if (isVariableDeclaration(node)) {
+      if (node.kind !== "var") return;
+      for (const declar of node.declarations) {
+        const bindings = getBindingIdentifiers$2(declar);
+        for (const key of Object.keys(bindings)) {
+          declars.push(cloneNode$2(bindings[key]));
+        }
+        if (declar.init) {
+          exprs.push(assignmentExpression$2("=", declar.id, declar.init));
+        }
+      }
+      ensureLastUndefined = true;
+    } else if (isIfStatement(node)) {
+      const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], declars) : buildUndefinedNode();
+      const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], declars) : buildUndefinedNode();
+      if (!consequent || !alternate) return;
+      exprs.push(conditionalExpression$1(node.test, consequent, alternate));
+    } else if (isBlockStatement$1(node)) {
+      const body = gatherSequenceExpressions(node.body, declars);
+      if (!body) return;
+      exprs.push(body);
+    } else if (isEmptyStatement(node)) {
+      if (nodes.indexOf(node) === 0) {
+        ensureLastUndefined = true;
+      }
+    } else {
+      return;
+    }
+  }
+  if (ensureLastUndefined) exprs.push(buildUndefinedNode());
+  if (exprs.length === 1) {
+    return exprs[0];
+  } else {
+    return sequenceExpression$1(exprs);
+  }
+}
 function replaceInline(nodes) {
   this.resync();
   if (Array.isArray(nodes)) {
@@ -2460,7 +2671,10 @@ function _evaluate(path, state) {
       const property = callee.get("property");
       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;
@@ -2521,7 +2735,7 @@ const {
   conditionalExpression,
   expressionStatement: expressionStatement$1,
   identifier,
-  isIdentifier: isIdentifier$3,
+  isIdentifier: isIdentifier$2,
   jsxIdentifier,
   logicalExpression,
   LOGICAL_OPERATORS,
@@ -2549,7 +2763,7 @@ function toComputedKey() {
     throw new ReferenceError("todo");
   }
   if (!this.node.computed) {
-    if (isIdentifier$3(key)) key = stringLiteral(key.name);
+    if (isIdentifier$2(key)) key = stringLiteral(key.name);
   }
   return key;
 }
@@ -2971,8 +3185,8 @@ const {
   STATEMENT_OR_BLOCK_KEYS,
   VISITOR_KEYS: VISITOR_KEYS$3,
   isBlockStatement,
-  isExpression: isExpression$2,
-  isIdentifier: isIdentifier$2,
+  isExpression: isExpression$1,
+  isIdentifier: isIdentifier$1,
   isLiteral,
   isStringLiteral,
   isType,
@@ -3012,7 +3226,7 @@ function canSwapBetweenExpressionAndStatement(replacement) {
   if (this.isExpression()) {
     return isBlockStatement(replacement);
   } else if (this.isBlockStatement()) {
-    return isExpression$2(replacement);
+    return isExpression$1(replacement);
   }
   return false;
 }
@@ -3067,7 +3281,7 @@ function referencesImport(moduleSource, importName) {
   if (path.isImportNamespaceSpecifier() && importName === "*") {
     return true;
   }
-  if (path.isImportSpecifier() && isIdentifier$2(path.node.imported, {
+  if (path.isImportSpecifier() && isIdentifier$1(path.node.imported, {
     name: importName
   })) {
     return true;
@@ -3593,6 +3807,9 @@ const hooks = [function (self, parent) {
   }
 }];
 
+const {
+  getBindingIdentifiers: getBindingIdentifiers$1
+} = _t;
 function remove() {
   this._assertUnremoved();
   this.resync();
@@ -3608,7 +3825,7 @@ function remove() {
   this._markRemoved();
 }
 function _removeFromScope() {
-  const bindings = this.getBindingIdentifiers();
+  const bindings = getBindingIdentifiers$1(this.node, false, false, true);
   Object.keys(bindings).forEach(name => this.scope.removeBinding(name));
 }
 function _callRemovalHooks() {
@@ -3648,7 +3865,7 @@ var NodePath_removal = /*#__PURE__*/Object.freeze({
 });
 
 const {
-  react: react$1
+  react
 } = _t;
 const {
   cloneNode: cloneNode$1,
@@ -3658,7 +3875,7 @@ const {
 } = _t;
 const referenceVisitor = {
   ReferencedIdentifier(path, state) {
-    if (path.isJSXIdentifier() && react$1.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
+    if (path.isJSXIdentifier() && react.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
       return;
     }
     if (path.node.name === "this") {
@@ -3819,8 +4036,8 @@ const {
   isAssignmentExpression,
   isCallExpression,
   isExportNamedDeclaration,
-  isExpression: isExpression$1,
-  isIdentifier: isIdentifier$1,
+  isExpression,
+  isIdentifier,
   isSequenceExpression,
   isSuper,
   thisExpression
@@ -3881,7 +4098,7 @@ function isHiddenInSequenceExpression(path) {
   return isSequenceExpression(path.parent) && (last(path.parent.expressions) !== path.node || isHiddenInSequenceExpression(path.parentPath));
 }
 function isAlmostConstantAssignment(node, scope) {
-  if (!isAssignmentExpression(node) || !isIdentifier$1(node.left)) {
+  if (!isAssignmentExpression(node) || !isIdentifier(node.left)) {
     return false;
   }
   const blockScope = scope.getBlockParent();
@@ -3899,7 +4116,7 @@ function insertAfter(nodes_) {
   } = this;
   if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || isExportNamedDeclaration(parent) || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
     return parentPath.insertAfter(nodes.map(node => {
-      return isExpression$1(node) ? expressionStatement(node) : node;
+      return isExpression(node) ? expressionStatement(node) : node;
     }));
   } else if (this.isNodeType("Expression") && !this.isJSXElement() && !parentPath.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
     if (this.node) {
@@ -4387,12 +4604,10 @@ function shareCommentsWithSiblings() {
   }
 }
 function removeIfExisting(list, toRemove) {
-  if (!toRemove) return list;
-  let lastFoundIndex = -1;
+  if (!toRemove?.length) return list;
+  const set = new Set(toRemove);
   return list.filter(el => {
-    const i = toRemove.indexOf(el, lastFoundIndex);
-    if (i === -1) return true;
-    lastFoundIndex = i;
+    return !set.has(el);
   });
 }
 function addComment(type, content, line) {
@@ -4409,156 +4624,6 @@ var NodePath_comments = /*#__PURE__*/Object.freeze({
   shareCommentsWithSiblings: shareCommentsWithSiblings
 });
 
-const {
-  isBinding,
-  isBlockScoped: nodeIsBlockScoped,
-  isExportDeclaration,
-  isExpression: nodeIsExpression,
-  isFlow: nodeIsFlow,
-  isForStatement,
-  isForXStatement,
-  isIdentifier,
-  isImportDeclaration,
-  isImportSpecifier,
-  isJSXIdentifier,
-  isJSXMemberExpression,
-  isMemberExpression,
-  isRestElement: nodeIsRestElement,
-  isReferenced: nodeIsReferenced,
-  isScope: nodeIsScope,
-  isStatement: nodeIsStatement,
-  isVar: nodeIsVar,
-  isVariableDeclaration,
-  react,
-  isForOfStatement
-} = _t;
-const {
-  isCompatTag
-} = react;
-function isReferencedIdentifier(opts) {
-  const {
-    node,
-    parent
-  } = this;
-  if (!isIdentifier(node, opts) && !isJSXMemberExpression(parent, opts)) {
-    if (isJSXIdentifier(node, opts)) {
-      if (isCompatTag(node.name)) return false;
-    } else {
-      return false;
-    }
-  }
-  return nodeIsReferenced(node, parent, this.parentPath.parent);
-}
-function isReferencedMemberExpression() {
-  const {
-    node,
-    parent
-  } = this;
-  return isMemberExpression(node) && nodeIsReferenced(node, parent);
-}
-function isBindingIdentifier() {
-  const {
-    node,
-    parent
-  } = this;
-  const grandparent = this.parentPath.parent;
-  return isIdentifier(node) && isBinding(node, parent, grandparent);
-}
-function isStatement() {
-  const {
-    node,
-    parent
-  } = this;
-  if (nodeIsStatement(node)) {
-    if (isVariableDeclaration(node)) {
-      if (isForXStatement(parent, {
-        left: node
-      })) return false;
-      if (isForStatement(parent, {
-        init: node
-      })) return false;
-    }
-    return true;
-  } else {
-    return false;
-  }
-}
-function isExpression() {
-  if (this.isIdentifier()) {
-    return this.isReferencedIdentifier();
-  } else {
-    return nodeIsExpression(this.node);
-  }
-}
-function isScope() {
-  return nodeIsScope(this.node, this.parent);
-}
-function isReferenced() {
-  return nodeIsReferenced(this.node, this.parent);
-}
-function isBlockScoped() {
-  return nodeIsBlockScoped(this.node);
-}
-function isVar() {
-  return nodeIsVar(this.node);
-}
-function isUser() {
-  return this.node && !!this.node.loc;
-}
-function isGenerated() {
-  return !this.isUser();
-}
-function isPure(constantsOnly) {
-  return this.scope.isPure(this.node, constantsOnly);
-}
-function isFlow() {
-  const {
-    node
-  } = this;
-  if (nodeIsFlow(node)) {
-    return true;
-  } else if (isImportDeclaration(node)) {
-    return node.importKind === "type" || node.importKind === "typeof";
-  } else if (isExportDeclaration(node)) {
-    return node.exportKind === "type";
-  } else if (isImportSpecifier(node)) {
-    return node.importKind === "type" || node.importKind === "typeof";
-  } else {
-    return false;
-  }
-}
-function isRestProperty() {
-  return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectPattern();
-}
-function isSpreadProperty() {
-  return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectExpression();
-}
-function isForAwaitStatement() {
-  return isForOfStatement(this.node, {
-    await: true
-  });
-}
-
-var NodePath_virtual_types_validator = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isBindingIdentifier: isBindingIdentifier,
-  isBlockScoped: isBlockScoped,
-  isExpression: isExpression,
-  isFlow: isFlow,
-  isForAwaitStatement: isForAwaitStatement,
-  isGenerated: isGenerated,
-  isPure: isPure,
-  isReferenced: isReferenced,
-  isReferencedIdentifier: isReferencedIdentifier,
-  isReferencedMemberExpression: isReferencedMemberExpression,
-  isRestProperty: isRestProperty,
-  isScope: isScope,
-  isSpreadProperty: isSpreadProperty,
-  isStatement: isStatement,
-  isUser: isUser,
-  isVar: isVar
-});
-
 const {
   validate
 } = _t;