@babel/traverse 7.0.0-beta.43 → 7.0.0-beta.44

package/lib/scope/index.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 
 function _includes() {
-  const data = _interopRequireDefault(require("lodash/includes"));
+  var data = _interopRequireDefault(require("lodash/includes"));
 
-  _includes = function () {
+  _includes = function _includes() {
     return data;
   };
 
@@ -16,9 +16,9 @@ function _includes() {
 }
 
 function _repeat() {
-  const data = _interopRequireDefault(require("lodash/repeat"));
+  var data = _interopRequireDefault(require("lodash/repeat"));
 
-  _repeat = function () {
+  _repeat = function _repeat() {
     return data;
   };
 
@@ -30,21 +30,21 @@ var _renamer = _interopRequireDefault(require("./lib/renamer"));
 var _index = _interopRequireDefault(require("../index"));
 
 function _defaults() {
-  const data = _interopRequireDefault(require("lodash/defaults"));
+  var data = _interopRequireDefault(require("lodash/defaults"));
 
-  _defaults = function () {
+  _defaults = function _defaults() {
     return data;
   };
 
   return data;
 }
 
-var _binding = _interopRequireDefault(require("./binding"));
+var _binding2 = _interopRequireDefault(require("./binding"));
 
 function _globals() {
-  const data = _interopRequireDefault(require("globals"));
+  var data = _interopRequireDefault(require("globals"));
 
-  _globals = function () {
+  _globals = function _globals() {
     return data;
   };
 
@@ -52,9 +52,9 @@ function _globals() {
 }
 
 function t() {
-  const data = _interopRequireWildcard(require("@babel/types"));
+  var data = _interopRequireWildcard(require("@babel/types"));
 
-  t = function () {
+  t = function t() {
     return data;
   };
 
@@ -67,12 +67,19 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+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); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
 function gatherNodeParts(node, parts) {
   if (t().isModuleDeclaration(node)) {
     if (node.source) {
       gatherNodeParts(node.source, parts);
     } else if (node.specifiers && node.specifiers.length) {
-      for (const specifier of node.specifiers) {
+      var _arr = node.specifiers;
+
+      for (var _i = 0; _i < _arr.length; _i++) {
+        var specifier = _arr[_i];
         gatherNodeParts(specifier, parts);
       }
     } else if (node.declaration) {
@@ -90,126 +97,122 @@ function gatherNodeParts(node, parts) {
   } else if (t().isCallExpression(node)) {
     gatherNodeParts(node.callee, parts);
   } else if (t().isObjectExpression(node) || t().isObjectPattern(node)) {
-    for (const prop of node.properties) {
+    var _arr2 = node.properties;
+
+    for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
+      var prop = _arr2[_i2];
       gatherNodeParts(prop.key || prop.argument, parts);
     }
   }
 }
 
-const collectorVisitor = {
-  For(path) {
-    for (const key of t().FOR_INIT_KEYS) {
-      const declar = path.get(key);
+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);
 
       if (declar.isVar()) {
-        const parentScope = path.scope.getFunctionParent() || path.scope.getProgramParent();
+        var parentScope = path.scope.getFunctionParent() || path.scope.getProgramParent();
         parentScope.registerBinding("var", declar);
       }
     }
   },
-
-  Declaration(path) {
+  Declaration: function Declaration(path) {
     if (path.isBlockScoped()) return;
 
     if (path.isExportDeclaration() && path.get("declaration").isDeclaration()) {
       return;
     }
 
-    const parent = path.scope.getFunctionParent() || path.scope.getProgramParent();
+    var parent = path.scope.getFunctionParent() || path.scope.getProgramParent();
     parent.registerDeclaration(path);
   },
-
-  ReferencedIdentifier(path, state) {
+  ReferencedIdentifier: function ReferencedIdentifier(path, state) {
     state.references.push(path);
   },
-
-  ForXStatement(path, state) {
-    const left = path.get("left");
+  ForXStatement: function ForXStatement(path, state) {
+    var left = path.get("left");
 
     if (left.isPattern() || left.isIdentifier()) {
       state.constantViolations.push(path);
     }
   },
-
   ExportDeclaration: {
-    exit(path) {
-      const {
-        node,
-        scope
-      } = path;
-      const declar = node.declaration;
+    exit: function exit(path) {
+      var node = path.node,
+          scope = path.scope;
+      var declar = node.declaration;
 
       if (t().isClassDeclaration(declar) || t().isFunctionDeclaration(declar)) {
-        const id = declar.id;
-        if (!id) return;
-        const binding = scope.getBinding(id.name);
+        var _id = declar.id;
+        if (!_id) return;
+        var binding = scope.getBinding(_id.name);
         if (binding) binding.reference(path);
       } else if (t().isVariableDeclaration(declar)) {
-        for (const decl of declar.declarations) {
-          const ids = t().getBindingIdentifiers(decl);
+        var _arr4 = declar.declarations;
+
+        for (var _i4 = 0; _i4 < _arr4.length; _i4++) {
+          var decl = _arr4[_i4];
+          var ids = t().getBindingIdentifiers(decl);
+
+          for (var name in ids) {
+            var _binding = scope.getBinding(name);
 
-          for (const name in ids) {
-            const binding = scope.getBinding(name);
-            if (binding) binding.reference(path);
+            if (_binding) _binding.reference(path);
           }
         }
       }
     }
-
   },
-
-  LabeledStatement(path) {
+  LabeledStatement: function LabeledStatement(path) {
     path.scope.getProgramParent().addGlobal(path.node);
     path.scope.getBlockParent().registerDeclaration(path);
   },
-
-  AssignmentExpression(path, state) {
+  AssignmentExpression: function AssignmentExpression(path, state) {
     state.assignments.push(path);
   },
-
-  UpdateExpression(path, state) {
+  UpdateExpression: function UpdateExpression(path, state) {
     state.constantViolations.push(path);
   },
-
-  UnaryExpression(path, state) {
+  UnaryExpression: function UnaryExpression(path, state) {
     if (path.node.operator === "delete") {
       state.constantViolations.push(path);
     }
   },
-
-  BlockScoped(path) {
-    let scope = path.scope;
+  BlockScoped: function BlockScoped(path) {
+    var scope = path.scope;
     if (scope.path === path) scope = scope.parent;
     scope.getBlockParent().registerDeclaration(path);
   },
-
-  ClassDeclaration(path) {
-    const id = path.node.id;
+  ClassDeclaration: function ClassDeclaration(path) {
+    var id = path.node.id;
     if (!id) return;
-    const name = id.name;
+    var name = id.name;
     path.scope.bindings[name] = path.scope.getBinding(name);
   },
+  Block: function Block(path) {
+    var paths = path.get("body");
+    var _arr5 = paths;
 
-  Block(path) {
-    const paths = path.get("body");
+    for (var _i5 = 0; _i5 < _arr5.length; _i5++) {
+      var bodyPath = _arr5[_i5];
 
-    for (const bodyPath of paths) {
       if (bodyPath.isFunctionDeclaration()) {
         path.scope.getBlockParent().registerDeclaration(bodyPath);
       }
     }
   }
-
 };
-let uid = 0;
+var uid = 0;
 
-class Scope {
-  constructor(path) {
-    const {
-      node
-    } = path;
+var Scope = function () {
+  function Scope(path) {
+    var node = path.node;
 
-    const cached = _cache.scope.get(node);
+    var cached = _cache.scope.get(node);
 
     if (cached && cached.path === path) {
       return cached;
@@ -223,59 +226,52 @@ class Scope {
     this.labels = new Map();
   }
 
-  get parent() {
-    const parent = this.path.findParent(p => p.isScope());
-    return parent && parent.scope;
-  }
+  var _proto = Scope.prototype;
 
-  get parentBlock() {
-    return this.path.parent;
-  }
-
-  get hub() {
-    return this.path.hub;
-  }
-
-  traverse(node, opts, state) {
+  _proto.traverse = function traverse(node, opts, state) {
     (0, _index.default)(node, opts, this, state, this.path);
-  }
+  };
 
-  generateDeclaredUidIdentifier(name) {
-    const id = this.generateUidIdentifier(name);
+  _proto.generateDeclaredUidIdentifier = function generateDeclaredUidIdentifier(name) {
+    var id = this.generateUidIdentifier(name);
     this.push({
-      id
+      id: id
     });
     return t().cloneNode(id);
-  }
+  };
 
-  generateUidIdentifier(name) {
+  _proto.generateUidIdentifier = function generateUidIdentifier(name) {
     return t().identifier(this.generateUid(name));
-  }
+  };
+
+  _proto.generateUid = function generateUid(name) {
+    if (name === void 0) {
+      name = "temp";
+    }
 
-  generateUid(name = "temp") {
     name = t().toIdentifier(name).replace(/^_+/, "").replace(/[0-9]+$/g, "");
-    let uid;
-    let i = 0;
+    var uid;
+    var i = 0;
 
     do {
       uid = this._generateUid(name, i);
       i++;
     } while (this.hasLabel(uid) || this.hasBinding(uid) || this.hasGlobal(uid) || this.hasReference(uid));
 
-    const program = this.getProgramParent();
+    var program = this.getProgramParent();
     program.references[uid] = true;
     program.uids[uid] = true;
     return uid;
-  }
+  };
 
-  _generateUid(name, i) {
-    let id = name;
+  _proto._generateUid = function _generateUid(name, i) {
+    var id = name;
     if (i > 1) id += i;
-    return `_${id}`;
-  }
+    return "_" + id;
+  };
 
-  generateUidBasedOnNode(parent, defaultName) {
-    let node = parent;
+  _proto.generateUidBasedOnNode = function generateUidBasedOnNode(parent, defaultName) {
+    var node = parent;
 
     if (t().isAssignmentExpression(parent)) {
       node = parent.left;
@@ -285,24 +281,24 @@ class Scope {
       node = node.key;
     }
 
-    const parts = [];
+    var parts = [];
     gatherNodeParts(node, parts);
-    let id = parts.join("$");
+    var id = parts.join("$");
     id = id.replace(/^_/, "") || defaultName || "ref";
     return this.generateUid(id.slice(0, 20));
-  }
+  };
 
-  generateUidIdentifierBasedOnNode(parent, defaultName) {
+  _proto.generateUidIdentifierBasedOnNode = function generateUidIdentifierBasedOnNode(parent, defaultName) {
     return t().identifier(this.generateUidBasedOnNode(parent, defaultName));
-  }
+  };
 
-  isStatic(node) {
+  _proto.isStatic = function isStatic(node) {
     if (t().isThisExpression(node) || t().isSuper(node)) {
       return true;
     }
 
     if (t().isIdentifier(node)) {
-      const binding = this.getBinding(node.name);
+      var binding = this.getBinding(node.name);
 
       if (binding) {
         return binding.constant;
@@ -312,62 +308,62 @@ class Scope {
     }
 
     return false;
-  }
+  };
 
-  maybeGenerateMemoised(node, dontPush) {
+  _proto.maybeGenerateMemoised = function maybeGenerateMemoised(node, dontPush) {
     if (this.isStatic(node)) {
       return null;
     } else {
-      const id = this.generateUidIdentifierBasedOnNode(node);
+      var _id2 = this.generateUidIdentifierBasedOnNode(node);
 
       if (!dontPush) {
         this.push({
-          id
+          id: _id2
         });
-        return t().cloneNode(id);
+        return t().cloneNode(_id2);
       }
 
-      return id;
+      return _id2;
     }
-  }
+  };
 
-  checkBlockScopedCollisions(local, kind, name, id) {
+  _proto.checkBlockScopedCollisions = function checkBlockScopedCollisions(local, kind, name, id) {
     if (kind === "param") return;
     if (local.kind === "local") return;
     if (kind === "hoisted" && local.kind === "let") return;
-    const duplicate = kind === "let" || local.kind === "let" || local.kind === "const" || local.kind === "module" || local.kind === "param" && (kind === "let" || kind === "const");
+    var 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);
     }
-  }
+  };
 
-  rename(oldName, newName, block) {
-    const binding = this.getBinding(oldName);
+  _proto.rename = function rename(oldName, newName, block) {
+    var binding = this.getBinding(oldName);
 
     if (binding) {
       newName = newName || this.generateUidIdentifier(oldName).name;
       return new _renamer.default(binding, oldName, newName).rename(block);
     }
-  }
+  };
 
-  _renameFromMap(map, oldName, newName, value) {
+  _proto._renameFromMap = function _renameFromMap(map, oldName, newName, value) {
     if (map[oldName]) {
       map[newName] = value;
       map[oldName] = null;
     }
-  }
+  };
 
-  dump() {
-    const sep = (0, _repeat().default)("-", 60);
+  _proto.dump = function dump() {
+    var sep = (0, _repeat().default)("-", 60);
     console.log(sep);
-    let scope = this;
+    var scope = this;
 
     do {
       console.log("#", scope.block.type);
 
-      for (const name in scope.bindings) {
-        const binding = scope.bindings[name];
+      for (var name in scope.bindings) {
+        var binding = scope.bindings[name];
         console.log(" -", name, {
           constant: binding.constant,
           references: binding.references,
@@ -378,13 +374,13 @@ class Scope {
     } while (scope = scope.parent);
 
     console.log(sep);
-  }
+  };
 
-  toArray(node, i) {
-    const file = this.hub.file;
+  _proto.toArray = function toArray(node, i) {
+    var file = this.hub.file;
 
     if (t().isIdentifier(node)) {
-      const binding = this.getBinding(node.name);
+      var binding = this.getBinding(node.name);
 
       if (binding && binding.constant && binding.path.isGenericType("Array")) {
         return node;
@@ -401,8 +397,8 @@ class Scope {
       return t().callExpression(t().memberExpression(t().memberExpression(t().memberExpression(t().identifier("Array"), t().identifier("prototype")), t().identifier("slice")), t().identifier("call")), [node]);
     }
 
-    let helperName;
-    const args = [node];
+    var helperName;
+    var args = [node];
 
     if (i === true) {
       helperName = "toConsumableArray";
@@ -414,21 +410,21 @@ class Scope {
     }
 
     return t().callExpression(file.addHelper(helperName), args);
-  }
+  };
 
-  hasLabel(name) {
+  _proto.hasLabel = function hasLabel(name) {
     return !!this.getLabel(name);
-  }
+  };
 
-  getLabel(name) {
+  _proto.getLabel = function getLabel(name) {
     return this.labels.get(name);
-  }
+  };
 
-  registerLabel(path) {
+  _proto.registerLabel = function registerLabel(path) {
     this.labels.set(path.node.label.name, path);
-  }
+  };
 
-  registerDeclaration(path) {
+  _proto.registerDeclaration = function registerDeclaration(path) {
     if (path.isFlow()) return;
 
     if (path.isLabeledStatement()) {
@@ -436,70 +432,93 @@ class Scope {
     } else if (path.isFunctionDeclaration()) {
       this.registerBinding("hoisted", path.get("id"), path);
     } else if (path.isVariableDeclaration()) {
-      const declarations = path.get("declarations");
+      var declarations = path.get("declarations");
+      var _arr6 = declarations;
 
-      for (const declar of declarations) {
+      for (var _i6 = 0; _i6 < _arr6.length; _i6++) {
+        var declar = _arr6[_i6];
         this.registerBinding(path.node.kind, declar);
       }
     } else if (path.isClassDeclaration()) {
       this.registerBinding("let", path);
     } else if (path.isImportDeclaration()) {
-      const specifiers = path.get("specifiers");
+      var specifiers = path.get("specifiers");
+      var _arr7 = specifiers;
 
-      for (const specifier of specifiers) {
+      for (var _i7 = 0; _i7 < _arr7.length; _i7++) {
+        var specifier = _arr7[_i7];
         this.registerBinding("module", specifier);
       }
     } else if (path.isExportDeclaration()) {
-      const declar = path.get("declaration");
+      var _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);
     }
-  }
+  };
 
-  buildUndefinedNode() {
+  _proto.buildUndefinedNode = function buildUndefinedNode() {
     if (this.hasBinding("undefined")) {
       return t().unaryExpression("void", t().numericLiteral(0), true);
     } else {
       return t().identifier("undefined");
     }
-  }
+  };
 
-  registerConstantViolation(path) {
-    const ids = path.getBindingIdentifiers();
+  _proto.registerConstantViolation = function registerConstantViolation(path) {
+    var ids = path.getBindingIdentifiers();
 
-    for (const name in ids) {
-      const binding = this.getBinding(name);
+    for (var name in ids) {
+      var 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()) {
-      const declarators = path.get("declarations");
+      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;
+        }
 
-      for (const declar of declarators) {
+        var declar = _ref;
         this.registerBinding(kind, declar);
       }
 
       return;
     }
 
-    const parent = this.getProgramParent();
-    const ids = path.getBindingIdentifiers(true);
+    var parent = this.getProgramParent();
+    var ids = path.getBindingIdentifiers(true);
 
-    for (const name in ids) {
-      for (const id of ids[name]) {
-        const local = this.getOwnBinding(name);
+    for (var name in ids) {
+      var _arr8 = ids[name];
+
+      for (var _i9 = 0; _i9 < _arr8.length; _i9++) {
+        var _id3 = _arr8[_i9];
+        var local = this.getOwnBinding(name);
 
         if (local) {
-          if (local.identifier === id) continue;
-          this.checkBlockScopedCollisions(local, kind, name, id);
+          if (local.identifier === _id3) continue;
+          this.checkBlockScopedCollisions(local, kind, name, _id3);
         }
 
         parent.references[name] = true;
@@ -507,8 +526,8 @@ class Scope {
         if (local) {
           this.registerConstantViolation(bindingPath);
         } else {
-          this.bindings[name] = new _binding.default({
-            identifier: id,
+          this.bindings[name] = new _binding2.default({
+            identifier: _id3,
             scope: this,
             path: bindingPath,
             kind: kind
@@ -516,45 +535,45 @@ class Scope {
         }
       }
     }
-  }
+  };
 
-  addGlobal(node) {
+  _proto.addGlobal = function addGlobal(node) {
     this.globals[node.name] = node;
-  }
+  };
 
-  hasUid(name) {
-    let scope = this;
+  _proto.hasUid = function hasUid(name) {
+    var scope = this;
 
     do {
       if (scope.uids[name]) return true;
     } while (scope = scope.parent);
 
     return false;
-  }
+  };
 
-  hasGlobal(name) {
-    let scope = this;
+  _proto.hasGlobal = function hasGlobal(name) {
+    var scope = this;
 
     do {
       if (scope.globals[name]) return true;
     } while (scope = scope.parent);
 
     return false;
-  }
+  };
 
-  hasReference(name) {
-    let scope = this;
+  _proto.hasReference = function hasReference(name) {
+    var scope = this;
 
     do {
       if (scope.references[name]) return true;
     } while (scope = scope.parent);
 
     return false;
-  }
+  };
 
-  isPure(node, constantsOnly) {
+  _proto.isPure = function isPure(node, constantsOnly) {
     if (t().isIdentifier(node)) {
-      const binding = this.getBinding(node.name);
+      var binding = this.getBinding(node.name);
       if (!binding) return false;
       if (constantsOnly) return binding.constant;
       return true;
@@ -565,7 +584,19 @@ class Scope {
 
       return this.isPure(node.body, constantsOnly);
     } else if (t().isClassBody(node)) {
-      for (const method of node.body) {
+      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;
       }
 
@@ -573,13 +604,19 @@ class Scope {
     } else if (t().isBinary(node)) {
       return this.isPure(node.left, constantsOnly) && this.isPure(node.right, constantsOnly);
     } else if (t().isArrayExpression(node)) {
-      for (const elem of node.elements) {
+      var _arr9 = node.elements;
+
+      for (var _i11 = 0; _i11 < _arr9.length; _i11++) {
+        var elem = _arr9[_i11];
         if (!this.isPure(elem, constantsOnly)) return false;
       }
 
       return true;
     } else if (t().isObjectExpression(node)) {
-      for (const prop of node.properties) {
+      var _arr10 = node.properties;
+
+      for (var _i12 = 0; _i12 < _arr10.length; _i12++) {
+        var prop = _arr10[_i12];
         if (!this.isPure(prop, constantsOnly)) return false;
       }
 
@@ -596,7 +633,10 @@ class Scope {
     } 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) {
+      var _arr11 = node.expressions;
+
+      for (var _i13 = 0; _i13 < _arr11.length; _i13++) {
+        var expression = _arr11[_i13];
         if (!this.isPure(expression, constantsOnly)) return false;
       }
 
@@ -604,36 +644,36 @@ class Scope {
     } else {
       return t().isPureish(node);
     }
-  }
+  };
 
-  setData(key, val) {
+  _proto.setData = function setData(key, val) {
     return this.data[key] = val;
-  }
+  };
 
-  getData(key) {
-    let scope = this;
+  _proto.getData = function getData(key) {
+    var scope = this;
 
     do {
-      const data = scope.data[key];
+      var data = scope.data[key];
       if (data != null) return data;
     } while (scope = scope.parent);
-  }
+  };
 
-  removeData(key) {
-    let scope = this;
+  _proto.removeData = function removeData(key) {
+    var scope = this;
 
     do {
-      const data = scope.data[key];
+      var data = scope.data[key];
       if (data != null) scope.data[key] = null;
     } while (scope = scope.parent);
-  }
+  };
 
-  init() {
+  _proto.init = function init() {
     if (!this.references) this.crawl();
-  }
+  };
 
-  crawl() {
-    const path = this.path;
+  _proto.crawl = function crawl() {
+    var path = this.path;
     this.references = Object.create(null);
     this.bindings = Object.create(null);
     this.globals = Object.create(null);
@@ -641,8 +681,11 @@ class Scope {
     this.data = Object.create(null);
 
     if (path.isLoop()) {
-      for (const key of t().FOR_INIT_KEYS) {
-        const node = path.get(key);
+      var _arr12 = t().FOR_INIT_KEYS;
+
+      for (var _i14 = 0; _i14 < _arr12.length; _i14++) {
+        var key = _arr12[_i14];
+        var node = path.get(key);
         if (node.isBlockScoped()) this.registerBinding(node.node.kind, node);
       }
     }
@@ -660,9 +703,21 @@ class Scope {
     }
 
     if (path.isFunction()) {
-      const params = path.get("params");
+      var params = path.get("params");
 
-      for (const param of 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;
+        }
+
+        var param = _ref3;
         this.registerBinding("param", param);
       }
     }
@@ -671,9 +726,9 @@ class Scope {
       this.registerBinding("let", path);
     }
 
-    const parent = this.getProgramParent();
+    var parent = this.getProgramParent();
     if (parent.crawling) return;
-    const state = {
+    var state = {
       references: [],
       constantViolations: [],
       assignments: []
@@ -682,21 +737,47 @@ class Scope {
     path.traverse(collectorVisitor, state);
     this.crawling = false;
 
-    for (const path of state.assignments) {
-      const ids = path.getBindingIdentifiers();
-      let programParent;
+    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 _path = _ref4;
+
+      var ids = _path.getBindingIdentifiers();
+
+      var programParent = void 0;
 
-      for (const name in ids) {
-        if (path.scope.getBinding(name)) continue;
-        programParent = programParent || path.scope.getProgramParent();
+      for (var name in ids) {
+        if (_path.scope.getBinding(name)) continue;
+        programParent = programParent || _path.scope.getProgramParent();
         programParent.addGlobal(ids[name]);
       }
 
-      path.scope.registerConstantViolation(path);
+      _path.scope.registerConstantViolation(_path);
     }
 
-    for (const ref of state.references) {
-      const binding = ref.scope.getBinding(ref.node.name);
+    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 ref = _ref5;
+      var binding = ref.scope.getBinding(ref.node.name);
 
       if (binding) {
         binding.reference(ref);
@@ -705,13 +786,26 @@ class Scope {
       }
     }
 
-    for (const path of state.constantViolations) {
-      path.scope.registerConstantViolation(path);
+    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 _path2 = _ref6;
+
+      _path2.scope.registerConstantViolation(_path2);
     }
-  }
+  };
 
-  push(opts) {
-    let path = this.path;
+  _proto.push = function push(opts) {
+    var path = this.path;
 
     if (!path.isBlockStatement() && !path.isProgram()) {
       path = this.getBlockParent().path;
@@ -726,26 +820,29 @@ class Scope {
       path = path.get("body");
     }
 
-    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);
+    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);
 
     if (!declarPath) {
-      const declar = t().variableDeclaration(kind, []);
+      var declar = t().variableDeclaration(kind, []);
       declar._blockHoist = blockHoist;
-      [declarPath] = path.unshiftContainer("body", [declar]);
+
+      var _path$unshiftContaine = path.unshiftContainer("body", [declar]);
+
+      declarPath = _path$unshiftContaine[0];
       if (!unique) path.setData(dataKey, declarPath);
     }
 
-    const declarator = t().variableDeclarator(opts.id, opts.init);
+    var declarator = t().variableDeclarator(opts.id, opts.init);
     declarPath.node.declarations.push(declarator);
     this.registerBinding(kind, declarPath.get("declarations").pop());
-  }
+  };
 
-  getProgramParent() {
-    let scope = this;
+  _proto.getProgramParent = function getProgramParent() {
+    var scope = this;
 
     do {
       if (scope.path.isProgram()) {
@@ -754,10 +851,10 @@ class Scope {
     } while (scope = scope.parent);
 
     throw new Error("Couldn't find a Program");
-  }
+  };
 
-  getFunctionParent() {
-    let scope = this;
+  _proto.getFunctionParent = function getFunctionParent() {
+    var scope = this;
 
     do {
       if (scope.path.isFunctionParent()) {
@@ -766,10 +863,10 @@ class Scope {
     } while (scope = scope.parent);
 
     return null;
-  }
+  };
 
-  getBlockParent() {
-    let scope = this;
+  _proto.getBlockParent = function getBlockParent() {
+    var scope = this;
 
     do {
       if (scope.path.isBlockParent()) {
@@ -778,11 +875,11 @@ class Scope {
     } while (scope = scope.parent);
 
     throw new Error("We couldn't find a BlockStatement, For, Switch, Function, Loop or Program...");
-  }
+  };
 
-  getAllBindings() {
-    const ids = Object.create(null);
-    let scope = this;
+  _proto.getAllBindings = function getAllBindings() {
+    var ids = Object.create(null);
+    var scope = this;
 
     do {
       (0, _defaults().default)(ids, scope.bindings);
@@ -790,17 +887,19 @@ class Scope {
     } while (scope);
 
     return ids;
-  }
+  };
 
-  getAllBindingsOfKind() {
-    const ids = Object.create(null);
+  _proto.getAllBindingsOfKind = function getAllBindingsOfKind() {
+    var ids = Object.create(null);
+    var _arr13 = arguments;
 
-    for (const kind of arguments) {
-      let scope = this;
+    for (var _i19 = 0; _i19 < _arr13.length; _i19++) {
+      var kind = _arr13[_i19];
+      var scope = this;
 
       do {
-        for (const name in scope.bindings) {
-          const binding = scope.bindings[name];
+        for (var name in scope.bindings) {
+          var binding = scope.bindings[name];
           if (binding.kind === kind) ids[name] = binding;
         }
 
@@ -809,40 +908,40 @@ class Scope {
     }
 
     return ids;
-  }
+  };
 
-  bindingIdentifierEquals(name, node) {
+  _proto.bindingIdentifierEquals = function bindingIdentifierEquals(name, node) {
     return this.getBindingIdentifier(name) === node;
-  }
+  };
 
-  getBinding(name) {
-    let scope = this;
+  _proto.getBinding = function getBinding(name) {
+    var scope = this;
 
     do {
-      const binding = scope.getOwnBinding(name);
+      var binding = scope.getOwnBinding(name);
       if (binding) return binding;
     } while (scope = scope.parent);
-  }
+  };
 
-  getOwnBinding(name) {
+  _proto.getOwnBinding = function getOwnBinding(name) {
     return this.bindings[name];
-  }
+  };
 
-  getBindingIdentifier(name) {
-    const info = this.getBinding(name);
+  _proto.getBindingIdentifier = function getBindingIdentifier(name) {
+    var info = this.getBinding(name);
     return info && info.identifier;
-  }
+  };
 
-  getOwnBindingIdentifier(name) {
-    const binding = this.bindings[name];
+  _proto.getOwnBindingIdentifier = function getOwnBindingIdentifier(name) {
+    var binding = this.bindings[name];
     return binding && binding.identifier;
-  }
+  };
 
-  hasOwnBinding(name) {
+  _proto.hasOwnBinding = function hasOwnBinding(name) {
     return !!this.getOwnBinding(name);
-  }
+  };
 
-  hasBinding(name, noGlobals) {
+  _proto.hasBinding = function hasBinding(name, noGlobals) {
     if (!name) return false;
     if (this.hasOwnBinding(name)) return true;
     if (this.parentHasBinding(name, noGlobals)) return true;
@@ -850,43 +949,64 @@ class Scope {
     if (!noGlobals && (0, _includes().default)(Scope.globals, name)) return true;
     if (!noGlobals && (0, _includes().default)(Scope.contextVariables, name)) return true;
     return false;
-  }
+  };
 
-  parentHasBinding(name, noGlobals) {
+  _proto.parentHasBinding = function parentHasBinding(name, noGlobals) {
     return this.parent && this.parent.hasBinding(name, noGlobals);
-  }
+  };
 
-  moveBindingTo(name, scope) {
-    const info = this.getBinding(name);
+  _proto.moveBindingTo = function moveBindingTo(name, scope) {
+    var info = this.getBinding(name);
 
     if (info) {
       info.scope.removeOwnBinding(name);
       info.scope = scope;
       scope.bindings[name] = info;
     }
-  }
+  };
 
-  removeOwnBinding(name) {
+  _proto.removeOwnBinding = function removeOwnBinding(name) {
     delete this.bindings[name];
-  }
+  };
 
-  removeBinding(name) {
-    const info = this.getBinding(name);
+  _proto.removeBinding = function removeBinding(name) {
+    var info = this.getBinding(name);
 
     if (info) {
       info.scope.removeOwnBinding(name);
     }
 
-    let scope = this;
+    var 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;
+}();
 
 exports.default = Scope;
 Scope.globals = Object.keys(_globals().default.builtin);