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

package/lib/path/evaluation.js

@@ -5,11 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.evaluateTruthy = evaluateTruthy;
 exports.evaluate = evaluate;
-const VALID_CALLEES = ["String", "Number", "Math"];
-const INVALID_METHODS = ["random"];
+var VALID_CALLEES = ["String", "Number", "Math"];
+var INVALID_METHODS = ["random"];
 
 function evaluateTruthy() {
-  const res = this.evaluate();
+  var res = this.evaluate();
   if (res.confident) return !!res.value;
 }
 
@@ -20,15 +20,11 @@ function deopt(path, state) {
 }
 
 function evaluateCached(path, state) {
-  const {
-    node
-  } = path;
-  const {
-    seen
-  } = state;
+  var node = path.node;
+  var seen = state.seen;
 
   if (seen.has(node)) {
-    const existing = seen.get(node);
+    var existing = seen.get(node);
 
     if (existing.resolved) {
       return existing.value;
@@ -37,12 +33,12 @@ function evaluateCached(path, state) {
       return;
     }
   } else {
-    const item = {
+    var item = {
       resolved: false
     };
     seen.set(node, item);
 
-    const val = _evaluate(path, state);
+    var val = _evaluate(path, state);
 
     if (state.confident) {
       item.resolved = true;
@@ -55,12 +51,10 @@ function evaluateCached(path, state) {
 
 function _evaluate(path, state) {
   if (!state.confident) return;
-  const {
-    node
-  } = path;
+  var node = path.node;
 
   if (path.isSequenceExpression()) {
-    const exprs = path.get("expressions");
+    var exprs = path.get("expressions");
     return evaluateCached(exprs[exprs.length - 1], state);
   }
 
@@ -77,13 +71,9 @@ function _evaluate(path, state) {
   }
 
   if (path.isTaggedTemplateExpression() && path.get("tag").isMemberExpression()) {
-    const object = path.get("tag.object");
-    const {
-      node: {
-        name
-      }
-    } = object;
-    const property = path.get("tag.property");
+    var object = path.get("tag.object");
+    var name = object.node.name;
+    var property = path.get("tag.property");
 
     if (object.isIdentifier() && name === "String" && !path.scope.getBinding(name, true) && property.isIdentifier && property.node.name === "raw") {
       return evaluateQuasis(path, node.quasi.quasis, state, true);
@@ -91,7 +81,7 @@ function _evaluate(path, state) {
   }
 
   if (path.isConditionalExpression()) {
-    const testResult = evaluateCached(path.get("test"), state);
+    var testResult = evaluateCached(path.get("test"), state);
     if (!state.confident) return;
 
     if (testResult) {
@@ -108,21 +98,22 @@ function _evaluate(path, state) {
   if (path.isMemberExpression() && !path.parentPath.isCallExpression({
     callee: node
   })) {
-    const property = path.get("property");
-    const object = path.get("object");
+    var _property = path.get("property");
+
+    var _object = path.get("object");
 
-    if (object.isLiteral() && property.isIdentifier()) {
-      const value = object.node.value;
-      const type = typeof value;
+    if (_object.isLiteral() && _property.isIdentifier()) {
+      var value = _object.node.value;
+      var type = typeof value;
 
       if (type === "number" || type === "string") {
-        return value[property.node.name];
+        return value[_property.node.name];
       }
     }
   }
 
   if (path.isReferencedIdentifier()) {
-    const binding = path.scope.getBinding(node.name);
+    var binding = path.scope.getBinding(node.name);
 
     if (binding && binding.constantViolations.length > 0) {
       return deopt(binding.path, state);
@@ -143,7 +134,7 @@ function _evaluate(path, state) {
         return binding ? deopt(binding.path, state) : NaN;
       }
 
-      const resolved = path.resolve();
+      var resolved = path.resolve();
 
       if (resolved === path) {
         return deopt(path, state);
@@ -160,13 +151,13 @@ function _evaluate(path, state) {
       return undefined;
     }
 
-    const argument = path.get("argument");
+    var argument = path.get("argument");
 
     if (node.operator === "typeof" && (argument.isFunction() || argument.isClass())) {
       return "function";
     }
 
-    const arg = evaluateCached(argument, state);
+    var arg = evaluateCached(argument, state);
     if (!state.confident) return;
 
     switch (node.operator) {
@@ -188,11 +179,23 @@ function _evaluate(path, state) {
   }
 
   if (path.isArrayExpression()) {
-    const arr = [];
-    const elems = path.get("elements");
+    var arr = [];
+    var elems = path.get("elements");
+
+    for (var _iterator = elems, _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;
+      }
 
-    for (const elem of elems) {
-      const elemValue = elem.evaluate();
+      var elem = _ref;
+      var elemValue = elem.evaluate();
 
       if (elemValue.confident) {
         arr.push(elemValue.value);
@@ -205,16 +208,29 @@ function _evaluate(path, state) {
   }
 
   if (path.isObjectExpression()) {
-    const obj = {};
-    const props = path.get("properties");
+    var obj = {};
+    var props = path.get("properties");
+
+    for (var _iterator2 = props, _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;
+      }
+
+      var prop = _ref2;
 
-    for (const prop of props) {
       if (prop.isObjectMethod() || prop.isSpreadElement()) {
         return deopt(prop, state);
       }
 
-      const keyPath = prop.get("key");
-      let key = keyPath;
+      var keyPath = prop.get("key");
+      var key = keyPath;
 
       if (prop.node.computed) {
         key = key.evaluate();
@@ -230,27 +246,28 @@ function _evaluate(path, state) {
         key = key.node.value;
       }
 
-      const valuePath = prop.get("value");
-      let value = valuePath.evaluate();
+      var valuePath = prop.get("value");
 
-      if (!value.confident) {
+      var _value = valuePath.evaluate();
+
+      if (!_value.confident) {
         return deopt(valuePath, state);
       }
 
-      value = value.value;
-      obj[key] = value;
+      _value = _value.value;
+      obj[key] = _value;
     }
 
     return obj;
   }
 
   if (path.isLogicalExpression()) {
-    const wasConfident = state.confident;
-    const left = evaluateCached(path.get("left"), state);
-    const leftConfident = state.confident;
+    var wasConfident = state.confident;
+    var left = evaluateCached(path.get("left"), state);
+    var leftConfident = state.confident;
     state.confident = wasConfident;
-    const right = evaluateCached(path.get("right"), state);
-    const rightConfident = state.confident;
+    var right = evaluateCached(path.get("right"), state);
+    var rightConfident = state.confident;
     state.confident = leftConfident && rightConfident;
 
     switch (node.operator) {
@@ -274,104 +291,110 @@ function _evaluate(path, state) {
   }
 
   if (path.isBinaryExpression()) {
-    const left = evaluateCached(path.get("left"), state);
+    var _left = evaluateCached(path.get("left"), state);
+
     if (!state.confident) return;
-    const right = evaluateCached(path.get("right"), state);
+
+    var _right = evaluateCached(path.get("right"), state);
+
     if (!state.confident) return;
 
     switch (node.operator) {
       case "-":
-        return left - right;
+        return _left - _right;
 
       case "+":
-        return left + right;
+        return _left + _right;
 
       case "/":
-        return left / right;
+        return _left / _right;
 
       case "*":
-        return left * right;
+        return _left * _right;
 
       case "%":
-        return left % right;
+        return _left % _right;
 
       case "**":
-        return left ** right;
+        return Math.pow(_left, _right);
 
       case "<":
-        return left < right;
+        return _left < _right;
 
       case ">":
-        return left > right;
+        return _left > _right;
 
       case "<=":
-        return left <= right;
+        return _left <= _right;
 
       case ">=":
-        return left >= right;
+        return _left >= _right;
 
       case "==":
-        return left == right;
+        return _left == _right;
 
       case "!=":
-        return left != right;
+        return _left != _right;
 
       case "===":
-        return left === right;
+        return _left === _right;
 
       case "!==":
-        return left !== right;
+        return _left !== _right;
 
       case "|":
-        return left | right;
+        return _left | _right;
 
       case "&":
-        return left & right;
+        return _left & _right;
 
       case "^":
-        return left ^ right;
+        return _left ^ _right;
 
       case "<<":
-        return left << right;
+        return _left << _right;
 
       case ">>":
-        return left >> right;
+        return _left >> _right;
 
       case ">>>":
-        return left >>> right;
+        return _left >>> _right;
     }
   }
 
   if (path.isCallExpression()) {
-    const callee = path.get("callee");
-    let context;
-    let func;
+    var callee = path.get("callee");
+    var context;
+    var func;
 
     if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name, true) && VALID_CALLEES.indexOf(callee.node.name) >= 0) {
       func = global[node.callee.name];
     }
 
     if (callee.isMemberExpression()) {
-      const object = callee.get("object");
-      const property = callee.get("property");
+      var _object2 = callee.get("object");
+
+      var _property2 = callee.get("property");
 
-      if (object.isIdentifier() && property.isIdentifier() && VALID_CALLEES.indexOf(object.node.name) >= 0 && INVALID_METHODS.indexOf(property.node.name) < 0) {
-        context = global[object.node.name];
-        func = context[property.node.name];
+      if (_object2.isIdentifier() && _property2.isIdentifier() && VALID_CALLEES.indexOf(_object2.node.name) >= 0 && INVALID_METHODS.indexOf(_property2.node.name) < 0) {
+        context = global[_object2.node.name];
+        func = context[_property2.node.name];
       }
 
-      if (object.isLiteral() && property.isIdentifier()) {
-        const type = typeof object.node.value;
+      if (_object2.isLiteral() && _property2.isIdentifier()) {
+        var _type = typeof _object2.node.value;
 
-        if (type === "string" || type === "number") {
-          context = object.node.value;
-          func = context[property.node.name];
+        if (_type === "string" || _type === "number") {
+          context = _object2.node.value;
+          func = context[_property2.node.name];
         }
       }
     }
 
     if (func) {
-      const args = path.get("arguments").map(arg => evaluateCached(arg, state));
+      var args = path.get("arguments").map(function (arg) {
+        return evaluateCached(arg, state);
+      });
       if (!state.confident) return;
       return func.apply(context, args);
     }
@@ -380,15 +403,31 @@ function _evaluate(path, state) {
   deopt(path, state);
 }
 
-function evaluateQuasis(path, quasis, state, raw = false) {
-  let str = "";
-  let i = 0;
-  const exprs = path.get("expressions");
+function evaluateQuasis(path, quasis, state, raw) {
+  if (raw === void 0) {
+    raw = false;
+  }
+
+  var str = "";
+  var i = 0;
+  var exprs = path.get("expressions");
+
+  for (var _iterator3 = quasis, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+    var _ref3;
+
+    if (_isArray3) {
+      if (_i3 >= _iterator3.length) break;
+      _ref3 = _iterator3[_i3++];
+    } else {
+      _i3 = _iterator3.next();
+      if (_i3.done) break;
+      _ref3 = _i3.value;
+    }
 
-  for (const elem of quasis) {
+    var elem = _ref3;
     if (!state.confident) break;
     str += raw ? elem.value.raw : elem.value.cooked;
-    const expr = exprs[i++];
+    var expr = exprs[i++];
     if (expr) str += String(evaluateCached(expr, state));
   }
 
@@ -397,12 +436,12 @@ function evaluateQuasis(path, quasis, state, raw = false) {
 }
 
 function evaluate() {
-  const state = {
+  var state = {
     confident: true,
     deoptPath: null,
     seen: new Map()
   };
-  let value = evaluateCached(this, state);
+  var value = evaluateCached(this, state);
   if (!state.confident) value = undefined;
   return {
     confident: state.confident,

package/lib/path/family.js

@@ -21,9 +21,9 @@ exports.getOuterBindingIdentifierPaths = getOuterBindingIdentifierPaths;
 var _index = _interopRequireDefault(require("./index"));
 
 function t() {
-  const data = _interopRequireWildcard(require("@babel/types"));
+  var data = _interopRequireWildcard(require("@babel/types"));
 
-  t = function () {
+  t = function t() {
     return data;
   };
 
@@ -48,7 +48,7 @@ function addCompletionRecords(path, paths) {
 }
 
 function getCompletionRecords() {
-  let paths = [];
+  var paths = [];
 
   if (this.isIfStatement()) {
     paths = addCompletionRecords(this.get("consequent"), paths);
@@ -91,9 +91,9 @@ function getNextSibling() {
 }
 
 function getAllNextSiblings() {
-  let _key = this.key;
-  let sibling = this.getSibling(++_key);
-  const siblings = [];
+  var _key = this.key;
+  var sibling = this.getSibling(++_key);
+  var siblings = [];
 
   while (sibling.node) {
     siblings.push(sibling);
@@ -104,9 +104,9 @@ function getAllNextSiblings() {
 }
 
 function getAllPrevSiblings() {
-  let _key = this.key;
-  let sibling = this.getSibling(--_key);
-  const siblings = [];
+  var _key = this.key;
+  var sibling = this.getSibling(--_key);
+  var siblings = [];
 
   while (sibling.node) {
     siblings.push(sibling);
@@ -118,7 +118,7 @@ function getAllPrevSiblings() {
 
 function get(key, context) {
   if (context === true) context = this.context;
-  const parts = key.split(".");
+  var parts = key.split(".");
 
   if (parts.length === 1) {
     return this._getKey(key, context);
@@ -128,14 +128,16 @@ function get(key, context) {
 }
 
 function _getKey(key, context) {
-  const node = this.node;
-  const container = node[key];
+  var _this = this;
+
+  var node = this.node;
+  var container = node[key];
 
   if (Array.isArray(container)) {
-    return container.map((_, i) => {
+    return container.map(function (_, i) {
       return _index.default.get({
         listKey: key,
-        parentPath: this,
+        parentPath: _this,
         parent: node,
         container: container,
         key: i
@@ -152,9 +154,12 @@ function _getKey(key, context) {
 }
 
 function _getPattern(parts, context) {
-  let path = this;
+  var path = this;
+  var _arr = parts;
+
+  for (var _i = 0; _i < _arr.length; _i++) {
+    var part = _arr[_i];
 
-  for (const part of parts) {
     if (part === ".") {
       path = path.parentPath;
     } else {
@@ -177,20 +182,28 @@ function getOuterBindingIdentifiers(duplicates) {
   return t().getOuterBindingIdentifiers(this.node, duplicates);
 }
 
-function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
-  const path = this;
-  let search = [].concat(path);
-  const ids = Object.create(null);
+function getBindingIdentifierPaths(duplicates, outerOnly) {
+  if (duplicates === void 0) {
+    duplicates = false;
+  }
+
+  if (outerOnly === void 0) {
+    outerOnly = false;
+  }
+
+  var path = this;
+  var search = [].concat(path);
+  var ids = Object.create(null);
 
   while (search.length) {
-    const id = search.shift();
+    var id = search.shift();
     if (!id) continue;
     if (!id.node) continue;
-    const keys = t().getBindingIdentifiers.keys[id.node.type];
+    var keys = t().getBindingIdentifiers.keys[id.node.type];
 
     if (id.isIdentifier()) {
       if (duplicates) {
-        const _ids = ids[id.node.name] = ids[id.node.name] || [];
+        var _ids = ids[id.node.name] = ids[id.node.name] || [];
 
         _ids.push(id);
       } else {
@@ -201,7 +214,7 @@ function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
     }
 
     if (id.isExportDeclaration()) {
-      const declaration = id.get("declaration");
+      var declaration = id.get("declaration");
 
       if (declaration.isDeclaration()) {
         search.push(declaration);
@@ -222,9 +235,9 @@ function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
     }
 
     if (keys) {
-      for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const child = id.get(key);
+      for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        var child = id.get(key);
 
         if (Array.isArray(child) || child.node) {
           search = search.concat(child);