@babel/traverse 7.0.0-beta.5 → 7.0.0-beta.53

package/lib/scope/index.js

@@ -1,179 +1,221 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.default = void 0;
 
-var _includes = _interopRequireDefault(require("lodash/includes"));
+function _includes() {
+  const data = _interopRequireDefault(require("lodash/includes"));
 
-var _repeat = _interopRequireDefault(require("lodash/repeat"));
+  _includes = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _repeat() {
+  const data = _interopRequireDefault(require("lodash/repeat"));
+
+  _repeat = function () {
+    return data;
+  };
+
+  return data;
+}
 
 var _renamer = _interopRequireDefault(require("./lib/renamer"));
 
 var _index = _interopRequireDefault(require("../index"));
 
-var _defaults = _interopRequireDefault(require("lodash/defaults"));
+function _defaults() {
+  const data = _interopRequireDefault(require("lodash/defaults"));
 
-var _binding2 = _interopRequireDefault(require("./binding"));
+  _defaults = function () {
+    return data;
+  };
 
-var _globals = _interopRequireDefault(require("globals"));
+  return data;
+}
 
-var t = _interopRequireWildcard(require("@babel/types"));
+var _binding = _interopRequireDefault(require("./binding"));
 
-var _cache = require("../cache");
+function _globals() {
+  const data = _interopRequireDefault(require("globals"));
 
-var _class, _temp;
+  _globals = function () {
+    return data;
+  };
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+  return data;
+}
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function () {
+    return data;
+  };
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+  return data;
+}
+
+var _cache = require("../cache");
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
 
