text: 'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.getVariableValues = getVariableValues;
  exports.getArgumentValues = getArgumentValues;
  exports.getDirectiveValues = getDirectiveValues;
  
  var _error = require('../error');
  
  var _find = require('../jsutils/find');
  
  var _find2 = _interopRequireDefault(_find);
  
  var _isInvalid = require('../jsutils/isInvalid');
  
  var _isInvalid2 = _interopRequireDefault(_isInvalid);
  
  var _keyMap = require('../jsutils/keyMap');
  
  var _keyMap2 = _interopRequireDefault(_keyMap);
  
  var _coerceValue = require('../utilities/coerceValue');
  
  var _typeFromAST = require('../utilities/typeFromAST');
  
  var _valueFromAST = require('../utilities/valueFromAST');
  
  var _kinds = require('../language/kinds');
  
  var _printer = require('../language/printer');
  
  var _definition = require('../type/definition');
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  /**
   * Prepares an object map of variableValues of the correct type based on the
   * provided variable definitions and arbitrary input. If the input cannot be
   * parsed to match the variable definitions, a GraphQLError will be thrown.
   *
   * Note: The returned value is a plain Object with a prototype, since it is
   * exposed to user code. Care should be taken to not pull values from the
   * Object prototype.
   */
  /**
   * Copyright (c) 2015-present, Facebook, Inc.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   *
   *  strict
   */
  
  function getVariableValues(schema, varDefNodes, inputs) {
    var errors = [];
    var coercedValues = {};
    for (var i = 0; i < varDefNodes.length; i++) {
      var varDefNode = varDefNodes[i];
      var varName = varDefNode.variable.name.value;
      var varType = (0, _typeFromAST.typeFromAST)(schema, varDefNode.type);
      if (!(0, _definition.isInputType)(varType)) {
        errors.push(new _error.GraphQLError('Variable "$' + varName + '" expected value of type ' + ('"' + (0, _printer.print)(varDefNode.type) + '" which cannot be used as an input type.'), [varDefNode.type]));
      } else {
        var value = inputs[varName];
        if ((0, _isInvalid2.default)(value)) {
          if ((0, _definition.isNonNullType)(varType)) {
            errors.push(new _error.GraphQLError('Variable "$' + varName + '" of required type ' + ('"' + String(varType) + '" was not provided.'), [varDefNode]));
          } else if (varDefNode.defaultValue) {
            coercedValues[varName] = (0, _valueFromAST.valueFromAST)(varDefNode.defaultValue, varType);
          }
        } else {
          var _coerced = (0, _coerceValue.coerceValue)(value, varType, varDefNode);
          var coercionErrors = _coerced.errors;
          if (coercionErrors) {
            (function () {
              var messagePrelude = 'Variable "$' + varName + '" got invalid value ' + JSON.stringify(value) + '; ';
              coercionErrors.forEach(function (error) {
                error.message = messagePrelude + error.message;
              });
              errors.push.apply(errors, coercionErrors);
            })();
          } else {
            coercedValues[varName] = _coerced.value;
          }
        }
      }
    }
    return errors.length === 0 ? { errors: undefined, coerced: coercedValues } : { errors: errors, coerced: undefined };
  }
  
  /**
   * Prepares an object map of argument values given a list of argument
   * definitions and list of argument AST nodes.
   *
   * Note: The returned value is a plain Object with a prototype, since it is
   * exposed to user code. Care should be taken to not pull values from the
   * Object prototype.
   */
  function getArgumentValues(def, node, variableValues) {
    var coercedValues = {};
    var argDefs = def.args;
    var argNodes = node.arguments;
    if (!argDefs || !argNodes) {
      return coercedValues;
    }
    var argNodeMap = (0, _keyMap2.default)(argNodes, function (arg) {
      return arg.name.value;
    });
    for (var i = 0; i < argDefs.length; i++) {
      var argDef = argDefs[i];
      var name = argDef.name;
      var argType = argDef.type;
      var argumentNode = argNodeMap[name];
      var defaultValue = argDef.defaultValue;
      if (!argumentNode) {
        if (!(0, _isInvalid2.default)(defaultValue)) {
          coercedValues[name] = defaultValue;
        } else if ((0, _definition.isNonNullType)(argType)) {
          throw new _error.GraphQLError('Argument "' + name + '" of required type ' + ('"' + String(argType) + '" was not provided.'), [node]);
        }
      } else if (argumentNode.value.kind === _kinds.Kind.VARIABLE) {
        var variableName = argumentNode.value.name.value;
        if (variableValues && Object.prototype.hasOwnProperty.call(variableValues, variableName) && !(0, _isInvalid2.default)(variableValues[variableName])) {
          // Note: this does not check that this variable value is correct.
          // This assumes that this query has been validated and the variable
          // usage here is of the correct type.
          coercedValues[name] = variableValues[variableName];
        } else if (!(0, _isInvalid2.default)(defaultValue)) {
          coercedValues[name] = defaultValue;
        } else if ((0, _definition.isNonNullType)(argType)) {
          throw new _error.GraphQLError('Argument "' + name + '" of required type "' + String(argType) + '" was ' + ('provided the variable "$' + variableName + '" which was not provided ') + 'a runtime value.', [argumentNode.value]);
        }
      } else {
        var valueNode = argumentNode.value;
        var coercedValue = (0, _valueFromAST.valueFromAST)(valueNode, argType, variableValues);
        if ((0, _isInvalid2.default)(coercedValue)) {
          // Note: ValuesOfCorrectType validation should catch this before
          // execution. This is a runtime check to ensure execution does not
          // continue with an invalid argument value.
          throw new _error.GraphQLError('Argument "' + name + '" has invalid value ' + (0, _printer.print)(valueNode) + '.', [argumentNode.value]);
        }
        coercedValues[name] = coercedValue;
      }
    }
    return coercedValues;
  }
  
  /**
   * Prepares an object map of argument values given a directive definition
   * and a AST node which may contain directives. Optionally also accepts a map
   * of variable values.
   *
   * If the directive does not exist on the node, returns undefined.
   *
   * Note: The returned value is a plain Object with a prototype, since it is
   * exposed to user code. Care should be taken to not pull values from the
   * Object prototype.
   */
  function getDirectiveValues(directiveDef, node, variableValues) {
    var directiveNode = node.directives && (0, _find2.default)(node.directives, function (directive) {
      return directive.name.value === directiveDef.name;
    });
  
    if (directiveNode) {
      return getArgumentValues(directiveDef, directiveNode, variableValues);
    }
  }