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

package/lib/path/introspection.js

@@ -24,9 +24,9 @@ exports.isConstantExpression = isConstantExpression;
 exports.is = void 0;
 
 function _includes() {
-  const data = _interopRequireDefault(require("lodash/includes"));
+  var data = _interopRequireDefault(require("lodash/includes"));
 
-  _includes = function () {
+  _includes = function _includes() {
     return data;
   };
 
@@ -34,9 +34,9 @@ function _includes() {
 }
 
 function t() {
-  const data = _interopRequireWildcard(require("@babel/types"));
+  var data = _interopRequireWildcard(require("@babel/types"));
 
-  t = function () {
+  t = function t() {
     return data;
   };
 
@@ -52,7 +52,7 @@ function matchesPattern(pattern, allowPartial) {
 }
 
 function has(key) {
-  const val = this.node && this.node[key];
+  var val = this.node && this.node[key];
 
   if (val && Array.isArray(val)) {
     return !!val.length;
@@ -65,7 +65,7 @@ function isStatic() {
   return this.scope.isStatic(this.node);
 }
 
-const is = has;
+var is = has;
 exports.is = is;
 
 function isnt(key) {
@@ -99,11 +99,11 @@ function canSwapBetweenExpressionAndStatement(replacement) {
 }
 
 function isCompletionRecord(allowInsideFunction) {
-  let path = this;
-  let first = true;
+  var path = this;
+  var first = true;
 
   do {
-    const container = path.container;
+    var container = path.container;
 
     if (path.isFunction() && !first) {
       return !!allowInsideFunction;
@@ -129,10 +129,10 @@ function isStatementOrBlock() {
 
 function referencesImport(moduleSource, importName) {
   if (!this.isReferencedIdentifier()) return false;
-  const binding = this.scope.getBinding(this.node.name);
+  var binding = this.scope.getBinding(this.node.name);
   if (!binding || binding.kind !== "module") return false;
-  const path = binding.path;
-  const parent = path.parentPath;
+  var path = binding.path;
+  var parent = path.parentPath;
   if (!parent.isImportDeclaration()) return false;
 
   if (parent.node.source.value === moduleSource) {
@@ -157,7 +157,7 @@ function referencesImport(moduleSource, importName) {
 }
 
 function getSource() {
-  const node = this.node;
+  var node = this.node;
 
   if (node.end) {
     return this.hub.file.code.slice(node.start, node.end);
@@ -171,11 +171,11 @@ function willIMaybeExecuteBefore(target) {
 }
 
 function _guessExecutionStatusRelativeTo(target) {
-  const targetFuncParent = target.scope.getFunctionParent() || target.scope.getProgramParent();
-  const selfFuncParent = this.scope.getFunctionParent() || target.scope.getProgramParent();
+  var targetFuncParent = target.scope.getFunctionParent() || target.scope.getProgramParent();
+  var selfFuncParent = this.scope.getFunctionParent() || target.scope.getProgramParent();
 
   if (targetFuncParent.node !== selfFuncParent.node) {
-    const status = this._guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent);
+    var status = this._guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent);
 
     if (status) {
       return status;
@@ -184,15 +184,15 @@ function _guessExecutionStatusRelativeTo(target) {
     }
   }
 
-  const targetPaths = target.getAncestry();
+  var targetPaths = target.getAncestry();
   if (targetPaths.indexOf(this) >= 0) return "after";
-  const selfPaths = this.getAncestry();
-  let commonPath;
-  let targetIndex;
-  let selfIndex;
+  var selfPaths = this.getAncestry();
+  var commonPath;
+  var targetIndex;
+  var selfIndex;
 
   for (selfIndex = 0; selfIndex < selfPaths.length; selfIndex++) {
-    const selfPath = selfPaths[selfIndex];
+    var selfPath = selfPaths[selfIndex];
     targetIndex = targetPaths.indexOf(selfPath);
 
     if (targetIndex >= 0) {
@@ -205,8 +205,8 @@ function _guessExecutionStatusRelativeTo(target) {
     return "before";
   }
 
-  const targetRelationship = targetPaths[targetIndex - 1];
-  const selfRelationship = selfPaths[selfIndex - 1];
+  var targetRelationship = targetPaths[targetIndex - 1];
+  var selfRelationship = selfPaths[selfIndex - 1];
 
   if (!targetRelationship || !selfRelationship) {
     return "before";
@@ -216,32 +216,59 @@ function _guessExecutionStatusRelativeTo(target) {
     return targetRelationship.key > selfRelationship.key ? "before" : "after";
   }
 
-  const keys = t().VISITOR_KEYS[commonPath.type];
-  const targetKeyPosition = keys.indexOf(targetRelationship.key);
-  const selfKeyPosition = keys.indexOf(selfRelationship.key);
+  var keys = t().VISITOR_KEYS[commonPath.type];
+  var targetKeyPosition = keys.indexOf(targetRelationship.key);
+  var selfKeyPosition = keys.indexOf(selfRelationship.key);
   return targetKeyPosition > selfKeyPosition ? "before" : "after";
 }
 
 function _guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent) {
-  const targetFuncPath = targetFuncParent.path;
+  var targetFuncPath = targetFuncParent.path;
   if (!targetFuncPath.isFunctionDeclaration()) return;
-  const binding = targetFuncPath.scope.getBinding(targetFuncPath.node.id.name);
+  var binding = targetFuncPath.scope.getBinding(targetFuncPath.node.id.name);
   if (!binding.references) return "before";
-  const referencePaths = binding.referencePaths;
+  var referencePaths = binding.referencePaths;
+
+  for (var _iterator = referencePaths, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    var path = _ref;
 
-  for (const path of referencePaths) {
     if (path.key !== "callee" || !path.parentPath.isCallExpression()) {
       return;
     }
   }
 
-  let allStatus;
+  var allStatus;
+
+  for (var _iterator2 = referencePaths, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+    var _ref2;
+
+    if (_isArray2) {
+      if (_i2 >= _iterator2.length) break;
+      _ref2 = _iterator2[_i2++];
+    } else {
+      _i2 = _iterator2.next();
+      if (_i2.done) break;
+      _ref2 = _i2.value;
+    }
 
-  for (const path of referencePaths) {
-    const childOfFunction = !!path.find(path => path.node === targetFuncPath.node);
+    var _path = _ref2;
+    var childOfFunction = !!_path.find(function (path) {
+      return path.node === targetFuncPath.node;
+    });
     if (childOfFunction) continue;
 
-    const status = this._guessExecutionStatusRelativeTo(path);
+    var status = this._guessExecutionStatusRelativeTo(_path);
 
     if (allStatus) {
       if (allStatus !== status) return;
@@ -267,31 +294,35 @@ function _resolve(dangerous, resolved) {
       return this.get("init").resolve(dangerous, resolved);
     } else {}
   } else if (this.isReferencedIdentifier()) {
-    const binding = this.scope.getBinding(this.node.name);
+    var binding = this.scope.getBinding(this.node.name);
     if (!binding) return;
     if (!binding.constant) return;
     if (binding.kind === "module") return;
 
     if (binding.path !== this) {
-      const ret = binding.path.resolve(dangerous, resolved);
-      if (this.find(parent => parent.node === ret.node)) return;
+      var ret = binding.path.resolve(dangerous, resolved);
+      if (this.find(function (parent) {
+        return parent.node === ret.node;
+      })) return;
       return ret;
     }
   } else if (this.isTypeCastExpression()) {
     return this.get("expression").resolve(dangerous, resolved);
   } else if (dangerous && this.isMemberExpression()) {
-    const targetKey = this.toComputedKey();
+    var targetKey = this.toComputedKey();
     if (!t().isLiteral(targetKey)) return;
-    const targetName = targetKey.value;
-    const target = this.get("object").resolve(dangerous, resolved);
+    var targetName = targetKey.value;
+    var target = this.get("object").resolve(dangerous, resolved);
 
     if (target.isObjectExpression()) {
-      const props = target.get("properties");
+      var props = target.get("properties");
+      var _arr = props;
 
-      for (const prop of props) {
+      for (var _i3 = 0; _i3 < _arr.length; _i3++) {
+        var prop = _arr[_i3];
         if (!prop.isProperty()) continue;
-        const key = prop.get("key");
-        let match = prop.isnt("computed") && key.isIdentifier({
+        var key = prop.get("key");
+        var match = prop.isnt("computed") && key.isIdentifier({
           name: targetName
         });
         match = match || key.isLiteral({
@@ -300,8 +331,8 @@ function _resolve(dangerous, resolved) {
         if (match) return prop.get("value").resolve(dangerous, resolved);
       }
     } else if (target.isArrayExpression() && !isNaN(+targetName)) {
-      const elems = target.get("elements");
-      const elem = elems[targetName];
+      var elems = target.get("elements");
+      var elem = elems[targetName];
       if (elem) return elem.resolve(dangerous, resolved);
     }
   }
@@ -309,7 +340,7 @@ function _resolve(dangerous, resolved) {
 
 function isConstantExpression() {
   if (this.isIdentifier()) {
-    const binding = this.scope.getBinding(this.node.name);
+    var binding = this.scope.getBinding(this.node.name);
 
     if (!binding) {
       return false;
@@ -324,7 +355,9 @@ function isConstantExpression() {
     }
 
     if (this.isTemplateLiteral()) {
-      return this.get("expressions").every(expression => expression.isConstantExpression());
+      return this.get("expressions").every(function (expression) {
+        return expression.isConstantExpression();
+      });
     }
 
     return true;

package/lib/path/lib/hoister.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 
 function t() {
-  const data = _interopRequireWildcard(require("@babel/types"));
+  var data = _interopRequireWildcard(require("@babel/types"));
 
-  t = function () {
+  t = function t() {
     return data;
   };
 
@@ -17,14 +17,14 @@ function t() {
 
 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; } }
 
-const referenceVisitor = {
-  ReferencedIdentifier(path, state) {
+var referenceVisitor = {
+  ReferencedIdentifier: function ReferencedIdentifier(path, state) {
     if (path.isJSXIdentifier() && t().react.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
       return;
     }
 
     if (path.node.name === "this") {
-      let scope = path.scope;
+      var scope = path.scope;
 
       do {
         if (scope.path.isFunction() && !scope.path.isArrowFunctionExpression()) {
@@ -35,16 +35,15 @@ const referenceVisitor = {
       if (scope) state.breakOnScopePaths.push(scope.path);
     }
 
-    const binding = path.scope.getBinding(path.node.name);
+    var binding = path.scope.getBinding(path.node.name);
     if (!binding) return;
     if (binding !== state.scope.getBinding(path.node.name)) return;
     state.bindings[path.node.name] = binding;
   }
-
 };
 
-class PathHoister {
-  constructor(path, scope) {
+var PathHoister = function () {
+  function PathHoister(path, scope) {
     this.breakOnScopePaths = [];
     this.bindings = {};
     this.scopes = [];
@@ -53,9 +52,11 @@ class PathHoister {
     this.attachAfter = false;
   }
 
-  isCompatibleScope(scope) {
-    for (const key in this.bindings) {
-      const binding = this.bindings[key];
+  var _proto = PathHoister.prototype;
+
+  _proto.isCompatibleScope = function isCompatibleScope(scope) {
+    for (var key in this.bindings) {
+      var binding = this.bindings[key];
 
       if (!scope.bindingIdentifierEquals(key, binding.identifier)) {
         return false;
@@ -63,10 +64,10 @@ class PathHoister {
     }
 
     return true;
-  }
+  };
 
-  getCompatibleScopes() {
-    let scope = this.path.scope;
+  _proto.getCompatibleScopes = function getCompatibleScopes() {
+    var scope = this.path.scope;
 
     do {
       if (this.isCompatibleScope(scope)) {
@@ -79,34 +80,37 @@ class PathHoister {
         break;
       }
     } while (scope = scope.parent);
-  }
+  };
 
-  getAttachmentPath() {
-    let path = this._getAttachmentPath();
+  _proto.getAttachmentPath = function getAttachmentPath() {
+    var path = this._getAttachmentPath();
 
     if (!path) return;
-    let targetScope = path.scope;
+    var targetScope = path.scope;
 
     if (targetScope.path === path) {
       targetScope = path.scope.parent;
     }
 
     if (targetScope.path.isProgram() || targetScope.path.isFunction()) {
-      for (const name in this.bindings) {
+      for (var name in this.bindings) {
         if (!targetScope.hasOwnBinding(name)) continue;
-        const binding = this.bindings[name];
+        var binding = this.bindings[name];
 
         if (binding.kind === "param" || binding.path.parentKey === "params") {
           continue;
         }
 
-        const bindingParentPath = this.getAttachmentParentForPath(binding.path);
+        var bindingParentPath = this.getAttachmentParentForPath(binding.path);
 
         if (bindingParentPath.key >= path.key) {
           this.attachAfter = true;
           path = binding.path;
+          var _arr = binding.constantViolations;
+
+          for (var _i = 0; _i < _arr.length; _i++) {
+            var violationPath = _arr[_i];
 
-          for (const violationPath of binding.constantViolations) {
             if (this.getAttachmentParentForPath(violationPath).key > path.key) {
               path = violationPath;
             }
@@ -116,19 +120,19 @@ class PathHoister {
     }
 
     return path;
-  }
+  };
 
-  _getAttachmentPath() {
-    const scopes = this.scopes;
-    const scope = scopes.pop();
+  _proto._getAttachmentPath = function _getAttachmentPath() {
+    var scopes = this.scopes;
+    var scope = scopes.pop();
     if (!scope) return;
 
     if (scope.path.isFunction()) {
       if (this.hasOwnParamBindings(scope)) {
         if (this.scope === scope) return;
-        const bodies = scope.path.get("body").get("body");
+        var bodies = scope.path.get("body").get("body");
 
-        for (let i = 0; i < bodies.length; i++) {
+        for (var i = 0; i < bodies.length; i++) {
           if (bodies[i].node._blockHoist) continue;
           return bodies[i];
         }
@@ -138,42 +142,45 @@ class PathHoister {
     } else if (scope.path.isProgram()) {
       return this.getNextScopeAttachmentParent();
     }
-  }
+  };
 
-  getNextScopeAttachmentParent() {
-    const scope = this.scopes.pop();
+  _proto.getNextScopeAttachmentParent = function getNextScopeAttachmentParent() {
+    var scope = this.scopes.pop();
     if (scope) return this.getAttachmentParentForPath(scope.path);
-  }
+  };
 
-  getAttachmentParentForPath(path) {
+  _proto.getAttachmentParentForPath = function getAttachmentParentForPath(path) {
     do {
       if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) {
         return path;
       }
     } while (path = path.parentPath);
-  }
+  };
 
-  hasOwnParamBindings(scope) {
-    for (const name in this.bindings) {
+  _proto.hasOwnParamBindings = function hasOwnParamBindings(scope) {
+    for (var name in this.bindings) {
       if (!scope.hasOwnBinding(name)) continue;
-      const binding = this.bindings[name];
+      var binding = this.bindings[name];
       if (binding.kind === "param" && binding.constant) return true;
     }
 
     return false;
-  }
+  };
 
-  run() {
+  _proto.run = function run() {
     this.path.traverse(referenceVisitor, this);
     this.getCompatibleScopes();
-    const attachTo = this.getAttachmentPath();
+    var attachTo = this.getAttachmentPath();
     if (!attachTo) return;
     if (attachTo.getFunctionParent() === this.path.getFunctionParent()) return;
-    let uid = attachTo.scope.generateUidIdentifier("ref");
-    const declarator = t().variableDeclarator(uid, this.path.node);
-    const insertFn = this.attachAfter ? "insertAfter" : "insertBefore";
-    const [attached] = attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : t().variableDeclaration("var", [declarator])]);
-    const parent = this.path.parentPath;
+    var uid = attachTo.scope.generateUidIdentifier("ref");
+    var declarator = t().variableDeclarator(uid, this.path.node);
+    var insertFn = this.attachAfter ? "insertAfter" : "insertBefore";
+
+    var _attachTo$insertFn = attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : t().variableDeclaration("var", [declarator])]),
+        attached = _attachTo$insertFn[0];
+
+    var parent = this.path.parentPath;
 
     if (parent.isJSXElement() && this.path.container === parent.node.children) {
       uid = t().JSXExpressionContainer(uid);
@@ -181,8 +188,9 @@ class PathHoister {
 
     this.path.replaceWith(t().cloneNode(uid));
     return attachTo.isVariableDeclarator() ? attached.get("init") : attached.get("declarations.0.init");
-  }
+  };
 
-}
+  return PathHoister;
+}();
 
 exports.default = PathHoister;

package/lib/path/lib/removal-hooks.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.hooks = void 0;
-const hooks = [function (self, parent) {
-  const removeParent = self.key === "test" && (parent.isWhile() || parent.isSwitchCase()) || self.key === "declaration" && parent.isExportDeclaration() || self.key === "body" && parent.isLabeledStatement() || self.listKey === "declarations" && parent.isVariableDeclaration() && parent.node.declarations.length === 1 || self.key === "expression" && parent.isExpressionStatement();
+var hooks = [function (self, parent) {
+  var removeParent = self.key === "test" && (parent.isWhile() || parent.isSwitchCase()) || self.key === "declaration" && parent.isExportDeclaration() || self.key === "body" && parent.isLabeledStatement() || self.listKey === "declarations" && parent.isVariableDeclaration() && parent.node.declarations.length === 1 || self.key === "expression" && parent.isExpressionStatement();
 
   if (removeParent) {
     parent.remove();