text: var SubscriptionsTransportWs =
  /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, {
  /******/ 				configurable: false,
  /******/ 				enumerable: true,
  /******/ 				get: getter
  /******/ 			});
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = 1);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ (function(module, exports) {
  
  var g;
  
  // This works in non-strict mode
  g = (function() {
  	return this;
  })();
  
  try {
  	// This works if eval is allowed (see CSP)
  	g = g || Function("return this")() || (1,eval)("this");
  } catch(e) {
  	// This works if the window reference is available
  	if(typeof window === "object")
  		g = window;
  }
  
  // g can still be undefined, but nothing to do about it...
  // We return undefined, instead of nothing here, so it's
  // easier to handle this case. if(!global) { ...}
  
  module.exports = g;
  
  
  /***/ }),
  /* 1 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(global) {
  var __assign = (this && this.__assign) || Object.assign || function(t) {
      for (var s, i = 1, n = arguments.length; i < n; i++) {
          s = arguments[i];
          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
              t[p] = s[p];
      }
      return t;
  };
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  var __generator = (this && this.__generator) || function (thisArg, body) {
      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
      function verb(n) { return function (v) { return step([n, v]); }; }
      function step(op) {
          if (f) throw new TypeError("Generator is already executing.");
          while (_) try {
              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
              if (y = 0, t) op = [op[0] & 2, t.value];
              switch (op[0]) {
                  case 0: case 1: t = op; break;
                  case 4: _.label++; return { value: op[1], done: false };
                  case 5: _.label++; y = op[1]; op = [0]; continue;
                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
                  default:
                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                      if (t[2]) _.ops.pop();
                      _.trys.pop(); continue;
              }
              op = body.call(thisArg, _);
          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
          if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
      }
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  var _global = typeof global !== 'undefined' ? global : (typeof window !== 'undefined' ? window : {});
  var NativeWebSocket = _global.WebSocket || _global.MozWebSocket;
  var Backoff = __webpack_require__(2);
  var eventemitter3_1 = __webpack_require__(3);
  var is_string_1 = __webpack_require__(4);
  var is_object_1 = __webpack_require__(5);
  var printer_1 = __webpack_require__(6);
  var getOperationAST_1 = __webpack_require__(8);
  var symbol_observable_1 = __webpack_require__(10);
  var protocol_1 = __webpack_require__(13);
  var defaults_1 = __webpack_require__(14);
  var message_types_1 = __webpack_require__(15);
  var SubscriptionClient = (function () {
      function SubscriptionClient(url, options, webSocketImpl) {
          var _a = (options || {}), _b = _a.connectionCallback, connectionCallback = _b === void 0 ? undefined : _b, _c = _a.connectionParams, connectionParams = _c === void 0 ? {} : _c, _d = _a.timeout, timeout = _d === void 0 ? defaults_1.WS_TIMEOUT : _d, _e = _a.reconnect, reconnect = _e === void 0 ? false : _e, _f = _a.reconnectionAttempts, reconnectionAttempts = _f === void 0 ? Infinity : _f, _g = _a.lazy, lazy = _g === void 0 ? false : _g, _h = _a.inactivityTimeout, inactivityTimeout = _h === void 0 ? 0 : _h;
          this.wsImpl = webSocketImpl || NativeWebSocket;
          if (!this.wsImpl) {
              throw new Error('Unable to find native implementation, or alternative implementation for WebSocket!');
          }
          this.connectionCallback = connectionCallback;
          this.url = url;
          this.operations = {};
          this.nextOperationId = 0;
          this.wsTimeout = timeout;
          this.unsentMessagesQueue = [];
          this.reconnect = reconnect;
          this.reconnecting = false;
          this.reconnectionAttempts = reconnectionAttempts;
          this.lazy = !!lazy;
          this.inactivityTimeout = inactivityTimeout;
          this.closedByUser = false;
          this.backoff = new Backoff({ jitter: 0.5 });
          this.eventEmitter = new eventemitter3_1.EventEmitter();
          this.middlewares = [];
          this.client = null;
          this.maxConnectTimeGenerator = this.createMaxConnectTimeGenerator();
          this.connectionParams = this.getConnectionParams(connectionParams);
          if (!this.lazy) {
              this.connect();
          }
      }
      Object.defineProperty(SubscriptionClient.prototype, "status", {
          get: function () {
              if (this.client === null) {
                  return this.wsImpl.CLOSED;
              }
              return this.client.readyState;
          },
          enumerable: true,
          configurable: true
      });
      SubscriptionClient.prototype.close = function (isForced, closedByUser) {
          if (isForced === void 0) { isForced = true; }
          if (closedByUser === void 0) { closedByUser = true; }
          this.clearInactivityTimeout();
          if (this.client !== null) {
              this.closedByUser = closedByUser;
              if (isForced) {
                  this.clearCheckConnectionInterval();
                  this.clearMaxConnectTimeout();
                  this.clearTryReconnectTimeout();
                  this.unsubscribeAll();
                  this.sendMessage(undefined, message_types_1.default.GQL_CONNECTION_TERMINATE, null);
              }
              this.client.close();
              this.client = null;
              this.eventEmitter.emit('disconnected');
              if (!isForced) {
                  this.tryReconnect();
              }
          }
      };
      SubscriptionClient.prototype.request = function (request) {
          var _a;
          var getObserver = this.getObserver.bind(this);
          var executeOperation = this.executeOperation.bind(this);
          var unsubscribe = this.unsubscribe.bind(this);
          var opId;
          this.clearInactivityTimeout();
          return _a = {},
              _a[symbol_observable_1.default] = function () {
                  return this;
              },
              _a.subscribe = function (observerOrNext, onError, onComplete) {
                  var observer = getObserver(observerOrNext, onError, onComplete);
                  opId = executeOperation(request, function (error, result) {
                      if (error === null && result === null) {
                          if (observer.complete) {
                              observer.complete();
                          }
                      }
                      else if (error) {
                          if (observer.error) {
                              observer.error(error[0]);
                          }
                      }
                      else {
                          if (observer.next) {
                              observer.next(result);
                          }
                      }
                  });
                  return {
                      unsubscribe: function () {
                          if (opId) {
                              unsubscribe(opId);
                              opId = null;
                          }
                      },
                  };
              },
              _a;
      };
      SubscriptionClient.prototype.on = function (eventName, callback, context) {
          var handler = this.eventEmitter.on(eventName, callback, context);
          return function () {
              handler.off(eventName, callback, context);
          };
      };
      SubscriptionClient.prototype.onConnected = function (callback, context) {
          return this.on('connected', callback, context);
      };
      SubscriptionClient.prototype.onConnecting = function (callback, context) {
          return this.on('connecting', callback, context);
      };
      SubscriptionClient.prototype.onDisconnected = function (callback, context) {
          return this.on('disconnected', callback, context);
      };
      SubscriptionClient.prototype.onReconnected = function (callback, context) {
          return this.on('reconnected', callback, context);
      };
      SubscriptionClient.prototype.onReconnecting = function (callback, context) {
          return this.on('reconnecting', callback, context);
      };
      SubscriptionClient.prototype.onError = function (callback, context) {
          return this.on('error', callback, context);
      };
      SubscriptionClient.prototype.unsubscribeAll = function () {
          var _this = this;
          Object.keys(this.operations).forEach(function (subId) {
              _this.unsubscribe(subId);
          });
      };
      SubscriptionClient.prototype.applyMiddlewares = function (options) {
          var _this = this;
          return new Promise(function (resolve, reject) {
              var queue = function (funcs, scope) {
                  var next = function (error) {
                      if (error) {
                          reject(error);
                      }
                      else {
                          if (funcs.length > 0) {
                              var f = funcs.shift();
                              if (f) {
                                  f.applyMiddleware.apply(scope, [options, next]);
                              }
                          }
                          else {
                              resolve(options);
                          }
                      }
                  };
                  next();
              };
              queue(_this.middlewares.slice(), _this);
          });
      };
      SubscriptionClient.prototype.use = function (middlewares) {
          var _this = this;
          middlewares.map(function (middleware) {
              if (typeof middleware.applyMiddleware === 'function') {
                  _this.middlewares.push(middleware);
              }
              else {
                  throw new Error('Middleware must implement the applyMiddleware function.');
              }
          });
          return this;
      };
      SubscriptionClient.prototype.getConnectionParams = function (connectionParams) {
          return function () { return new Promise(function (resolve, reject) {
              if (typeof connectionParams === 'function') {
                  try {
                      return resolve(connectionParams.call(null));
                  }
                  catch (error) {
                      return reject(error);
                  }
              }
              resolve(connectionParams);
          }); };
      };
      SubscriptionClient.prototype.executeOperation = function (options, handler) {
          var _this = this;
          if (this.client === null) {
              this.connect();
          }
          var opId = this.generateOperationId();
          this.operations[opId] = { options: options, handler: handler };
          this.applyMiddlewares(options)
              .then(function (processedOptions) {
              _this.checkOperationOptions(processedOptions, handler);
              if (_this.operations[opId]) {
                  _this.operations[opId] = { options: processedOptions, handler: handler };
                  _this.sendMessage(opId, message_types_1.default.GQL_START, processedOptions);
              }
          })
              .catch(function (error) {
              _this.unsubscribe(opId);
              handler(_this.formatErrors(error));
          });
          return opId;
      };
      SubscriptionClient.prototype.getObserver = function (observerOrNext, error, complete) {
          if (typeof observerOrNext === 'function') {
              return {
                  next: function (v) { return observerOrNext(v); },
                  error: function (e) { return error && error(e); },
                  complete: function () { return complete && complete(); },
              };
          }
          return observerOrNext;
      };
      SubscriptionClient.prototype.createMaxConnectTimeGenerator = function () {
          var minValue = 1000;
          var maxValue = this.wsTimeout;
          return new Backoff({
              min: minValue,
              max: maxValue,
              factor: 1.2,
          });
      };
      SubscriptionClient.prototype.clearCheckConnectionInterval = function () {
          if (this.checkConnectionIntervalId) {
              clearInterval(this.checkConnectionIntervalId);
              this.checkConnectionIntervalId = null;
          }
      };
      SubscriptionClient.prototype.clearMaxConnectTimeout = function () {
          if (this.maxConnectTimeoutId) {
              clearTimeout(this.maxConnectTimeoutId);
              this.maxConnectTimeoutId = null;
          }
      };
      SubscriptionClient.prototype.clearTryReconnectTimeout = function () {
          if (this.tryReconnectTimeoutId) {
              clearTimeout(this.tryReconnectTimeoutId);
              this.tryReconnectTimeoutId = null;
          }
      };
      SubscriptionClient.prototype.clearInactivityTimeout = function () {
          if (this.inactivityTimeoutId) {
              clearTimeout(this.inactivityTimeoutId);
              this.inactivityTimeoutId = null;
          }
      };
      SubscriptionClient.prototype.setInactivityTimeout = function () {
          var _this = this;
          if (this.inactivityTimeout > 0 && Object.keys(this.operations).length === 0) {
              this.inactivityTimeoutId = setTimeout(function () {
                  if (Object.keys(_this.operations).length === 0) {
                      _this.close();
                  }
              }, this.inactivityTimeout);
          }
      };
      SubscriptionClient.prototype.checkOperationOptions = function (options, handler) {
          var query = options.query, variables = options.variables, operationName = options.operationName;
          if (!query) {
              throw new Error('Must provide a query.');
          }
          if (!handler) {
              throw new Error('Must provide an handler.');
          }
          if ((!is_string_1.default(query) && !getOperationAST_1.getOperationAST(query, operationName)) ||
              (operationName && !is_string_1.default(operationName)) ||
              (variables && !is_object_1.default(variables))) {
              throw new Error('Incorrect option types. query must be a string or a document,' +
                  '`operationName` must be a string, and `variables` must be an object.');
          }
      };
      SubscriptionClient.prototype.buildMessage = function (id, type, payload) {
          var payloadToReturn = payload && payload.query ? __assign({}, payload, { query: typeof payload.query === 'string' ? payload.query : printer_1.print(payload.query) }) :
              payload;
          return {
              id: id,
              type: type,
              payload: payloadToReturn,
          };
      };
      SubscriptionClient.prototype.formatErrors = function (errors) {
          if (Array.isArray(errors)) {
              return errors;
          }
          if (errors && errors.errors) {
              return this.formatErrors(errors.errors);
          }
          if (errors && errors.message) {
              return [errors];
          }
          return [{
                  name: 'FormatedError',
                  message: 'Unknown error',
                  originalError: errors,
              }];
      };
      SubscriptionClient.prototype.sendMessage = function (id, type, payload) {
          this.sendMessageRaw(this.buildMessage(id, type, payload));
      };
      SubscriptionClient.prototype.sendMessageRaw = function (message) {
          switch (this.status) {
              case this.wsImpl.OPEN:
                  var serializedMessage = JSON.stringify(message);
                  try {
                      JSON.parse(serializedMessage);
                  }
                  catch (e) {
                      this.eventEmitter.emit('error', new Error("Message must be JSON-serializable. Got: " + message));
                  }
                  this.client.send(serializedMessage);
                  break;
              case this.wsImpl.CONNECTING:
                  this.unsentMessagesQueue.push(message);
                  break;
              default:
                  if (!this.reconnecting) {
                      this.eventEmitter.emit('error', new Error('A message was not sent because socket is not connected, is closing or ' +
                          'is already closed. Message was: ' + JSON.stringify(message)));
                  }
          }
      };
      SubscriptionClient.prototype.generateOperationId = function () {
          return String(++this.nextOperationId);
      };
      SubscriptionClient.prototype.tryReconnect = function () {
          var _this = this;
          if (!this.reconnect || this.backoff.attempts >= this.reconnectionAttempts) {
              return;
          }
          if (!this.reconnecting) {
              Object.keys(this.operations).forEach(function (key) {
                  _this.unsentMessagesQueue.push(_this.buildMessage(key, message_types_1.default.GQL_START, _this.operations[key].options));
              });
              this.reconnecting = true;
          }
          this.clearTryReconnectTimeout();
          var delay = this.backoff.duration();
          this.tryReconnectTimeoutId = setTimeout(function () {
              _this.connect();
          }, delay);
      };
      SubscriptionClient.prototype.flushUnsentMessagesQueue = function () {
          var _this = this;
          this.unsentMessagesQueue.forEach(function (message) {
              _this.sendMessageRaw(message);
          });
          this.unsentMessagesQueue = [];
      };
      SubscriptionClient.prototype.checkConnection = function () {
          if (this.wasKeepAliveReceived) {
              this.wasKeepAliveReceived = false;
              return;
          }
          if (!this.reconnecting) {
              this.close(false, true);
          }
      };
      SubscriptionClient.prototype.checkMaxConnectTimeout = function () {
          var _this = this;
          this.clearMaxConnectTimeout();
          this.maxConnectTimeoutId = setTimeout(function () {
              if (_this.status !== _this.wsImpl.OPEN) {
                  _this.reconnecting = true;
                  _this.close(false, true);
              }
          }, this.maxConnectTimeGenerator.duration());
      };
      SubscriptionClient.prototype.connect = function () {
          var _this = this;
          this.client = new this.wsImpl(this.url, protocol_1.GRAPHQL_WS);
          this.checkMaxConnectTimeout();
          this.client.onopen = function () { return __awaiter(_this, void 0, void 0, function () {
              var connectionParams, error_1;
              return __generator(this, function (_a) {
                  switch (_a.label) {
                      case 0:
                          if (!(this.status === this.wsImpl.OPEN)) return [3, 4];
                          this.clearMaxConnectTimeout();
                          this.closedByUser = false;
                          this.eventEmitter.emit(this.reconnecting ? 'reconnecting' : 'connecting');
                          _a.label = 1;
                      case 1:
                          _a.trys.push([1, 3, , 4]);
                          return [4, this.connectionParams()];
                      case 2:
                          connectionParams = _a.sent();
                          this.sendMessage(undefined, message_types_1.default.GQL_CONNECTION_INIT, connectionParams);
                          this.flushUnsentMessagesQueue();
                          return [3, 4];
                      case 3:
                          error_1 = _a.sent();
                          this.sendMessage(undefined, message_types_1.default.GQL_CONNECTION_ERROR, error_1);
                          this.flushUnsentMessagesQueue();
                          return [3, 4];
                      case 4: return [2];
                  }
              });
          }); };
          this.client.onclose = function () {
              if (!_this.closedByUser) {
                  _this.close(false, false);
              }
          };
          this.client.onerror = function (err) {
              _this.eventEmitter.emit('error', err);
          };
          this.client.onmessage = function (_a) {
              var data = _a.data;
              _this.processReceivedData(data);
          };
      };
      SubscriptionClient.prototype.processReceivedData = function (receivedData) {
          var parsedMessage;
          var opId;
          try {
              parsedMessage = JSON.parse(receivedData);
              opId = parsedMessage.id;
          }
          catch (e) {
              throw new Error("Message must be JSON-parseable. Got: " + receivedData);
          }
          if ([message_types_1.default.GQL_DATA,
              message_types_1.default.GQL_COMPLETE,
              message_types_1.default.GQL_ERROR,
          ].indexOf(parsedMessage.type) !== -1 && !this.operations[opId]) {
              this.unsubscribe(opId);
              return;
          }
          switch (parsedMessage.type) {
              case message_types_1.default.GQL_CONNECTION_ERROR:
                  if (this.connectionCallback) {
                      this.connectionCallback(parsedMessage.payload);
                  }
                  break;
              case message_types_1.default.GQL_CONNECTION_ACK:
                  this.eventEmitter.emit(this.reconnecting ? 'reconnected' : 'connected');
                  this.reconnecting = false;
                  this.backoff.reset();
                  this.maxConnectTimeGenerator.reset();
                  if (this.connectionCallback) {
                      this.connectionCallback();
                  }
                  break;
              case message_types_1.default.GQL_COMPLETE:
                  this.operations[opId].handler(null, null);
                  delete this.operations[opId];
                  break;
              case message_types_1.default.GQL_ERROR:
                  this.operations[opId].handler(this.formatErrors(parsedMessage.payload), null);
                  delete this.operations[opId];
                  break;
              case message_types_1.default.GQL_DATA:
                  var parsedPayload = !parsedMessage.payload.errors ?
                      parsedMessage.payload : __assign({}, parsedMessage.payload, { errors: this.formatErrors(parsedMessage.payload.errors) });
                  this.operations[opId].handler(null, parsedPayload);
                  break;
              case message_types_1.default.GQL_CONNECTION_KEEP_ALIVE:
                  var firstKA = typeof this.wasKeepAliveReceived === 'undefined';
                  this.wasKeepAliveReceived = true;
                  if (firstKA) {
                      this.checkConnection();
                  }
                  if (this.checkConnectionIntervalId) {
                      clearInterval(this.checkConnectionIntervalId);
                      this.checkConnection();
                  }
                  this.checkConnectionIntervalId = setInterval(this.checkConnection.bind(this), this.wsTimeout);
                  break;
              default:
                  throw new Error('Invalid message type!');
          }
      };
      SubscriptionClient.prototype.unsubscribe = function (opId) {
          if (this.operations[opId]) {
              delete this.operations[opId];
              this.setInactivityTimeout();
              this.sendMessage(opId, message_types_1.default.GQL_STOP, undefined);
          }
      };
      return SubscriptionClient;
  }());
  exports.SubscriptionClient = SubscriptionClient;
  //# sourceMappingURL=client.js.map
  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
  
  /***/ }),
  /* 2 */
  /***/ (function(module, exports) {
  
  
  /**
   * Expose `Backoff`.
   */
  
  module.exports = Backoff;
  
  /**
   * Initialize backoff timer with `opts`.
   *
   * - `min` initial timeout in milliseconds [100]
   * - `max` max timeout [10000]
   * - `jitter` [0]
   * - `factor` [2]
   *
   * @param {Object} opts
   * @api public
   */
  
  function Backoff(opts) {
    opts = opts || {};
    this.ms = opts.min || 100;
    this.max = opts.max || 10000;
    this.factor = opts.factor || 2;
    this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
    this.attempts = 0;
  }
  
  /**
   * Return the backoff duration.
   *
   * @return {Number}
   * @api public
   */
  
  Backoff.prototype.duration = function(){
    var ms = this.ms * Math.pow(this.factor, this.attempts++);
    if (this.jitter) {
      var rand =  Math.random();
      var deviation = Math.floor(rand * this.jitter * ms);
      ms = (Math.floor(rand * 10) & 1) == 0  ? ms - deviation : ms + deviation;
    }
    return Math.min(ms, this.max) | 0;
  };
  
  /**
   * Reset the number of attempts.
   *
   * @api public
   */
  
  Backoff.prototype.reset = function(){
    this.attempts = 0;
  };
  
  /**
   * Set the minimum duration
   *
   * @api public
   */
  
  Backoff.prototype.setMin = function(min){
    this.ms = min;
  };
  
  /**
   * Set the maximum duration
   *
   * @api public
   */
  
  Backoff.prototype.setMax = function(max){
    this.max = max;
  };
  
  /**
   * Set the jitter
   *
   * @api public
   */
  
  Backoff.prototype.setJitter = function(jitter){
    this.jitter = jitter;
  };
  
  
  
  /***/ }),
  /* 3 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var has = Object.prototype.hasOwnProperty
    , prefix = '~';
  
  /**
   * Constructor to create a storage for our `EE` objects.
   * An `Events` instance is a plain object whose properties are event names.
   *
   * @constructor
   * @private
   */
  function Events() {}
  
  //
  // We try to not inherit from `Object.prototype`. In some engines creating an
  // instance in this way is faster than calling `Object.create(null)` directly.
  // If `Object.create(null)` is not supported we prefix the event names with a
  // character to make sure that the built-in object properties are not
  // overridden or used as an attack vector.
  //
  if (Object.create) {
    Events.prototype = Object.create(null);
  
    //
    // This hack is needed because the `__proto__` property is still inherited in
    // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
    //
    if (!new Events().__proto__) prefix = false;
  }
  
  /**
   * Representation of a single event listener.
   *
   * @param {Function} fn The listener function.
   * @param {*} context The context to invoke the listener with.
   * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
   * @constructor
   * @private
   */
  function EE(fn, context, once) {
    this.fn = fn;
    this.context = context;
    this.once = once || false;
  }
  
  /**
   * Add a listener for a given event.
   *
   * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
   * @param {(String|Symbol)} event The event name.
   * @param {Function} fn The listener function.
   * @param {*} context The context to invoke the listener with.
   * @param {Boolean} once Specify if the listener is a one-time listener.
   * @returns {EventEmitter}
   * @private
   */
  function addListener(emitter, event, fn, context, once) {
    if (typeof fn !== 'function') {
      throw new TypeError('The listener must be a function');
    }
  
    var listener = new EE(fn, context || emitter, once)
      , evt = prefix ? prefix + event : event;
  
    if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
    else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
    else emitter._events[evt] = [emitter._events[evt], listener];
  
    return emitter;
  }
  
  /**
   * Clear event by name.
   *
   * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
   * @param {(String|Symbol)} evt The Event name.
   * @private
   */
  function clearEvent(emitter, evt) {
    if (--emitter._eventsCount === 0) emitter._events = new Events();
    else delete emitter._events[evt];
  }
  
  /**
   * Minimal `EventEmitter` interface that is molded against the Node.js
   * `EventEmitter` interface.
   *
   * @constructor
   * @public
   */
  function EventEmitter() {
    this._events = new Events();
    this._eventsCount = 0;
  }
  
  /**
   * Return an array listing the events for which the emitter has registered
   * listeners.
   *
   * @returns {Array}
   * @public
   */
  EventEmitter.prototype.eventNames = function eventNames() {
    var names = []
      , events
      , name;
  
    if (this._eventsCount === 0) return names;
  
    for (name in (events = this._events)) {
      if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
    }
  
    if (Object.getOwnPropertySymbols) {
      return names.concat(Object.getOwnPropertySymbols(events));
    }
  
    return names;
  };
  
  /**
   * Return the listeners registered for a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @returns {Array} The registered listeners.
   * @public
   */
  EventEmitter.prototype.listeners = function listeners(event) {
    var evt = prefix ? prefix + event : event
      , handlers = this._events[evt];
  
    if (!handlers) return [];
    if (handlers.fn) return [handlers.fn];
  
    for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
      ee[i] = handlers[i].fn;
    }
  
    return ee;
  };
  
  /**
   * Return the number of listeners listening to a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @returns {Number} The number of listeners.
   * @public
   */
  EventEmitter.prototype.listenerCount = function listenerCount(event) {
    var evt = prefix ? prefix + event : event
      , listeners = this._events[evt];
  
    if (!listeners) return 0;
    if (listeners.fn) return 1;
    return listeners.length;
  };
  
  /**
   * Calls each of the listeners registered for a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @returns {Boolean} `true` if the event had listeners, else `false`.
   * @public
   */
  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
    var evt = prefix ? prefix + event : event;
  
    if (!this._events[evt]) return false;
  
    var listeners = this._events[evt]
      , len = arguments.length
      , args
      , i;
  
    if (listeners.fn) {
      if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
  
      switch (len) {
        case 1: return listeners.fn.call(listeners.context), true;
        case 2: return listeners.fn.call(listeners.context, a1), true;
        case 3: return listeners.fn.call(listeners.context, a1, a2), true;
        case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
        case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
        case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
      }
  
      for (i = 1, args = new Array(len -1); i < len; i++) {
        args[i - 1] = arguments[i];
      }
  
      listeners.fn.apply(listeners.context, args);
    } else {
      var length = listeners.length
        , j;
  
      for (i = 0; i < length; i++) {
        if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
  
        switch (len) {
          case 1: listeners[i].fn.call(listeners[i].context); break;
          case 2: listeners[i].fn.call(listeners[i].context, a1); break;
          case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
          case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
          default:
            if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
              args[j - 1] = arguments[j];
            }
  
            listeners[i].fn.apply(listeners[i].context, args);
        }
      }
    }
  
    return true;
  };
  
  /**
   * Add a listener for a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @param {Function} fn The listener function.
   * @param {*} [context=this] The context to invoke the listener with.
   * @returns {EventEmitter} `this`.
   * @public
   */
  EventEmitter.prototype.on = function on(event, fn, context) {
    return addListener(this, event, fn, context, false);
  };
  
  /**
   * Add a one-time listener for a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @param {Function} fn The listener function.
   * @param {*} [context=this] The context to invoke the listener with.
   * @returns {EventEmitter} `this`.
   * @public
   */
  EventEmitter.prototype.once = function once(event, fn, context) {
    return addListener(this, event, fn, context, true);
  };
  
  /**
   * Remove the listeners of a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @param {Function} fn Only remove the listeners that match this function.
   * @param {*} context Only remove the listeners that have this context.
   * @param {Boolean} once Only remove one-time listeners.
   * @returns {EventEmitter} `this`.
   * @public
   */
  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
    var evt = prefix ? prefix + event : event;
  
    if (!this._events[evt]) return this;
    if (!fn) {
      clearEvent(this, evt);
      return this;
    }
  
    var listeners = this._events[evt];
  
    if (listeners.fn) {
      if (
        listeners.fn === fn &&
        (!once || listeners.once) &&
        (!context || listeners.context === context)
      ) {
        clearEvent(this, evt);
      }
    } else {
      for (var i = 0, events = [], length = listeners.length; i < length; i++) {
        if (
          listeners[i].fn !== fn ||
          (once && !listeners[i].once) ||
          (context && listeners[i].context !== context)
        ) {
          events.push(listeners[i]);
        }
      }
  
      //
      // Reset the array, or remove it completely if we have no more listeners.
      //
      if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
      else clearEvent(this, evt);
    }
  
    return this;
  };
  
  /**
   * Remove all listeners, or those of the specified event.
   *
   * @param {(String|Symbol)} [event] The event name.
   * @returns {EventEmitter} `this`.
   * @public
   */
  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
    var evt;
  
    if (event) {
      evt = prefix ? prefix + event : event;
      if (this._events[evt]) clearEvent(this, evt);
    } else {
      this._events = new Events();
      this._eventsCount = 0;
    }
  
    return this;
  };
  
  //
  // Alias methods names because people roll like that.
  //
  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
  
  //
  // Expose the prefix.
  //
  EventEmitter.prefixed = prefix;
  
  //
  // Allow `EventEmitter` to be imported as module namespace.
  //
  EventEmitter.EventEmitter = EventEmitter;
  
  //
  // Expose the module.
  //
  if (true) {
    module.exports = EventEmitter;
  }
  
  
  /***/ }),
  /* 4 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  function isString(value) {
      return typeof value === 'string';
  }
  exports.default = isString;
  //# sourceMappingURL=is-string.js.map
  
  /***/ }),
  /* 5 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  function isObject(value) {
      return ((value !== null) && (typeof value === 'object'));
  }
  exports.default = isObject;
  //# sourceMappingURL=is-object.js.map
  
  /***/ }),
  /* 6 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.print = print;
  
  var _visitor = __webpack_require__(7);
  
  /**
   * Converts an AST into a string, using one set of reasonable
   * formatting rules.
   */
  function print(ast) {
    return (0, _visitor.visit)(ast, { leave: printDocASTReducer });
  } /**
     * 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.
     */
  
  var printDocASTReducer = {
    Name: function Name(node) {
      return node.value;
    },
    Variable: function Variable(node) {
      return '$' + node.name;
    },
  
    // Document
  
    Document: function Document(node) {
      return join(node.definitions, '\n\n') + '\n';
    },
  
    OperationDefinition: function OperationDefinition(node) {
      var op = node.operation;
      var name = node.name;
      var varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');
      var directives = join(node.directives, ' ');
      var selectionSet = node.selectionSet;
      // Anonymous queries with no directives or variable definitions can use
      // the query short form.
      return !name && !directives && !varDefs && op === 'query' ? selectionSet : join([op, join([name, varDefs]), directives, selectionSet], ' ');
    },
  
  
    VariableDefinition: function VariableDefinition(_ref) {
      var variable = _ref.variable,
          type = _ref.type,
          defaultValue = _ref.defaultValue;
      return variable + ': ' + type + wrap(' = ', defaultValue);
    },
  
    SelectionSet: function SelectionSet(_ref2) {
      var selections = _ref2.selections;
      return block(selections);
    },
  
    Field: function Field(_ref3) {
      var alias = _ref3.alias,
          name = _ref3.name,
          args = _ref3.arguments,
          directives = _ref3.directives,
          selectionSet = _ref3.selectionSet;
      return join([wrap('', alias, ': ') + name + wrap('(', join(args, ', '), ')'), join(directives, ' '), selectionSet], ' ');
    },
  
    Argument: function Argument(_ref4) {
      var name = _ref4.name,
          value = _ref4.value;
      return name + ': ' + value;
    },
  
    // Fragments
  
    FragmentSpread: function FragmentSpread(_ref5) {
      var name = _ref5.name,
          directives = _ref5.directives;
      return '...' + name + wrap(' ', join(directives, ' '));
    },
  
    InlineFragment: function InlineFragment(_ref6) {
      var typeCondition = _ref6.typeCondition,
          directives = _ref6.directives,
          selectionSet = _ref6.selectionSet;
      return join(['...', wrap('on ', typeCondition), join(directives, ' '), selectionSet], ' ');
    },
  
    FragmentDefinition: function FragmentDefinition(_ref7) {
      var name = _ref7.name,
          typeCondition = _ref7.typeCondition,
          variableDefinitions = _ref7.variableDefinitions,
          directives = _ref7.directives,
          selectionSet = _ref7.selectionSet;
      return (
        // Note: fragment variable definitions are experimental and may be changed
        // or removed in the future.
        'fragment ' + name + wrap('(', join(variableDefinitions, ', '), ')') + ' ' + ('on ' + typeCondition + ' ' + wrap('', join(directives, ' '), ' ')) + selectionSet
      );
    },
  
    // Value
  
    IntValue: function IntValue(_ref8) {
      var value = _ref8.value;
      return value;
    },
    FloatValue: function FloatValue(_ref9) {
      var value = _ref9.value;
      return value;
    },
    StringValue: function StringValue(_ref10, key) {
      var value = _ref10.value,
          isBlockString = _ref10.block;
      return isBlockString ? printBlockString(value, key === 'description') : JSON.stringify(value);
    },
    BooleanValue: function BooleanValue(_ref11) {
      var value = _ref11.value;
      return value ? 'true' : 'false';
    },
    NullValue: function NullValue() {
      return 'null';
    },
    EnumValue: function EnumValue(_ref12) {
      var value = _ref12.value;
      return value;
    },
    ListValue: function ListValue(_ref13) {
      var values = _ref13.values;
      return '[' + join(values, ', ') + ']';
    },
    ObjectValue: function ObjectValue(_ref14) {
      var fields = _ref14.fields;
      return '{' + join(fields, ', ') + '}';
    },
    ObjectField: function ObjectField(_ref15) {
      var name = _ref15.name,
          value = _ref15.value;
      return name + ': ' + value;
    },
  
    // Directive
  
    Directive: function Directive(_ref16) {
      var name = _ref16.name,
          args = _ref16.arguments;
      return '@' + name + wrap('(', join(args, ', '), ')');
    },
  
    // Type
  
    NamedType: function NamedType(_ref17) {
      var name = _ref17.name;
      return name;
    },
    ListType: function ListType(_ref18) {
      var type = _ref18.type;
      return '[' + type + ']';
    },
    NonNullType: function NonNullType(_ref19) {
      var type = _ref19.type;
      return type + '!';
    },
  
    // Type System Definitions
  
    SchemaDefinition: function SchemaDefinition(_ref20) {
      var directives = _ref20.directives,
          operationTypes = _ref20.operationTypes;
      return join(['schema', join(directives, ' '), block(operationTypes)], ' ');
    },
  
    OperationTypeDefinition: function OperationTypeDefinition(_ref21) {
      var operation = _ref21.operation,
          type = _ref21.type;
      return operation + ': ' + type;
    },
  
    ScalarTypeDefinition: addDescription(function (_ref22) {
      var name = _ref22.name,
          directives = _ref22.directives;
      return join(['scalar', name, join(directives, ' ')], ' ');
    }),
  
    ObjectTypeDefinition: addDescription(function (_ref23) {
      var name = _ref23.name,
          interfaces = _ref23.interfaces,
          directives = _ref23.directives,
          fields = _ref23.fields;
      return join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');
    }),
  
    FieldDefinition: addDescription(function (_ref24) {
      var name = _ref24.name,
          args = _ref24.arguments,
          type = _ref24.type,
          directives = _ref24.directives;
      return name + wrap('(', join(args, ', '), ')') + ': ' + type + wrap(' ', join(directives, ' '));
    }),
  
    InputValueDefinition: addDescription(function (_ref25) {
      var name = _ref25.name,
          type = _ref25.type,
          defaultValue = _ref25.defaultValue,
          directives = _ref25.directives;
      return join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' ');
    }),
  
    InterfaceTypeDefinition: addDescription(function (_ref26) {
      var name = _ref26.name,
          directives = _ref26.directives,
          fields = _ref26.fields;
      return join(['interface', name, join(directives, ' '), block(fields)], ' ');
    }),
  
    UnionTypeDefinition: addDescription(function (_ref27) {
      var name = _ref27.name,
          directives = _ref27.directives,
          types = _ref27.types;
      return join(['union', name, join(directives, ' '), types && types.length !== 0 ? '= ' + join(types, ' | ') : ''], ' ');
    }),
  
    EnumTypeDefinition: addDescription(function (_ref28) {
      var name = _ref28.name,
          directives = _ref28.directives,
          values = _ref28.values;
      return join(['enum', name, join(directives, ' '), block(values)], ' ');
    }),
  
    EnumValueDefinition: addDescription(function (_ref29) {
      var name = _ref29.name,
          directives = _ref29.directives;
      return join([name, join(directives, ' ')], ' ');
    }),
  
    InputObjectTypeDefinition: addDescription(function (_ref30) {
      var name = _ref30.name,
          directives = _ref30.directives,
          fields = _ref30.fields;
      return join(['input', name, join(directives, ' '), block(fields)], ' ');
    }),
  
    ScalarTypeExtension: function ScalarTypeExtension(_ref31) {
      var name = _ref31.name,
          directives = _ref31.directives;
      return join(['extend scalar', name, join(directives, ' ')], ' ');
    },
  
    ObjectTypeExtension: function ObjectTypeExtension(_ref32) {
      var name = _ref32.name,
          interfaces = _ref32.interfaces,
          directives = _ref32.directives,
          fields = _ref32.fields;
      return join(['extend type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');
    },
  
    InterfaceTypeExtension: function InterfaceTypeExtension(_ref33) {
      var name = _ref33.name,
          directives = _ref33.directives,
          fields = _ref33.fields;
      return join(['extend interface', name, join(directives, ' '), block(fields)], ' ');
    },
  
    UnionTypeExtension: function UnionTypeExtension(_ref34) {
      var name = _ref34.name,
          directives = _ref34.directives,
          types = _ref34.types;
      return join(['extend union', name, join(directives, ' '), types && types.length !== 0 ? '= ' + join(types, ' | ') : ''], ' ');
    },
  
    EnumTypeExtension: function EnumTypeExtension(_ref35) {
      var name = _ref35.name,
          directives = _ref35.directives,
          values = _ref35.values;
      return join(['extend enum', name, join(directives, ' '), block(values)], ' ');
    },
  
    InputObjectTypeExtension: function InputObjectTypeExtension(_ref36) {
      var name = _ref36.name,
          directives = _ref36.directives,
          fields = _ref36.fields;
      return join(['extend input', name, join(directives, ' '), block(fields)], ' ');
    },
  
    DirectiveDefinition: addDescription(function (_ref37) {
      var name = _ref37.name,
          args = _ref37.arguments,
          locations = _ref37.locations;
      return 'directive @' + name + wrap('(', join(args, ', '), ')') + ' on ' + join(locations, ' | ');
    })
  };
  
  function addDescription(cb) {
    return function (node) {
      return join([node.description, cb(node)], '\n');
    };
  }
  
  /**
   * Given maybeArray, print an empty string if it is null or empty, otherwise
   * print all items together separated by separator if provided
   */
  function join(maybeArray, separator) {
    return maybeArray ? maybeArray.filter(function (x) {
      return x;
    }).join(separator || '') : '';
  }
  
  /**
   * Given array, print each item on its own line, wrapped in an
   * indented "{ }" block.
   */
  function block(array) {
    return array && array.length !== 0 ? '{\n' + indent(join(array, '\n')) + '\n}' : '';
  }
  
  /**
   * If maybeString is not null or empty, then wrap with start and end, otherwise
   * print an empty string.
   */
  function wrap(start, maybeString, end) {
    return maybeString ? start + maybeString + (end || '') : '';
  }
  
  function indent(maybeString) {
    return maybeString && '  ' + maybeString.replace(/\n/g, '\n  ');
  }
  
  /**
   * Print a block string in the indented block form by adding a leading and
   * trailing blank line. However, if a block string starts with whitespace and is
   * a single-line, adding a leading blank line would strip that whitespace.
   */
  function printBlockString(value, isDescription) {
    var escaped = value.replace(/"""/g, '\\"""');
    return (value[0] === ' ' || value[0] === '\t') && value.indexOf('\n') === -1 ? '"""' + escaped.replace(/"$/, '"\n') + '"""' : '"""\n' + (isDescription ? escaped : indent(escaped)) + '\n"""';
  }
  
  /***/ }),
  /* 7 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.visit = visit;
  exports.visitInParallel = visitInParallel;
  exports.visitWithTypeInfo = visitWithTypeInfo;
  exports.getVisitFn = getVisitFn;
  
  
  /**
   * A visitor is comprised of visit functions, which are called on each node
   * during the visitor's traversal.
   */
  
  
  /**
   * A visitor is provided to visit, it contains the collection of
   * relevant functions to be called during the visitor's traversal.
   */
  /**
   * 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
   */
  
  var QueryDocumentKeys = exports.QueryDocumentKeys = {
    Name: [],
  
    Document: ['definitions'],
    OperationDefinition: ['name', 'variableDefinitions', 'directives', 'selectionSet'],
    VariableDefinition: ['variable', 'type', 'defaultValue'],
    Variable: ['name'],
    SelectionSet: ['selections'],
    Field: ['alias', 'name', 'arguments', 'directives', 'selectionSet'],
    Argument: ['name', 'value'],
  
    FragmentSpread: ['name', 'directives'],
    InlineFragment: ['typeCondition', 'directives', 'selectionSet'],
    FragmentDefinition: ['name',
    // Note: fragment variable definitions are experimental and may be changed
    // or removed in the future.
    'variableDefinitions', 'typeCondition', 'directives', 'selectionSet'],
  
    IntValue: [],
    FloatValue: [],
    StringValue: [],
    BooleanValue: [],
    NullValue: [],
    EnumValue: [],
    ListValue: ['values'],
    ObjectValue: ['fields'],
    ObjectField: ['name', 'value'],
  
    Directive: ['name', 'arguments'],
  
    NamedType: ['name'],
    ListType: ['type'],
    NonNullType: ['type'],
  
    SchemaDefinition: ['directives', 'operationTypes'],
    OperationTypeDefinition: ['type'],
  
    ScalarTypeDefinition: ['description', 'name', 'directives'],
    ObjectTypeDefinition: ['description', 'name', 'interfaces', 'directives', 'fields'],
    FieldDefinition: ['description', 'name', 'arguments', 'type', 'directives'],
    InputValueDefinition: ['description', 'name', 'type', 'defaultValue', 'directives'],
    InterfaceTypeDefinition: ['description', 'name', 'directives', 'fields'],
    UnionTypeDefinition: ['description', 'name', 'directives', 'types'],
    EnumTypeDefinition: ['description', 'name', 'directives', 'values'],
    EnumValueDefinition: ['description', 'name', 'directives'],
    InputObjectTypeDefinition: ['description', 'name', 'directives', 'fields'],
  
    ScalarTypeExtension: ['name', 'directives'],
    ObjectTypeExtension: ['name', 'interfaces', 'directives', 'fields'],
    InterfaceTypeExtension: ['name', 'directives', 'fields'],
    UnionTypeExtension: ['name', 'directives', 'types'],
    EnumTypeExtension: ['name', 'directives', 'values'],
    InputObjectTypeExtension: ['name', 'directives', 'fields'],
  
    DirectiveDefinition: ['description', 'name', 'arguments', 'locations']
  };
  
  /**
   * A KeyMap describes each the traversable properties of each kind of node.
   */
  var BREAK = exports.BREAK = {};
  
  /**
   * visit() will walk through an AST using a depth first traversal, calling
   * the visitor's enter function at each node in the traversal, and calling the
   * leave function after visiting that node and all of its child nodes.
   *
   * By returning different values from the enter and leave functions, the
   * behavior of the visitor can be altered, including skipping over a sub-tree of
   * the AST (by returning false), editing the AST by returning a value or null
   * to remove the value, or to stop the whole traversal by returning BREAK.
   *
   * When using visit() to edit an AST, the original AST will not be modified, and
   * a new version of the AST with the changes applied will be returned from the
   * visit function.
   *
   *     const editedAST = visit(ast, {
   *       enter(node, key, parent, path, ancestors) {
   *         // @return
   *         //   undefined: no action
   *         //   false: skip visiting this node
   *         //   visitor.BREAK: stop visiting altogether
   *         //   null: delete this node
   *         //   any value: replace this node with the returned value
   *       },
   *       leave(node, key, parent, path, ancestors) {
   *         // @return
   *         //   undefined: no action
   *         //   false: no action
   *         //   visitor.BREAK: stop visiting altogether
   *         //   null: delete this node
   *         //   any value: replace this node with the returned value
   *       }
   *     });
   *
   * Alternatively to providing enter() and leave() functions, a visitor can
   * instead provide functions named the same as the kinds of AST nodes, or
   * enter/leave visitors at a named key, leading to four permutations of
   * visitor API:
   *
   * 1) Named visitors triggered when entering a node a specific kind.
   *
   *     visit(ast, {
   *       Kind(node) {
   *         // enter the "Kind" node
   *       }
   *     })
   *
   * 2) Named visitors that trigger upon entering and leaving a node of
   *    a specific kind.
   *
   *     visit(ast, {
   *       Kind: {
   *         enter(node) {
   *           // enter the "Kind" node
   *         }
   *         leave(node) {
   *           // leave the "Kind" node
   *         }
   *       }
   *     })
   *
   * 3) Generic visitors that trigger upon entering and leaving any node.
   *
   *     visit(ast, {
   *       enter(node) {
   *         // enter any node
   *       },
   *       leave(node) {
   *         // leave any node
   *       }
   *     })
   *
   * 4) Parallel visitors for entering and leaving nodes of a specific kind.
   *
   *     visit(ast, {
   *       enter: {
   *         Kind(node) {
   *           // enter the "Kind" node
   *         }
   *       },
   *       leave: {
   *         Kind(node) {
   *           // leave the "Kind" node
   *         }
   *       }
   *     })
   */
  function visit(root, visitor) {
    var visitorKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : QueryDocumentKeys;
  
    /* eslint-disable no-undef-init */
    var stack = undefined;
    var inArray = Array.isArray(root);
    var keys = [root];
    var index = -1;
    var edits = [];
    var node = undefined;
    var key = undefined;
    var parent = undefined;
    var path = [];
    var ancestors = [];
    var newRoot = root;
    /* eslint-enable no-undef-init */
  
    do {
      index++;
      var isLeaving = index === keys.length;
      var isEdited = isLeaving && edits.length !== 0;
      if (isLeaving) {
        key = ancestors.length === 0 ? undefined : path[path.length - 1];
        node = parent;
        parent = ancestors.pop();
        if (isEdited) {
          if (inArray) {
            node = node.slice();
          } else {
            var clone = {};
            for (var k in node) {
              if (node.hasOwnProperty(k)) {
                clone[k] = node[k];
              }
            }
            node = clone;
          }
          var editOffset = 0;
          for (var ii = 0; ii < edits.length; ii++) {
            var editKey = edits[ii][0];
            var editValue = edits[ii][1];
            if (inArray) {
              editKey -= editOffset;
            }
            if (inArray && editValue === null) {
              node.splice(editKey, 1);
              editOffset++;
            } else {
              node[editKey] = editValue;
            }
          }
        }
        index = stack.index;
        keys = stack.keys;
        edits = stack.edits;
        inArray = stack.inArray;
        stack = stack.prev;
      } else {
        key = parent ? inArray ? index : keys[index] : undefined;
        node = parent ? parent[key] : newRoot;
        if (node === null || node === undefined) {
          continue;
        }
        if (parent) {
          path.push(key);
        }
      }
  
      var result = void 0;
      if (!Array.isArray(node)) {
        if (!isNode(node)) {
          throw new Error('Invalid AST Node: ' + JSON.stringify(node));
        }
        var visitFn = getVisitFn(visitor, node.kind, isLeaving);
        if (visitFn) {
          result = visitFn.call(visitor, node, key, parent, path, ancestors);
  
          if (result === BREAK) {
            break;
          }
  
          if (result === false) {
            if (!isLeaving) {
              path.pop();
              continue;
            }
          } else if (result !== undefined) {
            edits.push([key, result]);
            if (!isLeaving) {
              if (isNode(result)) {
                node = result;
              } else {
                path.pop();
                continue;
              }
            }
          }
        }
      }
  
      if (result === undefined && isEdited) {
        edits.push([key, node]);
      }
  
      if (isLeaving) {
        path.pop();
      } else {
        stack = { inArray: inArray, index: index, keys: keys, edits: edits, prev: stack };
        inArray = Array.isArray(node);
        keys = inArray ? node : visitorKeys[node.kind] || [];
        index = -1;
        edits = [];
        if (parent) {
          ancestors.push(parent);
        }
        parent = node;
      }
    } while (stack !== undefined);
  
    if (edits.length !== 0) {
      newRoot = edits[edits.length - 1][1];
    }
  
    return newRoot;
  }
  
  function isNode(maybeNode) {
    return Boolean(maybeNode && typeof maybeNode.kind === 'string');
  }
  
  /**
   * Creates a new visitor instance which delegates to many visitors to run in
   * parallel. Each visitor will be visited for each node before moving on.
   *
   * If a prior visitor edits a node, no following visitors will see that node.
   */
  function visitInParallel(visitors) {
    var skipping = new Array(visitors.length);
  
    return {
      enter: function enter(node) {
        for (var i = 0; i < visitors.length; i++) {
          if (!skipping[i]) {
            var fn = getVisitFn(visitors[i], node.kind, /* isLeaving */false);
            if (fn) {
              var result = fn.apply(visitors[i], arguments);
              if (result === false) {
                skipping[i] = node;
              } else if (result === BREAK) {
                skipping[i] = BREAK;
              } else if (result !== undefined) {
                return result;
              }
            }
          }
        }
      },
      leave: function leave(node) {
        for (var i = 0; i < visitors.length; i++) {
          if (!skipping[i]) {
            var fn = getVisitFn(visitors[i], node.kind, /* isLeaving */true);
            if (fn) {
              var result = fn.apply(visitors[i], arguments);
              if (result === BREAK) {
                skipping[i] = BREAK;
              } else if (result !== undefined && result !== false) {
                return result;
              }
            }
          } else if (skipping[i] === node) {
            skipping[i] = null;
          }
        }
      }
    };
  }
  
  /**
   * Creates a new visitor instance which maintains a provided TypeInfo instance
   * along with visiting visitor.
   */
  function visitWithTypeInfo(typeInfo, visitor) {
    return {
      enter: function enter(node) {
        typeInfo.enter(node);
        var fn = getVisitFn(visitor, node.kind, /* isLeaving */false);
        if (fn) {
          var result = fn.apply(visitor, arguments);
          if (result !== undefined) {
            typeInfo.leave(node);
            if (isNode(result)) {
              typeInfo.enter(result);
            }
          }
          return result;
        }
      },
      leave: function leave(node) {
        var fn = getVisitFn(visitor, node.kind, /* isLeaving */true);
        var result = void 0;
        if (fn) {
          result = fn.apply(visitor, arguments);
        }
        typeInfo.leave(node);
        return result;
      }
    };
  }
  
  /**
   * Given a visitor instance, if it is leaving or not, and a node kind, return
   * the function the visitor runtime should call.
   */
  function getVisitFn(visitor, kind, isLeaving) {
    var kindVisitor = visitor[kind];
    if (kindVisitor) {
      if (!isLeaving && typeof kindVisitor === 'function') {
        // { Kind() {} }
        return kindVisitor;
      }
      var kindSpecificVisitor = isLeaving ? kindVisitor.leave : kindVisitor.enter;
      if (typeof kindSpecificVisitor === 'function') {
        // { Kind: { enter() {}, leave() {} } }
        return kindSpecificVisitor;
      }
    } else {
      var specificVisitor = isLeaving ? visitor.leave : visitor.enter;
      if (specificVisitor) {
        if (typeof specificVisitor === 'function') {
          // { enter() {}, leave() {} }
          return specificVisitor;
        }
        var specificKindVisitor = specificVisitor[kind];
        if (typeof specificKindVisitor === 'function') {
          // { enter: { Kind() {} }, leave: { Kind() {} } }
          return specificKindVisitor;
        }
      }
    }
  }
  
  /***/ }),
  /* 8 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.getOperationAST = getOperationAST;
  
  var _kinds = __webpack_require__(9);
  
  /**
   * Returns an operation AST given a document AST and optionally an operation
   * name. If a name is not provided, an operation is only returned if only one is
   * provided in the document.
   */
  function getOperationAST(documentAST, operationName) {
    var operation = null;
    for (var i = 0; i < documentAST.definitions.length; i++) {
      var definition = documentAST.definitions[i];
      if (definition.kind === _kinds.Kind.OPERATION_DEFINITION) {
        if (!operationName) {
          // If no operation name was provided, only return an Operation if there
          // is one defined in the document. Upon encountering the second, return
          // null.
          if (operation) {
            return null;
          }
          operation = definition;
        } else if (definition.name && definition.name.value === operationName) {
          return definition;
        }
      }
    }
    return operation;
  } /**
     * 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
     */
  
  /***/ }),
  /* 9 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  /**
   * 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
   */
  
  /**
   * The set of allowed kind values for AST nodes.
   */
  var Kind = exports.Kind = Object.freeze({
    // Name
    NAME: 'Name',
  
    // Document
    DOCUMENT: 'Document',
    OPERATION_DEFINITION: 'OperationDefinition',
    VARIABLE_DEFINITION: 'VariableDefinition',
    VARIABLE: 'Variable',
    SELECTION_SET: 'SelectionSet',
    FIELD: 'Field',
    ARGUMENT: 'Argument',
  
    // Fragments
    FRAGMENT_SPREAD: 'FragmentSpread',
    INLINE_FRAGMENT: 'InlineFragment',
    FRAGMENT_DEFINITION: 'FragmentDefinition',
  
    // Values
    INT: 'IntValue',
    FLOAT: 'FloatValue',
    STRING: 'StringValue',
    BOOLEAN: 'BooleanValue',
    NULL: 'NullValue',
    ENUM: 'EnumValue',
    LIST: 'ListValue',
    OBJECT: 'ObjectValue',
    OBJECT_FIELD: 'ObjectField',
  
    // Directives
    DIRECTIVE: 'Directive',
  
    // Types
    NAMED_TYPE: 'NamedType',
    LIST_TYPE: 'ListType',
    NON_NULL_TYPE: 'NonNullType',
  
    // Type System Definitions
    SCHEMA_DEFINITION: 'SchemaDefinition',
    OPERATION_TYPE_DEFINITION: 'OperationTypeDefinition',
  
    // Type Definitions
    SCALAR_TYPE_DEFINITION: 'ScalarTypeDefinition',
    OBJECT_TYPE_DEFINITION: 'ObjectTypeDefinition',
    FIELD_DEFINITION: 'FieldDefinition',
    INPUT_VALUE_DEFINITION: 'InputValueDefinition',
    INTERFACE_TYPE_DEFINITION: 'InterfaceTypeDefinition',
    UNION_TYPE_DEFINITION: 'UnionTypeDefinition',
    ENUM_TYPE_DEFINITION: 'EnumTypeDefinition',
    ENUM_VALUE_DEFINITION: 'EnumValueDefinition',
    INPUT_OBJECT_TYPE_DEFINITION: 'InputObjectTypeDefinition',
  
    // Type Extensions
    SCALAR_TYPE_EXTENSION: 'ScalarTypeExtension',
    OBJECT_TYPE_EXTENSION: 'ObjectTypeExtension',
    INTERFACE_TYPE_EXTENSION: 'InterfaceTypeExtension',
    UNION_TYPE_EXTENSION: 'UnionTypeExtension',
    ENUM_TYPE_EXTENSION: 'EnumTypeExtension',
    INPUT_OBJECT_TYPE_EXTENSION: 'InputObjectTypeExtension',
  
    // Directive Definitions
    DIRECTIVE_DEFINITION: 'DirectiveDefinition'
  });
  
  /**
   * The enum type representing the possible kind values of AST nodes.
   */
  
  /***/ }),
  /* 10 */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
  /* WEBPACK VAR INJECTION */(function(global, module) {/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__ponyfill_js__ = __webpack_require__(12);
  /* global window */
  
  
  var root;
  
  if (typeof self !== 'undefined') {
    root = self;
  } else if (typeof window !== 'undefined') {
    root = window;
  } else if (typeof global !== 'undefined') {
    root = global;
  } else if (true) {
    root = module;
  } else {
    root = Function('return this')();
  }
  
  var result = Object(__WEBPACK_IMPORTED_MODULE_0__ponyfill_js__["a" /* default */])(root);
  /* harmony default export */ __webpack_exports__["default"] = (result);
  
  /* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(0), __webpack_require__(11)(module)))
  
  /***/ }),
  /* 11 */
  /***/ (function(module, exports) {
  
  module.exports = function(originalModule) {
  	if(!originalModule.webpackPolyfill) {
  		var module = Object.create(originalModule);
  		// module.parent = undefined by default
  		if(!module.children) module.children = [];
  		Object.defineProperty(module, "loaded", {
  			enumerable: true,
  			get: function() {
  				return module.l;
  			}
  		});
  		Object.defineProperty(module, "id", {
  			enumerable: true,
  			get: function() {
  				return module.i;
  			}
  		});
  		Object.defineProperty(module, "exports", {
  			enumerable: true,
  		});
  		module.webpackPolyfill = 1;
  	}
  	return module;
  };
  
  
  /***/ }),
  /* 12 */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (immutable) */ __webpack_exports__["a"] = symbolObservablePonyfill;
  function symbolObservablePonyfill(root) {
  	var result;
  	var Symbol = root.Symbol;
  
  	if (typeof Symbol === 'function') {
  		if (Symbol.observable) {
  			result = Symbol.observable;
  		} else {
  			result = Symbol('observable');
  			Symbol.observable = result;
  		}
  	} else {
  		result = '@@observable';
  	}
  
  	return result;
  };
  
  
  /***/ }),
  /* 13 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  var GRAPHQL_WS = 'graphql-ws';
  exports.GRAPHQL_WS = GRAPHQL_WS;
  var GRAPHQL_SUBSCRIPTIONS = 'graphql-subscriptions';
  exports.GRAPHQL_SUBSCRIPTIONS = GRAPHQL_SUBSCRIPTIONS;
  //# sourceMappingURL=protocol.js.map
  
  /***/ }),
  /* 14 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  var WS_TIMEOUT = 30000;
  exports.WS_TIMEOUT = WS_TIMEOUT;
  //# sourceMappingURL=defaults.js.map
  
  /***/ }),
  /* 15 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  var MessageTypes = (function () {
      function MessageTypes() {
          throw new Error('Static Class');
      }
      MessageTypes.GQL_CONNECTION_INIT = 'connection_init';
      MessageTypes.GQL_CONNECTION_ACK = 'connection_ack';
      MessageTypes.GQL_CONNECTION_ERROR = 'connection_error';
      MessageTypes.GQL_CONNECTION_KEEP_ALIVE = 'ka';
      MessageTypes.GQL_CONNECTION_TERMINATE = 'connection_terminate';
      MessageTypes.GQL_START = 'start';
      MessageTypes.GQL_DATA = 'data';
      MessageTypes.GQL_ERROR = 'error';
      MessageTypes.GQL_COMPLETE = 'complete';
      MessageTypes.GQL_STOP = 'stop';
      MessageTypes.SUBSCRIPTION_START = 'subscription_start';
      MessageTypes.SUBSCRIPTION_DATA = 'subscription_data';
      MessageTypes.SUBSCRIPTION_SUCCESS = 'subscription_success';
      MessageTypes.SUBSCRIPTION_FAIL = 'subscription_fail';
      MessageTypes.SUBSCRIPTION_END = 'subscription_end';
      MessageTypes.INIT = 'init';
      MessageTypes.INIT_SUCCESS = 'init_success';
      MessageTypes.INIT_FAIL = 'init_fail';
      MessageTypes.KEEP_ALIVE = 'keepalive';
      return MessageTypes;
  }());
  exports.default = MessageTypes;
  //# sourceMappingURL=message-types.js.map
  
  /***/ })
  /******/ ]);