text: /* */ 
  "format cjs";
  "use strict";
  
  exports.__esModule = true;
  // istanbul ignore next
  
  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; } }
  
  var _types = require("../../../types");
  
  var t = _interopRequireWildcard(_types);
  
  /**
   * [Please add a description.]
   */
  
  exports["default"] = function (node) {
    if (!this.isReferenced()) return;
  
    // check if a binding exists of this value and if so then return a union type of all
    // possible types that the binding could be
    var binding = this.scope.getBinding(node.name);
    if (binding) {
      if (binding.identifier.typeAnnotation) {
        return binding.identifier.typeAnnotation;
      } else {
        return getTypeAnnotationBindingConstantViolations(this, node.name);
      }
    }
  
    // built-in values
    if (node.name === "undefined") {
      return t.voidTypeAnnotation();
    } else if (node.name === "NaN" || node.name === "Infinity") {
      return t.numberTypeAnnotation();
    } else if (node.name === "arguments") {
      // todo
    }
  };
  
  /**
   * [Please add a description.]
   */
  
  function getTypeAnnotationBindingConstantViolations(path, name) {
    var binding = path.scope.getBinding(name);
  
    var types = [];
    path.typeAnnotation = t.unionTypeAnnotation(types);
  
    var functionConstantViolations = [];
    var constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations);
  
    var testType = getConditionalAnnotation(path, name);
    if (testType) {
      var testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
  
      // remove constant violations observed before the IfStatement
      constantViolations = constantViolations.filter(function (path) {
        return testConstantViolations.indexOf(path) < 0;
      });
  
      // clear current types and add in observed test type
      types.push(testType.typeAnnotation);
    }
  
    if (constantViolations.length) {
      // pick one constant from each scope which will represent the last possible
      // control flow path that it could've taken/been
      var rawConstantViolations = constantViolations.reverse();
      var visitedScopes = [];
      constantViolations = [];
      var _arr = rawConstantViolations;
      for (var _i = 0; _i < _arr.length; _i++) {
        var violation = _arr[_i];
        var violationScope = violation.scope;
        if (visitedScopes.indexOf(violationScope) >= 0) continue;
  
        visitedScopes.push(violationScope);
        constantViolations.push(violation);
  
        if (violationScope === path.scope) {
          constantViolations = [violation];
          break;
        }
      }
  
      // add back on function constant violations since we can't track calls
      constantViolations = constantViolations.concat(functionConstantViolations);
  
      // push on inferred types of violated paths
      var _arr2 = constantViolations;
      for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
        var violation = _arr2[_i2];
        types.push(violation.getTypeAnnotation());
      }
    }
  
    if (types.length) {
      return t.createUnionTypeAnnotation(types);
    }
  }
  
  /**
   * [Please add a description.]
   */
  
  function getConstantViolationsBefore(binding, path, functions) {
    var violations = binding.constantViolations.slice();
    violations.unshift(binding.path);
    return violations.filter(function (violation) {
      violation = violation.resolve();
      var status = violation._guessExecutionStatusRelativeTo(path);
      if (functions && status === "function") functions.push(violation);
      return status === "before";
    });
  }
  
  /**
   * [Please add a description.]
   */
  
  function inferAnnotationFromBinaryExpression(name, path) {
    var operator = path.node.operator;
  
    var right = path.get("right").resolve();
    var left = path.get("left").resolve();
  
    var target;
    if (left.isIdentifier({ name: name })) {
      target = right;
    } else if (right.isIdentifier({ name: name })) {
      target = left;
    }
    if (target) {
      if (operator === "===") {
        return target.getTypeAnnotation();
      } else if (t.BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
        return t.numberTypeAnnotation();
      } else {
        return;
      }
    } else {
      if (operator !== "===") return;
    }
  
    //
    var typeofPath;
    var typePath;
    if (left.isUnaryExpression({ operator: "typeof" })) {
      typeofPath = left;
      typePath = right;
    } else if (right.isUnaryExpression({ operator: "typeof" })) {
      typeofPath = right;
      typePath = left;
    }
    if (!typePath && !typeofPath) return;
  
    // ensure that the type path is a Literal
    typePath = typePath.resolve();
    if (!typePath.isLiteral()) return;
  
    // and that it's a string so we can infer it
    var typeValue = typePath.node.value;
    if (typeof typeValue !== "string") return;
  
    // and that the argument of the typeof path references us!
    if (!typeofPath.get("argument").isIdentifier({ name: name })) return;
  
    // turn type value into a type annotation
    return t.createTypeAnnotationBasedOnTypeof(typePath.node.value);
  }
  
  /**
   * [Please add a description.]
   */
  
  function getParentConditionalPath(path) {
    var parentPath;
    while (parentPath = path.parentPath) {
      if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) {
        if (path.key === "test") {
          return;
        } else {
          return parentPath;
        }
      } else {
        path = parentPath;
      }
    }
  }
  
  /**
   * [Please add a description.]
   */
  
  function getConditionalAnnotation(path, name) {
    var ifStatement = getParentConditionalPath(path);
    if (!ifStatement) return;
  
    var test = ifStatement.get("test");
    var paths = [test];
    var types = [];
  
    do {
      var _path = paths.shift().resolve();
  
      if (_path.isLogicalExpression()) {
        paths.push(_path.get("left"));
        paths.push(_path.get("right"));
      }
  
      if (_path.isBinaryExpression()) {
        var type = inferAnnotationFromBinaryExpression(name, _path);
        if (type) types.push(type);
      }
    } while (paths.length);
  
    if (types.length) {
      return {
        typeAnnotation: t.createUnionTypeAnnotation(types),
        ifStatement: ifStatement
      };
    } else {
      return getConditionalAnnotation(ifStatement, name);
    }
  }
  module.exports = exports["default"];