-var _crawlCallsCount = 0;
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function gatherNodeParts(node, parts) {
-  if (t.isModuleDeclaration(node)) {
+  if (t().isModuleDeclaration(node)) {
     if (node.source) {
       gatherNodeParts(node.source, parts);
     } else if (node.specifiers && node.specifiers.length) {
-      var _arr = node.specifiers;
-
-      for (var _i = 0; _i < _arr.length; _i++) {
-        var specifier = _arr[_i];
+      for (const specifier of node.specifiers) {
         gatherNodeParts(specifier, parts);
       }
     } else if (node.declaration) {
       gatherNodeParts(node.declaration, parts);
     }
-  } else if (t.isModuleSpecifier(node)) {
+  } else if (t().isModuleSpecifier(node)) {
     gatherNodeParts(node.local, parts);
-  } else if (t.isMemberExpression(node)) {
+  } else if (t().isMemberExpression(node)) {
     gatherNodeParts(node.object, parts);
     gatherNodeParts(node.property, parts);
-  } else if (t.isIdentifier(node)) {
+  } else if (t().isIdentifier(node)) {
     parts.push(node.name);
-  } else if (t.isLiteral(node)) {
+  } else if (t().isLiteral(node)) {
     parts.push(node.value);
-  } else if (t.isCallExpression(node)) {
+  } else if (t().isCallExpression(node)) {
     gatherNodeParts(node.callee, parts);
-  } else if (t.isObjectExpression(node) || t.isObjectPattern(node)) {
-    var _arr2 = node.properties;
-
-    for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
-      var prop = _arr2[_i2];
+  } else if (t().isObjectExpression(node) || t().isObjectPattern(node)) {
+    for (const prop of node.properties) {
       gatherNodeParts(prop.key || prop.argument, parts);
     }
+  } else if (t().isPrivateName(node)) {
+    gatherNodeParts(node.id, parts);
+  } else if (t().isThisExpression(node)) {
+    parts.push("this");
+  } else if (t().isSuper(node)) {
+    parts.push("super");
   }
 }
 
-var collectorVisitor = {
-  For: function For(path) {
-    var _arr3 = t.FOR_INIT_KEYS;
-
-    for (var _i3 = 0; _i3 < _arr3.length; _i3++) {
-      var key = _arr3[_i3];
-      var declar = path.get(key);
+const collectorVisitor = {
+  For(path) {
+    for (const key of t().FOR_INIT_KEYS) {
+      const declar = path.get(key);
 
       if (declar.isVar()) {
-        var parentScope = path.scope.getFunctionParent() || path.scope.getProgramParent();
+        const parentScope = path.scope.getFunctionParent() || path.scope.getProgramParent();
         parentScope.registerBinding("var", declar);
       }
     }
   },
-  Declaration: function Declaration(path) {
+
+  Declaration(path) {
     if (path.isBlockScoped()) return;
 
     if (path.isExportDeclaration() && path.get("declaration").isDeclaration()) {
       return;
     }
 
-    var parent = path.scope.getFunctionParent() || path.scope.getProgramParent();
+    const parent = path.scope.getFunctionParent() || path.scope.getProgramParent();
     parent.registerDeclaration(path);
   },
-  ReferencedIdentifier: function ReferencedIdentifier(path, state) {
+
+  ReferencedIdentifier(path, state) {
     state.references.push(path);
   },
-  ForXStatement: function ForXStatement(path, state) {
-    var left = path.get("left");
+
+  ForXStatement(path, state) {
+    const left = path.get("left");
 
     if (left.isPattern() || left.isIdentifier()) {
       state.constantViolations.push(path);
     }
   },
+
   ExportDeclaration: {
-    exit: function exit(path) {
-      var node = path.node,
-          scope = path.scope;
-      var declar = node.declaration;
-
-      if (t.isClassDeclaration(declar) || t.isFunctionDeclaration(declar)) {
-        var _id = declar.id;
-        if (!_id) return;
-        var binding = scope.getBinding(_id.name);
+    exit(path) {
+      const {
+        node,
+        scope
+      } = path;
+      const declar = node.declaration;
+
+      if (t().isClassDeclaration(declar) || t().isFunctionDeclaration(declar)) {
+        const id = declar.id;
+        if (!id) return;
+        const binding = scope.getBinding(id.name);
         if (binding) binding.reference(path);
-      } else if (t.isVariableDeclaration(declar)) {
-        var _arr4 = declar.declarations;
-
-        for (var _i4 = 0; _i4 < _arr4.length; _i4++) {
-          var decl = _arr4[_i4];
-          var ids = t.getBindingIdentifiers(decl);
+      } else if (t().isVariableDeclaration(declar)) {
+        for (const decl of declar.declarations) {
+          const ids = t().getBindingIdentifiers(decl);
 
-          for (var name in ids) {
-            var _binding = scope.getBinding(name);
-
-            if (_binding) _binding.reference(path);
+          for (const name in ids) {
+            const binding = scope.getBinding(name);
+            if (binding) binding.reference(path);
           }
         }
       }
     }
+
   },
-  LabeledStatement: function LabeledStatement(path) {
+
+  LabeledStatement(path) {
     path.scope.getProgramParent().addGlobal(path.node);
     path.scope.getBlockParent().registerDeclaration(path);
   },
-  AssignmentExpression: function AssignmentExpression(path, state) {
+
+  AssignmentExpression(path, state) {
     state.assignments.push(path);
   },
-  UpdateExpression: function UpdateExpression(path, state) {
+
+  UpdateExpression(path, state) {
     state.constantViolations.push(path);
   },
-  UnaryExpression: function UnaryExpression(path, state) {
+
+  UnaryExpression(path, state) {
     if (path.node.operator === "delete") {
       state.constantViolations.push(path);
     }
   },
-  BlockScoped: function BlockScoped(path) {
-    var scope = path.scope;
+
+  BlockScoped(path) {
+    let scope = path.scope;
     if (scope.path === path) scope = scope.parent;
     scope.getBlockParent().registerDeclaration(path);
   },
-  ClassDeclaration: function ClassDeclaration(path) {
-    var id = path.node.id;
+
+  ClassDeclaration(path) {
+    const id = path.node.id;
     if (!id) return;
-    var name = id.name;
+    const name = id.name;
     path.scope.bindings[name] = path.scope.getBinding(name);
   },
-  Block: function Block(path) {
-    var paths = path.get("body");
-    var _arr5 = paths;
 
-    for (var _i5 = 0; _i5 < _arr5.length; _i5++) {
-      var bodyPath = _arr5[_i5];
+  Block(path) {
+    const paths = path.get("body");
 
+    for (const bodyPath of paths) {
       if (bodyPath.isFunctionDeclaration()) {
         path.scope.getBlockParent().registerDeclaration(bodyPath);
       }
     }
   }
+
 };
-var uid = 0;
-var Scope = (_temp = _class = function () {
-  function Scope(path) {
-    var node = path.node;
+let uid = 0;
 
-    var cached = _cache.scope.get(node);
+class Scope {
+  constructor(path) {
+    const {
+      node
+    } = path;
+
+    const cached = _cache.scope.get(node);
 
     if (cached && cached.path === path) {
       return cached;
@@ -187,83 +229,86 @@ var Scope = (_temp = _class = function () {
     this.labels = new Map();
   }
 
-  var _proto = Scope.prototype;
+  get parent() {
+    const parent = this.path.findParent(p => p.isScope());
+    return parent && parent.scope;
+  }
 
-  _proto.traverse = function traverse(node, opts, state) {
-    (0, _index.default)(node, opts, this, state, this.path);
-  };
+  get parentBlock() {
+    return this.path.parent;
+  }
 
-  _proto.generateDeclaredUidIdentifier = function generateDeclaredUidIdentifier(name) {
-    if (name === void 0) {
-      name = "temp";
-    }
+  get hub() {
+    return this.path.hub;
+  }
+
+  traverse(node, opts, state) {
+    (0, _index.default)(node, opts, this, state, this.path);
+  }
 
-    var id = this.generateUidIdentifier(name);
+  generateDeclaredUidIdentifier(name) {
+    const id = this.generateUidIdentifier(name);
     this.push({
-      id: id
+      id
     });
-    return id;
-  };
-
-  _proto.generateUidIdentifier = function generateUidIdentifier(name) {
-    if (name === void 0) {
-      name = "temp";
-    }
-
-    return t.identifier(this.generateUid(name));
-  };
+    return t().cloneNode(id);
+  }
 
-  _proto.generateUid = function generateUid(name) {
-    if (name === void 0) {
-      name = "temp";
-    }
+  generateUidIdentifier(name) {
+    return t().identifier(this.generateUid(name));
+  }
 
-    name = t.toIdentifier(name).replace(/^_+/, "").replace(/[0-9]+$/g, "");
-    var uid;
-    var i = 0;
+  generateUid(name = "temp") {
+    name = t().toIdentifier(name).replace(/^_+/, "").replace(/[0-9]+$/g, "");
+    let uid;
+    let i = 0;
 
     do {
       uid = this._generateUid(name, i);
       i++;
     } while (this.hasLabel(uid) || this.hasBinding(uid) || this.hasGlobal(uid) || this.hasReference(uid));
 
-    var program = this.getProgramParent();
+    const program = this.getProgramParent();
     program.references[uid] = true;
     program.uids[uid] = true;
     return uid;
-  };
+  }
 
-  _proto._generateUid = function _generateUid(name, i) {
-    var id = name;
+  _generateUid(name, i) {
+    let id = name;
     if (i > 1) id += i;
-    return "_" + id;
-  };
+    return `_${id}`;
+  }
 
-  _proto.generateUidIdentifierBasedOnNode = function generateUidIdentifierBasedOnNode(parent, defaultName) {
-    var node = parent;
+  generateUidBasedOnNode(parent, defaultName) {
+    let node = parent;
 
-    if (t.isAssignmentExpression(parent)) {
+    if (t().isAssignmentExpression(parent)) {
       node = parent.left;
-    } else if (t.isVariableDeclarator(parent)) {
+    } else if (t().isVariableDeclarator(parent)) {
       node = parent.id;
-    } else if (t.isObjectProperty(node) || t.isObjectMethod(node)) {
+    } else if (t().isObjectProperty(node) || t().isObjectMethod(node)) {
       node = node.key;
     }
 
-    var parts = [];
+    const parts = [];
     gatherNodeParts(node, parts);
-    var id = parts.join("$");
+    let id = parts.join("$");
     id = id.replace(/^_/, "") || defaultName || "ref";
-    return this.generateUidIdentifier(id.slice(0, 20));
-  };
+    return this.generateUid(id.slice(0, 20));
+  }
 
-  _proto.isStatic = function isStatic(node) {
-    if (t.isThisExpression(node) || t.isSuper(node)) {
+  generateUidIdentifierBasedOnNode(parent, defaultName) {
+    return t().identifier(this.generateUidBasedOnNode(parent, defaultName));
+  }
+
+  isStatic(node) {
+    if (t().isThisExpression(node) || t().isSuper(node)) {
       return true;
     }
 
-    if (t.isIdentifier(node)) {
-      var binding = this.getBinding(node.name);
+    if (t().isIdentifier(node)) {
+      const binding = this.getBinding(node.name);
 
       if (binding) {
         return binding.constant;
@@ -273,58 +318,62 @@ var Scope = (_temp = _class = function () {
     }
 
     return false;
-  };
+  }
 
-  _proto.maybeGenerateMemoised = function maybeGenerateMemoised(node, dontPush) {
+  maybeGenerateMemoised(node, dontPush) {
     if (this.isStatic(node)) {
       return null;
     } else {
-      var _id2 = this.generateUidIdentifierBasedOnNode(node);
+      const id = this.generateUidIdentifierBasedOnNode(node);
+
+      if (!dontPush) {
+        this.push({
+          id
+        });
+        return t().cloneNode(id);
+      }
 
-      if (!dontPush) this.push({
-        id: _id2
-      });
-      return _id2;
+      return id;
     }
-  };
+  }
 
-  _proto.checkBlockScopedCollisions = function checkBlockScopedCollisions(local, kind, name, id) {
+  checkBlockScopedCollisions(local, kind, name, id) {
     if (kind === "param") return;
     if (local.kind === "local") return;
     if (kind === "hoisted" && local.kind === "let") return;
-    var duplicate = kind === "let" || local.kind === "let" || local.kind === "const" || local.kind === "module" || local.kind === "param" && (kind === "let" || kind === "const");
+    const duplicate = kind === "let" || local.kind === "let" || local.kind === "const" || local.kind === "module" || local.kind === "param" && (kind === "let" || kind === "const");
 
     if (duplicate) {
-      throw this.hub.file.buildCodeFrameError(id, "Duplicate declaration \"" + name + "\"", TypeError);
+      throw this.hub.file.buildCodeFrameError(id, `Duplicate declaration "${name}"`, TypeError);
     }
-  };
+  }
 
-  _proto.rename = function rename(oldName, newName, block) {
-    var binding = this.getBinding(oldName);
+  rename(oldName, newName, block) {
+    const binding = this.getBinding(oldName);
 
     if (binding) {
       newName = newName || this.generateUidIdentifier(oldName).name;
       return new _renamer.default(binding, oldName, newName).rename(block);
     }
-  };
+  }
 
-  _proto._renameFromMap = function _renameFromMap(map, oldName, newName, value) {
+  _renameFromMap(map, oldName, newName, value) {
     if (map[oldName]) {
       map[newName] = value;
       map[oldName] = null;
     }
-  };
+  }
 
-  _proto.dump = function dump() {
-    var sep = (0, _repeat.default)("-", 60);
+  dump() {
+    const sep = (0, _repeat().default)("-", 60);
     console.log(sep);
-    var scope = this;
+    let scope = this;
 
     do {
       console.log("#", scope.block.type);
 
-      for (var name in scope.bindings) {
-        var binding = scope.bindings[name];
+      for (const name in scope.bindings) {
+        const binding = scope.bindings[name];
         console.log(" -", name, {
           constant: binding.constant,
           references: binding.references,
@@ -335,157 +384,135 @@ var Scope = (_temp = _class = function () {
     } while (scope = scope.parent);
 
     console.log(sep);
-  };
+  }
 
-  _proto.toArray = function toArray(node, i) {
-    var file = this.hub.file;
+  toArray(node, i) {
+    const file = this.hub.file;
 
-    if (t.isIdentifier(node)) {
-      var binding = this.getBinding(node.name);
+    if (t().isIdentifier(node)) {
+      const binding = this.getBinding(node.name);
 
       if (binding && binding.constant && binding.path.isGenericType("Array")) {
         return node;
       }
     }
 
-    if (t.isArrayExpression(node)) {
+    if (t().isArrayExpression(node)) {
       return node;
     }
 
-    if (t.isIdentifier(node, {
+    if (t().isIdentifier(node, {
       name: "arguments"
     })) {
-      return t.callExpression(t.memberExpression(t.memberExpression(t.memberExpression(t.identifier("Array"), t.identifier("prototype")), t.identifier("slice")), t.identifier("call")), [node]);
+      return t().callExpression(t().memberExpression(t().memberExpression(t().memberExpression(t().identifier("Array"), t().identifier("prototype")), t().identifier("slice")), t().identifier("call")), [node]);
     }
 
-    var helperName = "toArray";
-    var args = [node];
+    let helperName;
+    const args = [node];
 
     if (i === true) {
       helperName = "toConsumableArray";
     } else if (i) {
-      args.push(t.numericLiteral(i));
+      args.push(t().numericLiteral(i));
       helperName = "slicedToArray";
+    } else {
+      helperName = "toArray";
     }
 
-    return t.callExpression(file.addHelper(helperName), args);
-  };
+    return t().callExpression(file.addHelper(helperName), args);
+  }
 
-  _proto.hasLabel = function hasLabel(name) {
+  hasLabel(name) {
     return !!this.getLabel(name);
-  };
+  }
 
-  _proto.getLabel = function getLabel(name) {
+  getLabel(name) {
     return this.labels.get(name);
-  };
+  }
 
-  _proto.registerLabel = function registerLabel(path) {
+  registerLabel(path) {
     this.labels.set(path.node.label.name, path);
-  };
+  }
 
-  _proto.registerDeclaration = function registerDeclaration(path) {
+  registerDeclaration(path) {
     if (path.isLabeledStatement()) {
       this.registerLabel(path);
     } else if (path.isFunctionDeclaration()) {
       this.registerBinding("hoisted", path.get("id"), path);
     } else if (path.isVariableDeclaration()) {
-      var declarations = path.get("declarations");
-      var _arr6 = declarations;
+      const declarations = path.get("declarations");
 
-      for (var _i6 = 0; _i6 < _arr6.length; _i6++) {
-        var declar = _arr6[_i6];
+      for (const declar of declarations) {
         this.registerBinding(path.node.kind, declar);
       }
     } else if (path.isClassDeclaration()) {
       this.registerBinding("let", path);
     } else if (path.isImportDeclaration()) {
-      var specifiers = path.get("specifiers");
-      var _arr7 = specifiers;
+      const specifiers = path.get("specifiers");
 
-      for (var _i7 = 0; _i7 < _arr7.length; _i7++) {
-        var specifier = _arr7[_i7];
+      for (const specifier of specifiers) {
         this.registerBinding("module", specifier);
       }
     } else if (path.isExportDeclaration()) {
-      var _declar = path.get("declaration");
+      const declar = path.get("declaration");
 
-      if (_declar.isClassDeclaration() || _declar.isFunctionDeclaration() || _declar.isVariableDeclaration()) {
-        this.registerDeclaration(_declar);
+      if (declar.isClassDeclaration() || declar.isFunctionDeclaration() || declar.isVariableDeclaration()) {
+        this.registerDeclaration(declar);
       }
     } else {
       this.registerBinding("unknown", path);
     }
-  };
+  }
 
-  _proto.buildUndefinedNode = function buildUndefinedNode() {
+  buildUndefinedNode() {
     if (this.hasBinding("undefined")) {
-      return t.unaryExpression("void", t.numericLiteral(0), true);
+      return t().unaryExpression("void", t().numericLiteral(0), true);
     } else {
-      return t.identifier("undefined");
+      return t().identifier("undefined");
     }
-  };
+  }
 
-  _proto.registerConstantViolation = function registerConstantViolation(path) {
-    var ids = path.getBindingIdentifiers();
+  registerConstantViolation(path) {
+    const ids = path.getBindingIdentifiers();
 
-    for (var name in ids) {
-      var binding = this.getBinding(name);
+    for (const name in ids) {
+      const binding = this.getBinding(name);
       if (binding) binding.reassign(path);
     }
-  };
-
-  _proto.registerBinding = function registerBinding(kind, path, bindingPath) {
-    if (bindingPath === void 0) {
-      bindingPath = path;
-    }
+  }
 
+  registerBinding(kind, path, bindingPath = path) {
     if (!kind) throw new ReferenceError("no `kind`");
 
     if (path.isVariableDeclaration()) {
-      var declarators = path.get("declarations");
-
-      for (var _iterator = declarators, _isArray = Array.isArray(_iterator), _i8 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
-        var _ref;
-
-        if (_isArray) {
-          if (_i8 >= _iterator.length) break;
-          _ref = _iterator[_i8++];
-        } else {
-          _i8 = _iterator.next();
-          if (_i8.done) break;
-          _ref = _i8.value;
-        }
+      const declarators = path.get("declarations");
 
-        var _declar2 = _ref;
-        this.registerBinding(kind, _declar2);
+      for (const declar of declarators) {
+        this.registerBinding(kind, declar);
       }
 
       return;
     }
 
-    var parent = this.getProgramParent();
-    var ids = path.getBindingIdentifiers(true);
-
-    for (var name in ids) {
-      var _arr8 = ids[name];
+    const parent = this.getProgramParent();
+    const ids = path.getBindingIdentifiers(true);
 
-      for (var _i9 = 0; _i9 < _arr8.length; _i9++) {
-        var _id3 = _arr8[_i9];
-        var local = this.getOwnBinding(name);
+    for (const name in ids) {
+      for (const id of ids[name]) {
+        const local = this.getOwnBinding(name);
 
         if (local) {
-          if (local.identifier === _id3) continue;
-          this.checkBlockScopedCollisions(local, kind, name, _id3);
+          if (local.identifier === id) continue;
+          this.checkBlockScopedCollisions(local, kind, name, id);
         }
 
-        if (local && local.path.isFlow()) local = null;
         parent.references[name] = true;
 
         if (local) {
           this.registerConstantViolation(bindingPath);
         } else {
-          this.bindings[name] = new _binding2.default({
-            identifier: _id3,
+          this.bindings[name] = new _binding.default({
+            identifier: id,
             scope: this,
             path: bindingPath,
             kind: kind
@@ -493,153 +520,124 @@ var Scope = (_temp = _class = function () {
         }
       }
     }
-  };
+  }
 
-  _proto.addGlobal = function addGlobal(node) {
+  addGlobal(node) {
     this.globals[node.name] = node;
-  };
+  }
 
-  _proto.hasUid = function hasUid(name) {
-    var scope = this;
+  hasUid(name) {
+    let scope = this;
 
     do {
       if (scope.uids[name]) return true;
     } while (scope = scope.parent);
 
     return false;
-  };
+  }
 
-  _proto.hasGlobal = function hasGlobal(name) {
-    var scope = this;
+  hasGlobal(name) {
+    let scope = this;
 
     do {
       if (scope.globals[name]) return true;
     } while (scope = scope.parent);
 
     return false;
-  };
+  }
 
-  _proto.hasReference = function hasReference(name) {
-    var scope = this;
+  hasReference(name) {
+    let scope = this;
 
     do {
       if (scope.references[name]) return true;
     } while (scope = scope.parent);
 
     return false;
-  };
+  }
 
-  _proto.isPure = function isPure(node, constantsOnly) {
-    if (t.isIdentifier(node)) {
-      var binding = this.getBinding(node.name);
+  isPure(node, constantsOnly) {
+    if (t().isIdentifier(node)) {
+      const binding = this.getBinding(node.name);
       if (!binding) return false;
       if (constantsOnly) return binding.constant;
       return true;
-    } else if (t.isClass(node)) {
+    } else if (t().isClass(node)) {
       if (node.superClass && !this.isPure(node.superClass, constantsOnly)) {
         return false;
       }
 
       return this.isPure(node.body, constantsOnly);
-    } else if (t.isClassBody(node)) {
-      for (var _iterator2 = node.body, _isArray2 = Array.isArray(_iterator2), _i10 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
-        var _ref2;
-
-        if (_isArray2) {
-          if (_i10 >= _iterator2.length) break;
-          _ref2 = _iterator2[_i10++];
-        } else {
-          _i10 = _iterator2.next();
-          if (_i10.done) break;
-          _ref2 = _i10.value;
-        }
-
-        var _method = _ref2;
-        if (!this.isPure(_method, constantsOnly)) return false;
+    } else if (t().isClassBody(node)) {
+      for (const method of node.body) {
+        if (!this.isPure(method, constantsOnly)) return false;
       }
 
       return true;
-    } else if (t.isBinary(node)) {
+    } else if (t().isBinary(node)) {
       return this.isPure(node.left, constantsOnly) && this.isPure(node.right, constantsOnly);
-    } else if (t.isArrayExpression(node)) {
-      var _arr9 = node.elements;
-
-      for (var _i11 = 0; _i11 < _arr9.length; _i11++) {
-        var elem = _arr9[_i11];
+    } else if (t().isArrayExpression(node)) {
+      for (const elem of node.elements) {
         if (!this.isPure(elem, constantsOnly)) return false;
       }
 
       return true;
-    } else if (t.isObjectExpression(node)) {
-      var _arr10 = node.properties;
-
-      for (var _i12 = 0; _i12 < _arr10.length; _i12++) {
-        var prop = _arr10[_i12];
+    } else if (t().isObjectExpression(node)) {
+      for (const prop of node.properties) {
         if (!this.isPure(prop, constantsOnly)) return false;
       }
 
       return true;
-    } else if (t.isClassMethod(node)) {
+    } else if (t().isClassMethod(node)) {
       if (node.computed && !this.isPure(node.key, constantsOnly)) return false;
       if (node.kind === "get" || node.kind === "set") return false;
       return true;
-    } else if (t.isClassProperty(node) || t.isObjectProperty(node)) {
+    } else if (t().isProperty(node)) {
       if (node.computed && !this.isPure(node.key, constantsOnly)) return false;
       return this.isPure(node.value, constantsOnly);
-    } else if (t.isUnaryExpression(node)) {
+    } else if (t().isUnaryExpression(node)) {
       return this.isPure(node.argument, constantsOnly);
-    } else if (t.isTaggedTemplateExpression(node)) {
-      return t.matchesPattern(node.tag, "String.raw") && !this.hasBinding("String", true) && this.isPure(node.quasi, constantsOnly);
-    } else if (t.isTemplateLiteral(node)) {
-      var _arr11 = node.expressions;
-
-      for (var _i13 = 0; _i13 < _arr11.length; _i13++) {
-        var expression = _arr11[_i13];
+    } else if (t().isTaggedTemplateExpression(node)) {
+      return t().matchesPattern(node.tag, "String.raw") && !this.hasBinding("String", true) && this.isPure(node.quasi, constantsOnly);
+    } else if (t().isTemplateLiteral(node)) {
+      for (const expression of node.expressions) {
         if (!this.isPure(expression, constantsOnly)) return false;
       }
 
       return true;
     } else {
-      return t.isPureish(node);
+      return t().isPureish(node);
     }
-  };
+  }
 
-  _proto.setData = function setData(key, val) {
+  setData(key, val) {
     return this.data[key] = val;
-  };
+  }
 
-  _proto.getData = function getData(key) {
-    var scope = this;
+  getData(key) {
+    let scope = this;
 
     do {
-      var data = scope.data[key];
+      const data = scope.data[key];
       if (data != null) return data;
     } while (scope = scope.parent);
-  };
+  }
 
-  _proto.removeData = function removeData(key) {
-    var scope = this;
+  removeData(key) {
+    let scope = this;
 
     do {
-      var data = scope.data[key];
+      const data = scope.data[key];
       if (data != null) scope.data[key] = null;
     } while (scope = scope.parent);
-  };
+  }
 
-  _proto.init = function init() {
+  init() {
     if (!this.references) this.crawl();
-  };
-
-  _proto.crawl = function crawl() {
-    _crawlCallsCount++;
-
-    this._crawl();
-
-    _crawlCallsCount--;
-  };
+  }
 
-  _proto._crawl = function _crawl() {
-    var path = this.path;
+  crawl() {
+    const path = this.path;
     this.references = Object.create(null);
     this.bindings = Object.create(null);
     this.globals = Object.create(null);
@@ -647,44 +645,29 @@ var Scope = (_temp = _class = function () {
     this.data = Object.create(null);
 
     if (path.isLoop()) {
-      var _arr12 = t.FOR_INIT_KEYS;
-
-      for (var _i14 = 0; _i14 < _arr12.length; _i14++) {
-        var key = _arr12[_i14];
-        var node = path.get(key);
+      for (const key of t().FOR_INIT_KEYS) {
+        const node = path.get(key);
         if (node.isBlockScoped()) this.registerBinding(node.node.kind, node);
       }
     }
 
     if (path.isFunctionExpression() && path.has("id")) {
-      if (!path.get("id").node[t.NOT_LOCAL_BINDING]) {
+      if (!path.get("id").node[t().NOT_LOCAL_BINDING]) {
         this.registerBinding("local", path.get("id"), path);
       }
     }
 
     if (path.isClassExpression() && path.has("id")) {
-      if (!path.get("id").node[t.NOT_LOCAL_BINDING]) {
+      if (!path.get("id").node[t().NOT_LOCAL_BINDING]) {
         this.registerBinding("local", path);
       }
     }
 
     if (path.isFunction()) {
-      var params = path.get("params");
-
-      for (var _iterator3 = params, _isArray3 = Array.isArray(_iterator3), _i15 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
-        var _ref3;
-
-        if (_isArray3) {
-          if (_i15 >= _iterator3.length) break;
-          _ref3 = _iterator3[_i15++];
-        } else {
-          _i15 = _iterator3.next();
-          if (_i15.done) break;
-          _ref3 = _i15.value;
-        }
+      const params = path.get("params");
 
-        var _param = _ref3;
-        this.registerBinding("param", _param);
+      for (const param of params) {
+        this.registerBinding("param", param);
       }
     }
 
@@ -692,9 +675,9 @@ var Scope = (_temp = _class = function () {
       this.registerBinding("let", path);
     }
 
-    var parent = this.getProgramParent();
+    const parent = this.getProgramParent();
     if (parent.crawling) return;
-    var state = {
+    const state = {
       references: [],
       constantViolations: [],
       assignments: []
@@ -703,76 +686,36 @@ var Scope = (_temp = _class = function () {
     path.traverse(collectorVisitor, state);
     this.crawling = false;
 
-    for (var _iterator4 = state.assignments, _isArray4 = Array.isArray(_iterator4), _i16 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
-      var _ref4;
-
-      if (_isArray4) {
-        if (_i16 >= _iterator4.length) break;
-        _ref4 = _iterator4[_i16++];
-      } else {
-        _i16 = _iterator4.next();
-        if (_i16.done) break;
-        _ref4 = _i16.value;
-      }
-
-      var _path3 = _ref4;
-
-      var ids = _path3.getBindingIdentifiers();
+    for (const path of state.assignments) {
+      const ids = path.getBindingIdentifiers();
+      let programParent;
 
-      var programParent = void 0;
-
-      for (var name in ids) {
-        if (_path3.scope.getBinding(name)) continue;
-        programParent = programParent || _path3.scope.getProgramParent();
+      for (const name in ids) {
+        if (path.scope.getBinding(name)) continue;
+        programParent = programParent || path.scope.getProgramParent();
         programParent.addGlobal(ids[name]);
       }
 
-      _path3.scope.registerConstantViolation(_path3);
+      path.scope.registerConstantViolation(path);
     }
 
-    for (var _iterator5 = state.references, _isArray5 = Array.isArray(_iterator5), _i17 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
-      var _ref5;
-
-      if (_isArray5) {
-        if (_i17 >= _iterator5.length) break;
-        _ref5 = _iterator5[_i17++];
-      } else {
-        _i17 = _iterator5.next();
-        if (_i17.done) break;
-        _ref5 = _i17.value;
-      }
-
-      var _ref7 = _ref5;
-
-      var binding = _ref7.scope.getBinding(_ref7.node.name);
+    for (const ref of state.references) {
+      const binding = ref.scope.getBinding(ref.node.name);
 
       if (binding) {
-        binding.reference(_ref7);
+        binding.reference(ref);
       } else {
-        _ref7.scope.getProgramParent().addGlobal(_ref7.node);
+        ref.scope.getProgramParent().addGlobal(ref.node);
       }
     }
 
-    for (var _iterator6 = state.constantViolations, _isArray6 = Array.isArray(_iterator6), _i18 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
-      var _ref6;
-
-      if (_isArray6) {
-        if (_i18 >= _iterator6.length) break;
-        _ref6 = _iterator6[_i18++];
-      } else {
-        _i18 = _iterator6.next();
-        if (_i18.done) break;
-        _ref6 = _i18.value;
-      }
-
-      var _path4 = _ref6;
-
-      _path4.scope.registerConstantViolation(_path4);
+    for (const path of state.constantViolations) {
+      path.scope.registerConstantViolation(path);
     }
-  };
+  }
 
-  _proto.push = function push(opts) {
-    var path = this.path;
+  push(opts) {
+    let path = this.path;
 
     if (!path.isBlockStatement() && !path.isProgram()) {
       path = this.getBlockParent().path;
@@ -787,29 +730,26 @@ var Scope = (_temp = _class = function () {
       path = path.get("body");
     }
 
-    var unique = opts.unique;
-    var kind = opts.kind || "var";
-    var blockHoist = opts._blockHoist == null ? 2 : opts._blockHoist;
-    var dataKey = "declaration:" + kind + ":" + blockHoist;
-    var declarPath = !unique && path.getData(dataKey);
+    const unique = opts.unique;
+    const kind = opts.kind || "var";
+    const blockHoist = opts._blockHoist == null ? 2 : opts._blockHoist;
+    const dataKey = `declaration:${kind}:${blockHoist}`;
+    let declarPath = !unique && path.getData(dataKey);
 
     if (!declarPath) {
-      var declar = t.variableDeclaration(kind, []);
+      const declar = t().variableDeclaration(kind, []);
       declar._blockHoist = blockHoist;
-
-      var _path$unshiftContaine = path.unshiftContainer("body", [declar]);
-
-      declarPath = _path$unshiftContaine[0];
+      [declarPath] = path.unshiftContainer("body", [declar]);
       if (!unique) path.setData(dataKey, declarPath);
     }
 
-    var declarator = t.variableDeclarator(opts.id, opts.init);
+    const declarator = t().variableDeclarator(opts.id, opts.init);
     declarPath.node.declarations.push(declarator);
     this.registerBinding(kind, declarPath.get("declarations").pop());
-  };
+  }
 
-  _proto.getProgramParent = function getProgramParent() {
-    var scope = this;
+  getProgramParent() {
+    let scope = this;
 
     do {
       if (scope.path.isProgram()) {
@@ -818,10 +758,10 @@ var Scope = (_temp = _class = function () {
     } while (scope = scope.parent);
 
     throw new Error("Couldn't find a Program");
-  };
+  }
 
-  _proto.getFunctionParent = function getFunctionParent() {
-    var scope = this;
+  getFunctionParent() {
+    let scope = this;
 
     do {
       if (scope.path.isFunctionParent()) {
@@ -830,10 +770,10 @@ var Scope = (_temp = _class = function () {
     } while (scope = scope.parent);
 
     return null;
-  };
+  }
 
-  _proto.getBlockParent = function getBlockParent() {
-    var scope = this;
+  getBlockParent() {
+    let scope = this;
 
     do {
       if (scope.path.isBlockParent()) {
@@ -842,31 +782,29 @@ var Scope = (_temp = _class = function () {
     } while (scope = scope.parent);
 
     throw new Error("We couldn't find a BlockStatement, For, Switch, Function, Loop or Program...");
-  };
+  }
 
-  _proto.getAllBindings = function getAllBindings() {
-    var ids = Object.create(null);
-    var scope = this;
+  getAllBindings() {
+    const ids = Object.create(null);
+    let scope = this;
 
     do {
-      (0, _defaults.default)(ids, scope.bindings);
+      (0, _defaults().default)(ids, scope.bindings);
       scope = scope.parent;
     } while (scope);
 
     return ids;
-  };
+  }
 
-  _proto.getAllBindingsOfKind = function getAllBindingsOfKind() {
-    var ids = Object.create(null);
-    var _arr13 = arguments;
+  getAllBindingsOfKind() {
+    const ids = Object.create(null);
 
-    for (var _i19 = 0; _i19 < _arr13.length; _i19++) {
-      var kind = _arr13[_i19];
-      var scope = this;
+    for (const kind of arguments) {
+      let scope = this;
 
       do {
-        for (var name in scope.bindings) {
-          var binding = scope.bindings[name];
+        for (const name in scope.bindings) {
+          const binding = scope.bindings[name];
           if (binding.kind === kind) ids[name] = binding;
         }
 
@@ -875,121 +813,85 @@ var Scope = (_temp = _class = function () {
     }
 
     return ids;
-  };
+  }
 
-  _proto.bindingIdentifierEquals = function bindingIdentifierEquals(name, node) {
+  bindingIdentifierEquals(name, node) {
     return this.getBindingIdentifier(name) === node;
-  };
-
-  _proto.warnOnFlowBinding = function warnOnFlowBinding(binding) {
-    if (_crawlCallsCount === 0 && binding && binding.path.isFlow()) {
-      console.warn("\n        You or one of the Babel plugins you are using are using Flow declarations as bindings.\n        Support for this will be removed in version 7. To find out the caller, grep for this\n        message and change it to a `console.trace()`.\n      ");
-    }
-
-    return binding;
-  };
+  }
 
-  _proto.getBinding = function getBinding(name) {
-    var scope = this;
+  getBinding(name) {
+    let scope = this;
 
     do {
-      var binding = scope.getOwnBinding(name);
-      if (binding) return this.warnOnFlowBinding(binding);
+      const binding = scope.getOwnBinding(name);
+      if (binding) return binding;
     } while (scope = scope.parent);
-  };
+  }
 
-  _proto.getOwnBinding = function getOwnBinding(name) {
-    return this.warnOnFlowBinding(this.bindings[name]);
-  };
+  getOwnBinding(name) {
+    return this.bindings[name];
+  }
 
-  _proto.getBindingIdentifier = function getBindingIdentifier(name) {
-    var info = this.getBinding(name);
+  getBindingIdentifier(name) {
+    const info = this.getBinding(name);
     return info && info.identifier;
-  };
+  }
 
-  _proto.getOwnBindingIdentifier = function getOwnBindingIdentifier(name) {
-    var binding = this.bindings[name];
+  getOwnBindingIdentifier(name) {
+    const binding = this.bindings[name];
     return binding && binding.identifier;
-  };
+  }
 
-  _proto.hasOwnBinding = function hasOwnBinding(name) {
+  hasOwnBinding(name) {
     return !!this.getOwnBinding(name);
-  };
+  }
 
-  _proto.hasBinding = function hasBinding(name, noGlobals) {
+  hasBinding(name, noGlobals) {
     if (!name) return false;
     if (this.hasOwnBinding(name)) return true;
     if (this.parentHasBinding(name, noGlobals)) return true;
     if (this.hasUid(name)) return true;
-    if (!noGlobals && (0, _includes.default)(Scope.globals, name)) return true;
-    if (!noGlobals && (0, _includes.default)(Scope.contextVariables, name)) return true;
+    if (!noGlobals && (0, _includes().default)(Scope.globals, name)) return true;
+    if (!noGlobals && (0, _includes().default)(Scope.contextVariables, name)) return true;
     return false;
-  };
+  }
 
-  _proto.parentHasBinding = function parentHasBinding(name, noGlobals) {
+  parentHasBinding(name, noGlobals) {
     return this.parent && this.parent.hasBinding(name, noGlobals);
-  };
+  }
 
-  _proto.moveBindingTo = function moveBindingTo(name, scope) {
-    var info = this.getBinding(name);
+  moveBindingTo(name, scope) {
+    const info = this.getBinding(name);
 
     if (info) {
       info.scope.removeOwnBinding(name);
       info.scope = scope;
       scope.bindings[name] = info;
     }
-  };
+  }
 
-  _proto.removeOwnBinding = function removeOwnBinding(name) {
+  removeOwnBinding(name) {
     delete this.bindings[name];
-  };
+  }
 
-  _proto.removeBinding = function removeBinding(name) {
-    var info = this.getBinding(name);
+  removeBinding(name) {
+    const info = this.getBinding(name);
 
     if (info) {
       info.scope.removeOwnBinding(name);
     }
 
-    var scope = this;
+    let scope = this;
 
     do {
       if (scope.uids[name]) {
         scope.uids[name] = false;
       }
     } while (scope = scope.parent);
-  };
+  }
+
+}
 
-  _createClass(Scope, [{
-    key: "parent",
-    get: function get() {
-      var parent = this.path.findParent(function (p) {
-        return p.isScope();
-      });
-      return parent && parent.scope;
-    }
-  }, {
-    key: "parentBlock",
-    get: function get() {
-      return this.path.parent;
-    }
-  }, {
-    key: "hub",
-    get: function get() {
-      return this.path.hub;
-    }
-  }]);
-
-  return Scope;
-}(), Object.defineProperty(_class, "globals", {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  value: Object.keys(_globals.default.builtin)
-}), Object.defineProperty(_class, "contextVariables", {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  value: ["arguments", "undefined", "Infinity", "NaN"]
-}), _temp);
-exports.default = Scope;
+exports.default = Scope;
+Scope.globals = Object.keys(_globals().default.builtin);
+Scope.contextVariables = ["arguments", "undefined", "Infinity", "NaN"];