text: "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = _default;
  
  function t() {
    const data = _interopRequireWildcard(require("@babel/types"));
  
    t = function () {
      return data;
    };
  
    return data;
  }
  
  function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
  
  function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
  
  function _default(node) {
    if (!this.isReferenced()) return;
    const binding = this.scope.getBinding(node.name);
  
    if (binding) {
      if (binding.identifier.typeAnnotation) {
        return binding.identifier.typeAnnotation;
      } else {
        return getTypeAnnotationBindingConstantViolations(binding, this, node.name);
      }
    }
  
    if (node.name === "undefined") {
      return t().voidTypeAnnotation();
    } else if (node.name === "NaN" || node.name === "Infinity") {
      return t().numberTypeAnnotation();
    } else if (node.name === "arguments") {}
  }
  
  function getTypeAnnotationBindingConstantViolations(binding, path, name) {
    const types = [];
    const functionConstantViolations = [];
    let constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations);
    const testType = getConditionalAnnotation(binding, path, name);
  
    if (testType) {
      const testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
      constantViolations = constantViolations.filter(path => testConstantViolations.indexOf(path) < 0);
      types.push(testType.typeAnnotation);
    }
  
    if (constantViolations.length) {
      constantViolations = constantViolations.concat(functionConstantViolations);
  
      for (const violation of constantViolations) {
        types.push(violation.getTypeAnnotation());
      }
    }
  
    if (types.length) {
      return t().createUnionTypeAnnotation(types);
    }
  }
  
  function getConstantViolationsBefore(binding, path, functions) {
    const violations = binding.constantViolations.slice();
    violations.unshift(binding.path);
    return violations.filter(violation => {
      violation = violation.resolve();
  
      const status = violation._guessExecutionStatusRelativeTo(path);
  
      if (functions && status === "unknown") functions.push(violation);
      return status === "before";
    });
  }
  
  function inferAnnotationFromBinaryExpression(name, path) {
    const operator = path.node.operator;
    const right = path.get("right").resolve();
    const left = path.get("left").resolve();
    let target;
  
    if (left.isIdentifier({
      name
    })) {
      target = right;
    } else if (right.isIdentifier({
      name
    })) {
      target = left;
    }
  
    if (target) {
      if (operator === "===") {
        return target.getTypeAnnotation();
      }
  
      if (t().BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
        return t().numberTypeAnnotation();
      }
  
      return;
    }
  
    if (operator !== "===" && operator !== "==") return;
    let typeofPath;
    let typePath;
  
    if (left.isUnaryExpression({
      operator: "typeof"
    })) {
      typeofPath = left;
      typePath = right;
    } else if (right.isUnaryExpression({
      operator: "typeof"
    })) {
      typeofPath = right;
      typePath = left;
    }
  
    if (!typeofPath) return;
    if (!typeofPath.get("argument").isIdentifier({
      name
    })) return;
    typePath = typePath.resolve();
    if (!typePath.isLiteral()) return;
    const typeValue = typePath.node.value;
    if (typeof typeValue !== "string") return;
    return t().createTypeAnnotationBasedOnTypeof(typeValue);
  }
  
  function getParentConditionalPath(binding, path, name) {
    let parentPath;
  
    while (parentPath = path.parentPath) {
      if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) {
        if (path.key === "test") {
          return;
        }
  
        return parentPath;
      }
  
      if (parentPath.isFunction()) {
        if (parentPath.parentPath.scope.getBinding(name) !== binding) return;
      }
  
      path = parentPath;
    }
  }
  
  function getConditionalAnnotation(binding, path, name) {
    const ifStatement = getParentConditionalPath(binding, path, name);
    if (!ifStatement) return;
    const test = ifStatement.get("test");
    const paths = [test];
    const types = [];
  
    for (let i = 0; i < paths.length; i++) {
      const path = paths[i];
  
      if (path.isLogicalExpression()) {
        if (path.node.operator === "&&") {
          paths.push(path.get("left"));
          paths.push(path.get("right"));
        }
      } else if (path.isBinaryExpression()) {
        const type = inferAnnotationFromBinaryExpression(name, path);
        if (type) types.push(type);
      }
    }
  
    if (types.length) {
      return {
        typeAnnotation: t().createUnionTypeAnnotation(types),
        ifStatement
      };
    }
  
    return getConditionalAnnotation(ifStatement, name);
  }