text: /*!
   * Pusher JavaScript Library v7.0.2
   * https://pusher.com/
   *
   * Copyright 2020, Pusher
   * Released under the MIT licence.
   */
  
  module.exports =
  /******/ (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, { enumerable: true, get: getter });
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// define __esModule on exports
  /******/ 	__webpack_require__.r = function(exports) {
  /******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  /******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  /******/ 		}
  /******/ 		Object.defineProperty(exports, '__esModule', { value: true });
  /******/ 	};
  /******/
  /******/ 	// create a fake namespace object
  /******/ 	// mode & 1: value is a module id, require it
  /******/ 	// mode & 2: merge all properties of value into the ns
  /******/ 	// mode & 4: return value when already ns object
  /******/ 	// mode & 8|1: behave like require
  /******/ 	__webpack_require__.t = function(value, mode) {
  /******/ 		if(mode & 1) value = __webpack_require__(value);
  /******/ 		if(mode & 8) return value;
  /******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  /******/ 		var ns = Object.create(null);
  /******/ 		__webpack_require__.r(ns);
  /******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  /******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  /******/ 		return ns;
  /******/ 	};
  /******/
  /******/ 	// 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 = 21);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ (function(module, exports) {
  
  module.exports = require("util");
  
  /***/ }),
  /* 1 */
  /***/ (function(module, exports, __webpack_require__) {
  
  /* eslint-disable node/no-deprecated-api */
  var buffer = __webpack_require__(22)
  var Buffer = buffer.Buffer
  
  // alternative to using Object.keys for old browsers
  function copyProps (src, dst) {
    for (var key in src) {
      dst[key] = src[key]
    }
  }
  if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
    module.exports = buffer
  } else {
    // Copy properties from require('buffer')
    copyProps(buffer, exports)
    exports.Buffer = SafeBuffer
  }
  
  function SafeBuffer (arg, encodingOrOffset, length) {
    return Buffer(arg, encodingOrOffset, length)
  }
  
  // Copy static methods from Buffer
  copyProps(Buffer, SafeBuffer)
  
  SafeBuffer.from = function (arg, encodingOrOffset, length) {
    if (typeof arg === 'number') {
      throw new TypeError('Argument must not be a number')
    }
    return Buffer(arg, encodingOrOffset, length)
  }
  
  SafeBuffer.alloc = function (size, fill, encoding) {
    if (typeof size !== 'number') {
      throw new TypeError('Argument must be a number')
    }
    var buf = Buffer(size)
    if (fill !== undefined) {
      if (typeof encoding === 'string') {
        buf.fill(fill, encoding)
      } else {
        buf.fill(fill)
      }
    } else {
      buf.fill(0)
    }
    return buf
  }
  
  SafeBuffer.allocUnsafe = function (size) {
    if (typeof size !== 'number') {
      throw new TypeError('Argument must be a number')
    }
    return Buffer(size)
  }
  
  SafeBuffer.allocUnsafeSlow = function (size) {
    if (typeof size !== 'number') {
      throw new TypeError('Argument must be a number')
    }
    return buffer.SlowBuffer(size)
  }
  
  
  /***/ }),
  /* 2 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var Buffer  = __webpack_require__(1).Buffer,
      Emitter = __webpack_require__(23).EventEmitter,
      util    = __webpack_require__(0),
      streams = __webpack_require__(24),
      Headers = __webpack_require__(9),
      Reader  = __webpack_require__(25);
  
  var Base = function(request, url, options) {
    Emitter.call(this);
    Base.validateOptions(options || {}, ['maxLength', 'masking', 'requireMasking', 'protocols']);
  
    this._request   = request;
    this._reader    = new Reader();
    this._options   = options || {};
    this._maxLength = this._options.maxLength || this.MAX_LENGTH;
    this._headers   = new Headers();
    this.__queue    = [];
    this.readyState = 0;
    this.url        = url;
  
    this.io = new streams.IO(this);
    this.messages = new streams.Messages(this);
    this._bindEventListeners();
  };
  util.inherits(Base, Emitter);
  
  Base.isWebSocket = function(request) {
    var connection = request.headers.connection || '',
        upgrade    = request.headers.upgrade || '';
  
    return request.method === 'GET' &&
           connection.toLowerCase().split(/ *, */).indexOf('upgrade') >= 0 &&
           upgrade.toLowerCase() === 'websocket';
  };
  
  Base.validateOptions = function(options, validKeys) {
    for (var key in options) {
      if (validKeys.indexOf(key) < 0)
        throw new Error('Unrecognized option: ' + key);
    }
  };
  
  var instance = {
    // This is 64MB, small enough for an average VPS to handle without
    // crashing from process out of memory
    MAX_LENGTH: 0x3ffffff,
  
    STATES: ['connecting', 'open', 'closing', 'closed'],
  
    _bindEventListeners: function() {
      var self = this;
  
      // Protocol errors are informational and do not have to be handled
      this.messages.on('error', function() {});
  
      this.on('message', function(event) {
        var messages = self.messages;
        if (messages.readable) messages.emit('data', event.data);
      });
  
      this.on('error', function(error) {
        var messages = self.messages;
        if (messages.readable) messages.emit('error', error);
      });
  
      this.on('close', function() {
        var messages = self.messages;
        if (!messages.readable) return;
        messages.readable = messages.writable = false;
        messages.emit('end');
      });
    },
  
    getState: function() {
      return this.STATES[this.readyState] || null;
    },
  
    addExtension: function(extension) {
      return false;
    },
  
    setHeader: function(name, value) {
      if (this.readyState > 0) return false;
      this._headers.set(name, value);
      return true;
    },
  
    start: function() {
      if (this.readyState !== 0) return false;
  
      if (!Base.isWebSocket(this._request))
        return this._failHandshake(new Error('Not a WebSocket request'));
  
      var response;
  
      try {
        response = this._handshakeResponse();
      } catch (error) {
        return this._failHandshake(error);
      }
  
      this._write(response);
      if (this._stage !== -1) this._open();
      return true;
    },
  
    _failHandshake: function(error) {
      var headers = new Headers();
      headers.set('Content-Type', 'text/plain');
      headers.set('Content-Length', Buffer.byteLength(error.message, 'utf8'));
  
      headers = ['HTTP/1.1 400 Bad Request', headers.toString(), error.message];
      this._write(Buffer.from(headers.join('\r\n'), 'utf8'));
      this._fail('protocol_error', error.message);
  
      return false;
    },
  
    text: function(message) {
      return this.frame(message);
    },
  
    binary: function(message) {
      return false;
    },
  
    ping: function() {
      return false;
    },
  
    pong: function() {
        return false;
    },
  
    close: function(reason, code) {
      if (this.readyState !== 1) return false;
      this.readyState = 3;
      this.emit('close', new Base.CloseEvent(null, null));
      return true;
    },
  
    _open: function() {
      this.readyState = 1;
      this.__queue.forEach(function(args) { this.frame.apply(this, args) }, this);
      this.__queue = [];
      this.emit('open', new Base.OpenEvent());
    },
  
    _queue: function(message) {
      this.__queue.push(message);
      return true;
    },
  
    _write: function(chunk) {
      var io = this.io;
      if (io.readable) io.emit('data', chunk);
    },
  
    _fail: function(type, message) {
      this.readyState = 2;
      this.emit('error', new Error(message));
      this.close();
    }
  };
  
  for (var key in instance)
    Base.prototype[key] = instance[key];
  
  
  Base.ConnectEvent = function() {};
  
  Base.OpenEvent = function() {};
  
  Base.CloseEvent = function(code, reason) {
    this.code   = code;
    this.reason = reason;
  };
  
  Base.MessageEvent = function(data) {
    this.data = data;
  };
  
  Base.PingEvent = function(data) {
    this.data = data;
  };
  
  Base.PongEvent = function(data) {
    this.data = data;
  };
  
  module.exports = Base;
  
  
  /***/ }),
  /* 3 */
  /***/ (function(module, exports) {
  
  module.exports = require("crypto");
  
  /***/ }),
  /* 4 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  // Protocol references:
  //
  // * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
  // * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
  // * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
  
  var Base   = __webpack_require__(2),
      Client = __webpack_require__(26),
      Server = __webpack_require__(37);
  
  var Driver = {
    client: function(url, options) {
      options = options || {};
      if (options.masking === undefined) options.masking = true;
      return new Client(url, options);
    },
  
    server: function(options) {
      options = options || {};
      if (options.requireMasking === undefined) options.requireMasking = true;
      return new Server(options);
    },
  
    http: function() {
      return Server.http.apply(Server, arguments);
    },
  
    isSecureRequest: function(request) {
      return Server.isSecureRequest(request);
    },
  
    isWebSocket: function(request) {
      return Base.isWebSocket(request);
    },
  
    validateOptions: function(options, validKeys) {
      Base.validateOptions(options, validKeys);
    }
  };
  
  module.exports = Driver;
  
  
  /***/ }),
  /* 5 */
  /***/ (function(module, exports) {
  
  module.exports = require("stream");
  
  /***/ }),
  /* 6 */
  /***/ (function(module, exports) {
  
  module.exports = require("url");
  
  /***/ }),
  /* 7 */
  /***/ (function(module, exports) {
  
  var Event = function(eventType, options) {
    this.type = eventType;
    for (var key in options)
      this[key] = options[key];
  };
  
  Event.prototype.initEvent = function(eventType, canBubble, cancelable) {
    this.type       = eventType;
    this.bubbles    = canBubble;
    this.cancelable = cancelable;
  };
  
  Event.prototype.stopPropagation = function() {};
  Event.prototype.preventDefault  = function() {};
  
  Event.CAPTURING_PHASE = 1;
  Event.AT_TARGET       = 2;
  Event.BUBBLING_PHASE  = 3;
  
  module.exports = Event;
  
  
  /***/ }),
  /* 8 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  // Copyright (C) 2016 Dmitry Chestnykh
  // MIT License. See LICENSE file for details.
  var __extends = (this && this.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  Object.defineProperty(exports, "__esModule", { value: true });
  /**
   * Package base64 implements Base64 encoding and decoding.
   */
  // Invalid character used in decoding to indicate
  // that the character to decode is out of range of
  // alphabet and cannot be decoded.
  var INVALID_BYTE = 256;
  /**
   * Implements standard Base64 encoding.
   *
   * Operates in constant time.
   */
  var Coder = /** @class */ (function () {
      // TODO(dchest): methods to encode chunk-by-chunk.
      function Coder(_paddingCharacter) {
          if (_paddingCharacter === void 0) { _paddingCharacter = "="; }
          this._paddingCharacter = _paddingCharacter;
      }
      Coder.prototype.encodedLength = function (length) {
          if (!this._paddingCharacter) {
              return (length * 8 + 5) / 6 | 0;
          }
          return (length + 2) / 3 * 4 | 0;
      };
      Coder.prototype.encode = function (data) {
          var out = "";
          var i = 0;
          for (; i < data.length - 2; i += 3) {
              var c = (data[i] << 16) | (data[i + 1] << 8) | (data[i + 2]);
              out += this._encodeByte((c >>> 3 * 6) & 63);
              out += this._encodeByte((c >>> 2 * 6) & 63);
              out += this._encodeByte((c >>> 1 * 6) & 63);
              out += this._encodeByte((c >>> 0 * 6) & 63);
          }
          var left = data.length - i;
          if (left > 0) {
              var c = (data[i] << 16) | (left === 2 ? data[i + 1] << 8 : 0);
              out += this._encodeByte((c >>> 3 * 6) & 63);
              out += this._encodeByte((c >>> 2 * 6) & 63);
              if (left === 2) {
                  out += this._encodeByte((c >>> 1 * 6) & 63);
              }
              else {
                  out += this._paddingCharacter || "";
              }
              out += this._paddingCharacter || "";
          }
          return out;
      };
      Coder.prototype.maxDecodedLength = function (length) {
          if (!this._paddingCharacter) {
              return (length * 6 + 7) / 8 | 0;
          }
          return length / 4 * 3 | 0;
      };
      Coder.prototype.decodedLength = function (s) {
          return this.maxDecodedLength(s.length - this._getPaddingLength(s));
      };
      Coder.prototype.decode = function (s) {
          if (s.length === 0) {
              return new Uint8Array(0);
          }
          var paddingLength = this._getPaddingLength(s);
          var length = s.length - paddingLength;
          var out = new Uint8Array(this.maxDecodedLength(length));
          var op = 0;
          var i = 0;
          var haveBad = 0;
          var v0 = 0, v1 = 0, v2 = 0, v3 = 0;
          for (; i < length - 4; i += 4) {
              v0 = this._decodeChar(s.charCodeAt(i + 0));
              v1 = this._decodeChar(s.charCodeAt(i + 1));
              v2 = this._decodeChar(s.charCodeAt(i + 2));
              v3 = this._decodeChar(s.charCodeAt(i + 3));
              out[op++] = (v0 << 2) | (v1 >>> 4);
              out[op++] = (v1 << 4) | (v2 >>> 2);
              out[op++] = (v2 << 6) | v3;
              haveBad |= v0 & INVALID_BYTE;
              haveBad |= v1 & INVALID_BYTE;
              haveBad |= v2 & INVALID_BYTE;
              haveBad |= v3 & INVALID_BYTE;
          }
          if (i < length - 1) {
              v0 = this._decodeChar(s.charCodeAt(i));
              v1 = this._decodeChar(s.charCodeAt(i + 1));
              out[op++] = (v0 << 2) | (v1 >>> 4);
              haveBad |= v0 & INVALID_BYTE;
              haveBad |= v1 & INVALID_BYTE;
          }
          if (i < length - 2) {
              v2 = this._decodeChar(s.charCodeAt(i + 2));
              out[op++] = (v1 << 4) | (v2 >>> 2);
              haveBad |= v2 & INVALID_BYTE;
          }
          if (i < length - 3) {
              v3 = this._decodeChar(s.charCodeAt(i + 3));
              out[op++] = (v2 << 6) | v3;
              haveBad |= v3 & INVALID_BYTE;
          }
          if (haveBad !== 0) {
              throw new Error("Base64Coder: incorrect characters for decoding");
          }
          return out;
      };
      // Standard encoding have the following encoded/decoded ranges,
      // which we need to convert between.
      //
      // ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 0123456789  +   /
      // Index:   0 - 25                    26 - 51              52 - 61   62  63
      // ASCII:  65 - 90                    97 - 122             48 - 57   43  47
      //
      // Encode 6 bits in b into a new character.
      Coder.prototype._encodeByte = function (b) {
          // Encoding uses constant time operations as follows:
          //
          // 1. Define comparison of A with B using (A - B) >>> 8:
          //          if A > B, then result is positive integer
          //          if A <= B, then result is 0
          //
          // 2. Define selection of C or 0 using bitwise AND: X & C:
          //          if X == 0, then result is 0
          //          if X != 0, then result is C
          //
          // 3. Start with the smallest comparison (b >= 0), which is always
          //    true, so set the result to the starting ASCII value (65).
          //
          // 4. Continue comparing b to higher ASCII values, and selecting
          //    zero if comparison isn't true, otherwise selecting a value
          //    to add to result, which:
          //
          //          a) undoes the previous addition
          //          b) provides new value to add
          //
          var result = b;
          // b >= 0
          result += 65;
          // b > 25
          result += ((25 - b) >>> 8) & ((0 - 65) - 26 + 97);
          // b > 51
          result += ((51 - b) >>> 8) & ((26 - 97) - 52 + 48);
          // b > 61
          result += ((61 - b) >>> 8) & ((52 - 48) - 62 + 43);
          // b > 62
          result += ((62 - b) >>> 8) & ((62 - 43) - 63 + 47);
          return String.fromCharCode(result);
      };
      // Decode a character code into a byte.
      // Must return 256 if character is out of alphabet range.
      Coder.prototype._decodeChar = function (c) {
          // Decoding works similar to encoding: using the same comparison
          // function, but now it works on ranges: result is always incremented
          // by value, but this value becomes zero if the range is not
          // satisfied.
          //
          // Decoding starts with invalid value, 256, which is then
          // subtracted when the range is satisfied. If none of the ranges
          // apply, the function returns 256, which is then checked by
          // the caller to throw error.
          var result = INVALID_BYTE; // start with invalid character
          // c == 43 (c > 42 and c < 44)
          result += (((42 - c) & (c - 44)) >>> 8) & (-INVALID_BYTE + c - 43 + 62);
          // c == 47 (c > 46 and c < 48)
          result += (((46 - c) & (c - 48)) >>> 8) & (-INVALID_BYTE + c - 47 + 63);
          // c > 47 and c < 58
          result += (((47 - c) & (c - 58)) >>> 8) & (-INVALID_BYTE + c - 48 + 52);
          // c > 64 and c < 91
          result += (((64 - c) & (c - 91)) >>> 8) & (-INVALID_BYTE + c - 65 + 0);
          // c > 96 and c < 123
          result += (((96 - c) & (c - 123)) >>> 8) & (-INVALID_BYTE + c - 97 + 26);
          return result;
      };
      Coder.prototype._getPaddingLength = function (s) {
          var paddingLength = 0;
          if (this._paddingCharacter) {
              for (var i = s.length - 1; i >= 0; i--) {
                  if (s[i] !== this._paddingCharacter) {
                      break;
                  }
                  paddingLength++;
              }
              if (s.length < 4 || paddingLength > 2) {
                  throw new Error("Base64Coder: incorrect padding");
              }
          }
          return paddingLength;
      };
      return Coder;
  }());
  exports.Coder = Coder;
  var stdCoder = new Coder();
  function encode(data) {
      return stdCoder.encode(data);
  }
  exports.encode = encode;
  function decode(s) {
      return stdCoder.decode(s);
  }
  exports.decode = decode;
  /**
   * Implements URL-safe Base64 encoding.
   * (Same as Base64, but '+' is replaced with '-', and '/' with '_').
   *
   * Operates in constant time.
   */
  var URLSafeCoder = /** @class */ (function (_super) {
      __extends(URLSafeCoder, _super);
      function URLSafeCoder() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      // URL-safe encoding have the following encoded/decoded ranges:
      //
      // ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 0123456789  -   _
      // Index:   0 - 25                    26 - 51              52 - 61   62  63
      // ASCII:  65 - 90                    97 - 122             48 - 57   45  95
      //
      URLSafeCoder.prototype._encodeByte = function (b) {
          var result = b;
          // b >= 0
          result += 65;
          // b > 25
          result += ((25 - b) >>> 8) & ((0 - 65) - 26 + 97);
          // b > 51
          result += ((51 - b) >>> 8) & ((26 - 97) - 52 + 48);
          // b > 61
          result += ((61 - b) >>> 8) & ((52 - 48) - 62 + 45);
          // b > 62
          result += ((62 - b) >>> 8) & ((62 - 45) - 63 + 95);
          return String.fromCharCode(result);
      };
      URLSafeCoder.prototype._decodeChar = function (c) {
          var result = INVALID_BYTE;
          // c == 45 (c > 44 and c < 46)
          result += (((44 - c) & (c - 46)) >>> 8) & (-INVALID_BYTE + c - 45 + 62);
          // c == 95 (c > 94 and c < 96)
          result += (((94 - c) & (c - 96)) >>> 8) & (-INVALID_BYTE + c - 95 + 63);
          // c > 47 and c < 58
          result += (((47 - c) & (c - 58)) >>> 8) & (-INVALID_BYTE + c - 48 + 52);
          // c > 64 and c < 91
          result += (((64 - c) & (c - 91)) >>> 8) & (-INVALID_BYTE + c - 65 + 0);
          // c > 96 and c < 123
          result += (((96 - c) & (c - 123)) >>> 8) & (-INVALID_BYTE + c - 97 + 26);
          return result;
      };
      return URLSafeCoder;
  }(Coder));
  exports.URLSafeCoder = URLSafeCoder;
  var urlSafeCoder = new URLSafeCoder();
  function encodeURLSafe(data) {
      return urlSafeCoder.encode(data);
  }
  exports.encodeURLSafe = encodeURLSafe;
  function decodeURLSafe(s) {
      return urlSafeCoder.decode(s);
  }
  exports.decodeURLSafe = decodeURLSafe;
  exports.encodedLength = function (length) {
      return stdCoder.encodedLength(length);
  };
  exports.maxDecodedLength = function (length) {
      return stdCoder.maxDecodedLength(length);
  };
  exports.decodedLength = function (s) {
      return stdCoder.decodedLength(s);
  };
  //# sourceMappingURL=base64.js.map
  
  /***/ }),
  /* 9 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var Headers = function() {
    this.clear();
  };
  
  Headers.prototype.ALLOWED_DUPLICATES = ['set-cookie', 'set-cookie2', 'warning', 'www-authenticate'];
  
  Headers.prototype.clear = function() {
    this._sent  = {};
    this._lines = [];
  };
  
  Headers.prototype.set = function(name, value) {
    if (value === undefined) return;
  
    name = this._strip(name);
    value = this._strip(value);
  
    var key = name.toLowerCase();
    if (!this._sent.hasOwnProperty(key) || this.ALLOWED_DUPLICATES.indexOf(key) >= 0) {
      this._sent[key] = true;
      this._lines.push(name + ': ' + value + '\r\n');
    }
  };
  
  Headers.prototype.toString = function() {
    return this._lines.join('');
  };
  
  Headers.prototype._strip = function(string) {
    return string.toString().replace(/^ */, '').replace(/ *$/, '');
  };
  
  module.exports = Headers;
  
  
  /***/ }),
  /* 10 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var NodeHTTPParser = __webpack_require__(27).HTTPParser,
      Buffer         = __webpack_require__(1).Buffer;
  
  var TYPES = {
    request:  NodeHTTPParser.REQUEST  || 'request',
    response: NodeHTTPParser.RESPONSE || 'response'
  };
  
  var HttpParser = function(type) {
    this._type     = type;
    this._parser   = new NodeHTTPParser(TYPES[type]);
    this._complete = false;
    this.headers   = {};
  
    var current = null,
        self    = this;
  
    this._parser.onHeaderField = function(b, start, length) {
      current = b.toString('utf8', start, start + length).toLowerCase();
    };
  
    this._parser.onHeaderValue = function(b, start, length) {
      var value = b.toString('utf8', start, start + length);
  
      if (self.headers.hasOwnProperty(current))
        self.headers[current] += ', ' + value;
      else
        self.headers[current] = value;
    };
  
    this._parser.onHeadersComplete = this._parser[NodeHTTPParser.kOnHeadersComplete] =
    function(majorVersion, minorVersion, headers, method, pathname, statusCode) {
      var info = arguments[0];
  
      if (typeof info === 'object') {
        method     = info.method;
        pathname   = info.url;
        statusCode = info.statusCode;
        headers    = info.headers;
      }
  
      self.method     = (typeof method === 'number') ? HttpParser.METHODS[method] : method;
      self.statusCode = statusCode;
      self.url        = pathname;
  
      if (!headers) return;
  
      for (var i = 0, n = headers.length, key, value; i < n; i += 2) {
        key   = headers[i].toLowerCase();
        value = headers[i+1];
        if (self.headers.hasOwnProperty(key))
          self.headers[key] += ', ' + value;
        else
          self.headers[key] = value;
      }
  
      self._complete = true;
    };
  };
  
  HttpParser.METHODS = {
    0:  'DELETE',
    1:  'GET',
    2:  'HEAD',
    3:  'POST',
    4:  'PUT',
    5:  'CONNECT',
    6:  'OPTIONS',
    7:  'TRACE',
    8:  'COPY',
    9:  'LOCK',
    10: 'MKCOL',
    11: 'MOVE',
    12: 'PROPFIND',
    13: 'PROPPATCH',
    14: 'SEARCH',
    15: 'UNLOCK',
    16: 'BIND',
    17: 'REBIND',
    18: 'UNBIND',
    19: 'ACL',
    20: 'REPORT',
    21: 'MKACTIVITY',
    22: 'CHECKOUT',
    23: 'MERGE',
    24: 'M-SEARCH',
    25: 'NOTIFY',
    26: 'SUBSCRIBE',
    27: 'UNSUBSCRIBE',
    28: 'PATCH',
    29: 'PURGE',
    30: 'MKCALENDAR',
    31: 'LINK',
    32: 'UNLINK'
  };
  
  var VERSION = (process.version || '')
                .match(/[0-9]+/g)
                .map(function(n) { return parseInt(n, 10) });
  
  if (VERSION[0] === 0 && VERSION[1] === 12) {
    HttpParser.METHODS[16] = 'REPORT';
    HttpParser.METHODS[17] = 'MKACTIVITY';
    HttpParser.METHODS[18] = 'CHECKOUT';
    HttpParser.METHODS[19] = 'MERGE';
    HttpParser.METHODS[20] = 'M-SEARCH';
    HttpParser.METHODS[21] = 'NOTIFY';
    HttpParser.METHODS[22] = 'SUBSCRIBE';
    HttpParser.METHODS[23] = 'UNSUBSCRIBE';
    HttpParser.METHODS[24] = 'PATCH';
    HttpParser.METHODS[25] = 'PURGE';
  }
  
  HttpParser.prototype.isComplete = function() {
    return this._complete;
  };
  
  HttpParser.prototype.parse = function(chunk) {
    var consumed = this._parser.execute(chunk, 0, chunk.length);
  
    if (typeof consumed !== 'number') {
      this.error     = consumed;
      this._complete = true;
      return;
    }
  
    if (this._complete)
      this.body = (consumed < chunk.length)
                ? chunk.slice(consumed)
                : Buffer.alloc(0);
  };
  
  module.exports = HttpParser;
  
  
  /***/ }),
  /* 11 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var Stream      = __webpack_require__(5).Stream,
      util        = __webpack_require__(0),
      driver      = __webpack_require__(4),
      EventTarget = __webpack_require__(16),
      Event       = __webpack_require__(7);
  
  var API = function(options) {
    options = options || {};
    driver.validateOptions(options, ['headers', 'extensions', 'maxLength', 'ping', 'proxy', 'tls', 'ca']);
  
    this.readable = this.writable = true;
  
    var headers = options.headers;
    if (headers) {
      for (var name in headers) this._driver.setHeader(name, headers[name]);
    }
  
    var extensions = options.extensions;
    if (extensions) {
      [].concat(extensions).forEach(this._driver.addExtension, this._driver);
    }
  
    this._ping          = options.ping;
    this._pingId        = 0;
    this.readyState     = API.CONNECTING;
    this.bufferedAmount = 0;
    this.protocol       = '';
    this.url            = this._driver.url;
    this.version        = this._driver.version;
  
    var self = this;
  
    this._driver.on('open',    function(e) { self._open() });
    this._driver.on('message', function(e) { self._receiveMessage(e.data) });
    this._driver.on('close',   function(e) { self._beginClose(e.reason, e.code) });
  
    this._driver.on('error', function(error) {
      self._emitError(error.message);
    });
    this.on('error', function() {});
  
    this._driver.messages.on('drain', function() {
      self.emit('drain');
    });
  
    if (this._ping)
      this._pingTimer = setInterval(function() {
        self._pingId += 1;
        self.ping(self._pingId.toString());
      }, this._ping * 1000);
  
    this._configureStream();
  
    if (!this._proxy) {
      this._stream.pipe(this._driver.io);
      this._driver.io.pipe(this._stream);
    }
  };
  util.inherits(API, Stream);
  
  API.CONNECTING = 0;
  API.OPEN       = 1;
  API.CLOSING    = 2;
  API.CLOSED     = 3;
  
  var instance = {
    write: function(data) {
      return this.send(data);
    },
  
    end: function(data) {
      if (data !== undefined) this.send(data);
      this.close();
    },
  
    pause: function() {
      return this._driver.messages.pause();
    },
  
    resume: function() {
      return this._driver.messages.resume();
    },
  
    send: function(data) {
      if (this.readyState > API.OPEN) return false;
      if (!(data instanceof Buffer)) data = String(data);
      return this._driver.messages.write(data);
    },
  
    ping: function(message, callback) {
      if (this.readyState > API.OPEN) return false;
      return this._driver.ping(message, callback);
    },
  
    close: function() {
      if (this.readyState !== API.CLOSED) this.readyState = API.CLOSING;
      this._driver.close();
    },
  
    _configureStream: function() {
      var self = this;
  
      this._stream.setTimeout(0);
      this._stream.setNoDelay(true);
  
      ['close', 'end'].forEach(function(event) {
        this._stream.on(event, function() { self._finalizeClose() });
      }, this);
  
      this._stream.on('error', function(error) {
        self._emitError('Network error: ' + self.url + ': ' + error.message);
        self._finalizeClose();
      });
    },
  
   _open: function() {
      if (this.readyState !== API.CONNECTING) return;
  
      this.readyState = API.OPEN;
      this.protocol = this._driver.protocol || '';
  
      var event = new Event('open');
      event.initEvent('open', false, false);
      this.dispatchEvent(event);
    },
  
    _receiveMessage: function(data) {
      if (this.readyState > API.OPEN) return false;
  
      if (this.readable) this.emit('data', data);
  
      var event = new Event('message', {data: data});
      event.initEvent('message', false, false);
      this.dispatchEvent(event);
    },
  
    _emitError: function(message) {
      if (this.readyState >= API.CLOSING) return;
  
      var event = new Event('error', {message: message});
      event.initEvent('error', false, false);
      this.dispatchEvent(event);
    },
  
    _beginClose: function(reason, code) {
      if (this.readyState === API.CLOSED) return;
      this.readyState = API.CLOSING;
  
      if (this._stream) {
        this._stream.end();
        if (!this._stream.readable) this._finalizeClose();
      }
      this._closeParams = [reason, code];
    },
  
    _finalizeClose: function() {
      if (this.readyState === API.CLOSED) return;
      this.readyState = API.CLOSED;
  
      if (this._pingTimer) clearInterval(this._pingTimer);
      if (this._stream) this._stream.end();
  
      if (this.readable) this.emit('end');
      this.readable = this.writable = false;
  
      var reason = this._closeParams ? this._closeParams[0] : '',
          code   = this._closeParams ? this._closeParams[1] : 1006;
  
      var event = new Event('close', {code: code, reason: reason});
      event.initEvent('close', false, false);
      this.dispatchEvent(event);
    }
  };
  
  for (var method in instance) API.prototype[method] = instance[method];
  for (var key in EventTarget) API.prototype[key] = EventTarget[key];
  
  module.exports = API;
  
  
  /***/ }),
  /* 12 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var Buffer     = __webpack_require__(1).Buffer,
      crypto     = __webpack_require__(3),
      util       = __webpack_require__(0),
      Extensions = __webpack_require__(29),
      Base       = __webpack_require__(2),
      Frame      = __webpack_require__(34),
      Message    = __webpack_require__(35);
  
  var Hybi = function(request, url, options) {
    Base.apply(this, arguments);
  
    this._extensions     = new Extensions();
    this._stage          = 0;
    this._masking        = this._options.masking;
    this._protocols      = this._options.protocols || [];
    this._requireMasking = this._options.requireMasking;
    this._pingCallbacks  = {};
  
    if (typeof this._protocols === 'string')
      this._protocols = this._protocols.split(/ *, */);
  
    if (!this._request) return;
  
    var protos    = this._request.headers['sec-websocket-protocol'],
        supported = this._protocols;
  
    if (protos !== undefined) {
      if (typeof protos === 'string') protos = protos.split(/ *, */);
      this.protocol = protos.filter(function(p) { return supported.indexOf(p) >= 0 })[0];
    }
  
    this.version = 'hybi-' + Hybi.VERSION;
  };
  util.inherits(Hybi, Base);
  
  Hybi.VERSION = '13';
  
  Hybi.mask = function(payload, mask, offset) {
    if (!mask || mask.length === 0) return payload;
    offset = offset || 0;
  
    for (var i = 0, n = payload.length - offset; i < n; i++) {
      payload[offset + i] = payload[offset + i] ^ mask[i % 4];
    }
    return payload;
  };
  
  Hybi.generateAccept = function(key) {
    var sha1 = crypto.createHash('sha1');
    sha1.update(key + Hybi.GUID);
    return sha1.digest('base64');
  };
  
  Hybi.GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
  
  var instance = {
    FIN:    0x80,
    MASK:   0x80,
    RSV1:   0x40,
    RSV2:   0x20,
    RSV3:   0x10,
    OPCODE: 0x0F,
    LENGTH: 0x7F,
  
    OPCODES: {
      continuation: 0,
      text:         1,
      binary:       2,
      close:        8,
      ping:         9,
      pong:         10
    },
  
    OPCODE_CODES:    [0, 1, 2, 8, 9, 10],
    MESSAGE_OPCODES: [0, 1, 2],
    OPENING_OPCODES: [1, 2],
  
    ERRORS: {
      normal_closure:       1000,
      going_away:           1001,
      protocol_error:       1002,
      unacceptable:         1003,
      encoding_error:       1007,
      policy_violation:     1008,
      too_large:            1009,
      extension_error:      1010,
      unexpected_condition: 1011
    },
  
    ERROR_CODES:        [1000, 1001, 1002, 1003, 1007, 1008, 1009, 1010, 1011],
    DEFAULT_ERROR_CODE: 1000,
    MIN_RESERVED_ERROR: 3000,
    MAX_RESERVED_ERROR: 4999,
  
    // http://www.w3.org/International/questions/qa-forms-utf-8.en.php
    UTF8_MATCH: /^([\x00-\x7F]|[\xC2-\xDF][\x80-\xBF]|\xE0[\xA0-\xBF][\x80-\xBF]|[\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}|\xED[\x80-\x9F][\x80-\xBF]|\xF0[\x90-\xBF][\x80-\xBF]{2}|[\xF1-\xF3][\x80-\xBF]{3}|\xF4[\x80-\x8F][\x80-\xBF]{2})*$/,
  
    addExtension: function(extension) {
      this._extensions.add(extension);
      return true;
    },
  
    parse: function(chunk) {
      this._reader.put(chunk);
      var buffer = true;
      while (buffer) {
        switch (this._stage) {
          case 0:
            buffer = this._reader.read(1);
            if (buffer) this._parseOpcode(buffer[0]);
            break;
  
          case 1:
            buffer = this._reader.read(1);
            if (buffer) this._parseLength(buffer[0]);
            break;
  
          case 2:
            buffer = this._reader.read(this._frame.lengthBytes);
            if (buffer) this._parseExtendedLength(buffer);
            break;
  
          case 3:
            buffer = this._reader.read(4);
            if (buffer) {
              this._stage = 4;
              this._frame.maskingKey = buffer;
            }
            break;
  
          case 4:
            buffer = this._reader.read(this._frame.length);
            if (buffer) {
              this._stage = 0;
              this._emitFrame(buffer);
            }
            break;
  
          default:
            buffer = null;
        }
      }
    },
  
    text: function(message) {
      if (this.readyState > 1) return false;
      return this.frame(message, 'text');
    },
  
    binary: function(message) {
      if (this.readyState > 1) return false;
      return this.frame(message, 'binary');
    },
  
    ping: function(message, callback) {
      if (this.readyState > 1) return false;
      message = message || '';
      if (callback) this._pingCallbacks[message] = callback;
      return this.frame(message, 'ping');
    },
  
    pong: function(message) {
        if (this.readyState > 1) return false;
        message = message ||'';
        return this.frame(message, 'pong');
    },
  
    close: function(reason, code) {
      reason = reason || '';
      code   = code   || this.ERRORS.normal_closure;
  
      if (this.readyState <= 0) {
        this.readyState = 3;
        this.emit('close', new Base.CloseEvent(code, reason));
        return true;
      } else if (this.readyState === 1) {
        this.readyState = 2;
        this._extensions.close(function() { this.frame(reason, 'close', code) }, this);
        return true;
      } else {
        return false;
      }
    },
  
    frame: function(buffer, type, code) {
      if (this.readyState <= 0) return this._queue([buffer, type, code]);
      if (this.readyState > 2) return false;
  
      if (buffer instanceof Array)    buffer = Buffer.from(buffer);
      if (typeof buffer === 'number') buffer = buffer.toString();
  
      var message = new Message(),
          isText  = (typeof buffer === 'string'),
          payload, copy;
  
      message.rsv1   = message.rsv2 = message.rsv3 = false;
      message.opcode = this.OPCODES[type || (isText ? 'text' : 'binary')];
  
      payload = isText ? Buffer.from(buffer, 'utf8') : buffer;
  
      if (code) {
        copy = payload;
        payload = Buffer.allocUnsafe(2 + copy.length);
        payload.writeUInt16BE(code, 0);
        copy.copy(payload, 2);
      }
      message.data = payload;
  
      var onMessageReady = function(message) {
        var frame = new Frame();
  
        frame.final   = true;
        frame.rsv1    = message.rsv1;
        frame.rsv2    = message.rsv2;
        frame.rsv3    = message.rsv3;
        frame.opcode  = message.opcode;
        frame.masked  = !!this._masking;
        frame.length  = message.data.length;
        frame.payload = message.data;
  
        if (frame.masked) frame.maskingKey = crypto.randomBytes(4);
  
        this._sendFrame(frame);
      };
  
      if (this.MESSAGE_OPCODES.indexOf(message.opcode) >= 0)
        this._extensions.processOutgoingMessage(message, function(error, message) {
          if (error) return this._fail('extension_error', error.message);
          onMessageReady.call(this, message);
        }, this);
      else
        onMessageReady.call(this, message);
  
      return true;
    },
  
    _sendFrame: function(frame) {
      var length = frame.length,
          header = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10),
          offset = header + (frame.masked ? 4 : 0),
          buffer = Buffer.allocUnsafe(offset + length),
          masked = frame.masked ? this.MASK : 0;
  
      buffer[0] = (frame.final ? this.FIN : 0) |
                  (frame.rsv1 ? this.RSV1 : 0) |
                  (frame.rsv2 ? this.RSV2 : 0) |
                  (frame.rsv3 ? this.RSV3 : 0) |
                  frame.opcode;
  
      if (length <= 125) {
        buffer[1] = masked | length;
      } else if (length <= 65535) {
        buffer[1] = masked | 126;
        buffer.writeUInt16BE(length, 2);
      } else {
        buffer[1] = masked | 127;
        buffer.writeUInt32BE(Math.floor(length / 0x100000000), 2);
        buffer.writeUInt32BE(length % 0x100000000, 6);
      }
  
      frame.payload.copy(buffer, offset);
  
      if (frame.masked) {
        frame.maskingKey.copy(buffer, header);
        Hybi.mask(buffer, frame.maskingKey, offset);
      }
  
      this._write(buffer);
    },
  
    _handshakeResponse: function() {
      var secKey  = this._request.headers['sec-websocket-key'],
          version = this._request.headers['sec-websocket-version'];
  
      if (version !== Hybi.VERSION)
        throw new Error('Unsupported WebSocket version: ' + version);
  
      if (typeof secKey !== 'string')
        throw new Error('Missing handshake request header: Sec-WebSocket-Key');
  
      this._headers.set('Upgrade', 'websocket');
      this._headers.set('Connection', 'Upgrade');
      this._headers.set('Sec-WebSocket-Accept', Hybi.generateAccept(secKey));
  
      if (this.protocol) this._headers.set('Sec-WebSocket-Protocol', this.protocol);
  
      var extensions = this._extensions.generateResponse(this._request.headers['sec-websocket-extensions']);
      if (extensions) this._headers.set('Sec-WebSocket-Extensions', extensions);
  
      var start   = 'HTTP/1.1 101 Switching Protocols',
          headers = [start, this._headers.toString(), ''];
  
      return Buffer.from(headers.join('\r\n'), 'utf8');
    },
  
    _shutdown: function(code, reason, error) {
      delete this._frame;
      delete this._message;
      this._stage = 5;
  
      var sendCloseFrame = (this.readyState === 1);
      this.readyState = 2;
  
      this._extensions.close(function() {
        if (sendCloseFrame) this.frame(reason, 'close', code);
        this.readyState = 3;
        if (error) this.emit('error', new Error(reason));
        this.emit('close', new Base.CloseEvent(code, reason));
      }, this);
    },
  
    _fail: function(type, message) {
      if (this.readyState > 1) return;
      this._shutdown(this.ERRORS[type], message, true);
    },
  
    _parseOpcode: function(octet) {
      var rsvs = [this.RSV1, this.RSV2, this.RSV3].map(function(rsv) {
        return (octet & rsv) === rsv;
      });
  
      var frame = this._frame = new Frame();
  
      frame.final  = (octet & this.FIN) === this.FIN;
      frame.rsv1   = rsvs[0];
      frame.rsv2   = rsvs[1];
      frame.rsv3   = rsvs[2];
      frame.opcode = (octet & this.OPCODE);
  
      this._stage = 1;
  
      if (!this._extensions.validFrameRsv(frame))
        return this._fail('protocol_error',
            'One or more reserved bits are on: reserved1 = ' + (frame.rsv1 ? 1 : 0) +
            ', reserved2 = ' + (frame.rsv2 ? 1 : 0) +
            ', reserved3 = ' + (frame.rsv3 ? 1 : 0));
  
      if (this.OPCODE_CODES.indexOf(frame.opcode) < 0)
        return this._fail('protocol_error', 'Unrecognized frame opcode: ' + frame.opcode);
  
      if (this.MESSAGE_OPCODES.indexOf(frame.opcode) < 0 && !frame.final)
        return this._fail('protocol_error', 'Received fragmented control frame: opcode = ' + frame.opcode);
  
      if (this._message && this.OPENING_OPCODES.indexOf(frame.opcode) >= 0)
        return this._fail('protocol_error', 'Received new data frame but previous continuous frame is unfinished');
    },
  
    _parseLength: function(octet) {
      var frame = this._frame;
      frame.masked = (octet & this.MASK) === this.MASK;
      frame.length = (octet & this.LENGTH);
  
      if (frame.length >= 0 && frame.length <= 125) {
        this._stage = frame.masked ? 3 : 4;
        if (!this._checkFrameLength()) return;
      } else {
        this._stage = 2;
        frame.lengthBytes = (frame.length === 126 ? 2 : 8);
      }
  
      if (this._requireMasking && !frame.masked)
        return this._fail('unacceptable', 'Received unmasked frame but masking is required');
    },
  
    _parseExtendedLength: function(buffer) {
      var frame = this._frame;
      frame.length = this._readUInt(buffer);
  
      this._stage = frame.masked ? 3 : 4;
  
      if (this.MESSAGE_OPCODES.indexOf(frame.opcode) < 0 && frame.length > 125)
        return this._fail('protocol_error', 'Received control frame having too long payload: ' + frame.length);
  
      if (!this._checkFrameLength()) return;
    },
  
    _checkFrameLength: function() {
      var length = this._message ? this._message.length : 0;
  
      if (length + this._frame.length > this._maxLength) {
        this._fail('too_large', 'WebSocket frame length too large');
        return false;
      } else {
        return true;
      }
    },
  
    _emitFrame: function(buffer) {
      var frame   = this._frame,
          payload = frame.payload = Hybi.mask(buffer, frame.maskingKey),
          opcode  = frame.opcode,
          message,
          code, reason,
          callbacks, callback;
  
      delete this._frame;
  
      if (opcode === this.OPCODES.continuation) {
        if (!this._message) return this._fail('protocol_error', 'Received unexpected continuation frame');
        this._message.pushFrame(frame);
      }
  
      if (opcode === this.OPCODES.text || opcode === this.OPCODES.binary) {
        this._message = new Message();
        this._message.pushFrame(frame);
      }
  
      if (frame.final && this.MESSAGE_OPCODES.indexOf(opcode) >= 0)
        return this._emitMessage(this._message);
  
      if (opcode === this.OPCODES.close) {
        code   = (payload.length >= 2) ? payload.readUInt16BE(0) : null;
        reason = (payload.length > 2) ? this._encode(payload.slice(2)) : null;
  
        if (!(payload.length === 0) &&
            !(code !== null && code >= this.MIN_RESERVED_ERROR && code <= this.MAX_RESERVED_ERROR) &&
            this.ERROR_CODES.indexOf(code) < 0)
          code = this.ERRORS.protocol_error;
  
        if (payload.length > 125 || (payload.length > 2 && !reason))
          code = this.ERRORS.protocol_error;
  
        this._shutdown(code || this.DEFAULT_ERROR_CODE, reason || '');
      }
  
      if (opcode === this.OPCODES.ping) {
        this.frame(payload, 'pong');
        this.emit('ping', new Base.PingEvent(payload.toString()))
      }
  
      if (opcode === this.OPCODES.pong) {
        callbacks = this._pingCallbacks;
        message   = this._encode(payload);
        callback  = callbacks[message];
  
        delete callbacks[message];
        if (callback) callback()
  
        this.emit('pong', new Base.PongEvent(payload.toString()))
      }
    },
  
    _emitMessage: function(message) {
      var message = this._message;
      message.read();
  
      delete this._message;
  
      this._extensions.processIncomingMessage(message, function(error, message) {
        if (error) return this._fail('extension_error', error.message);
  
        var payload = message.data;
        if (message.opcode === this.OPCODES.text) payload = this._encode(payload);
  
        if (payload === null)
          return this._fail('encoding_error', 'Could not decode a text frame as UTF-8');
        else
          this.emit('message', new Base.MessageEvent(payload));
      }, this);
    },
  
    _encode: function(buffer) {
      try {
        var string = buffer.toString('binary', 0, buffer.length);
        if (!this.UTF8_MATCH.test(string)) return null;
      } catch (e) {}
      return buffer.toString('utf8', 0, buffer.length);
    },
  
    _readUInt: function(buffer) {
      if (buffer.length === 2) return buffer.readUInt16BE(0);
  
      return buffer.readUInt32BE(0) * 0x100000000 +
             buffer.readUInt32BE(4);
    }
  };
  
  for (var key in instance)
    Hybi.prototype[key] = instance[key];
  
  module.exports = Hybi;
  
  
  /***/ }),
  /* 13 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var RingBuffer = function(bufferSize) {
    this._bufferSize = bufferSize;
    this.clear();
  };
  
  RingBuffer.prototype.clear = function() {
    this._buffer     = new Array(this._bufferSize);
    this._ringOffset = 0;
    this._ringSize   = this._bufferSize;
    this._head       = 0;
    this._tail       = 0;
    this.length      = 0;
  };
  
  RingBuffer.prototype.push = function(value) {
    var expandBuffer = false,
        expandRing   = false;
  
    if (this._ringSize < this._bufferSize) {
      expandBuffer = (this._tail === 0);
    } else if (this._ringOffset === this._ringSize) {
      expandBuffer = true;
      expandRing   = (this._tail === 0);
    }
  
    if (expandBuffer) {
      this._tail       = this._bufferSize;
      this._buffer     = this._buffer.concat(new Array(this._bufferSize));
      this._bufferSize = this._buffer.length;
  
      if (expandRing)
        this._ringSize = this._bufferSize;
    }
  
    this._buffer[this._tail] = value;
    this.length += 1;
    if (this._tail < this._ringSize) this._ringOffset += 1;
    this._tail = (this._tail + 1) % this._bufferSize;
  };
  
  RingBuffer.prototype.peek = function() {
    if (this.length === 0) return void 0;
    return this._buffer[this._head];
  };
  
  RingBuffer.prototype.shift = function() {
    if (this.length === 0) return void 0;
  
    var value = this._buffer[this._head];
    this._buffer[this._head] = void 0;
    this.length -= 1;
    this._ringOffset -= 1;
  
    if (this._ringOffset === 0 && this.length > 0) {
      this._head       = this._ringSize;
      this._ringOffset = this.length;
      this._ringSize   = this._bufferSize;
    } else {
      this._head = (this._head + 1) % this._ringSize;
    }
    return value;
  };
  
  module.exports = RingBuffer;
  
  
  /***/ }),
  /* 14 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var RingBuffer = __webpack_require__(13);
  
  var Pledge = function() {
    this._complete  = false;
    this._callbacks = new RingBuffer(Pledge.QUEUE_SIZE);
  };
  
  Pledge.QUEUE_SIZE = 4;
  
  Pledge.all = function(list) {
    var pledge  = new Pledge(),
        pending = list.length,
        n       = pending;
  
    if (pending === 0) pledge.done();
  
    while (n--) list[n].then(function() {
      pending -= 1;
      if (pending === 0) pledge.done();
    });
    return pledge;
  };
  
  Pledge.prototype.then = function(callback) {
    if (this._complete) callback();
    else this._callbacks.push(callback);
  };
  
  Pledge.prototype.done = function() {
    this._complete = true;
    var callbacks = this._callbacks, callback;
    while (callback = callbacks.shift()) callback();
  };
  
  module.exports = Pledge;
  
  
  /***/ }),
  /* 15 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var Buffer = __webpack_require__(1).Buffer,
      Base   = __webpack_require__(2),
      util   = __webpack_require__(0);
  
  var Draft75 = function(request, url, options) {
    Base.apply(this, arguments);
    this._stage  = 0;
    this.version = 'hixie-75';
  
    this._headers.set('Upgrade', 'WebSocket');
    this._headers.set('Connection', 'Upgrade');
    this._headers.set('WebSocket-Origin', this._request.headers.origin);
    this._headers.set('WebSocket-Location', this.url);
  };
  util.inherits(Draft75, Base);
  
  var instance = {
    close: function() {
      if (this.readyState === 3) return false;
      this.readyState = 3;
      this.emit('close', new Base.CloseEvent(null, null));
      return true;
    },
  
    parse: function(chunk) {
      if (this.readyState > 1) return;
  
      this._reader.put(chunk);
  
      this._reader.eachByte(function(octet) {
        var message;
  
        switch (this._stage) {
          case -1:
            this._body.push(octet);
            this._sendHandshakeBody();
            break;
  
          case 0:
            this._parseLeadingByte(octet);
            break;
  
          case 1:
            this._length = (octet & 0x7F) + 128 * this._length;
  
            if (this._closing && this._length === 0) {
              return this.close();
            }
            else if ((octet & 0x80) !== 0x80) {
              if (this._length === 0) {
                this._stage = 0;
              }
              else {
                this._skipped = 0;
                this._stage   = 2;
              }
            }
            break;
  
          case 2:
            if (octet === 0xFF) {
              this._stage = 0;
              message = Buffer.from(this._buffer).toString('utf8', 0, this._buffer.length);
              this.emit('message', new Base.MessageEvent(message));
            }
            else {
              if (this._length) {
                this._skipped += 1;
                if (this._skipped === this._length)
                  this._stage = 0;
              } else {
                this._buffer.push(octet);
                if (this._buffer.length > this._maxLength) return this.close();
              }
            }
            break;
        }
      }, this);
    },
  
    frame: function(buffer) {
      if (this.readyState === 0) return this._queue([buffer]);
      if (this.readyState > 1) return false;
  
      if (typeof buffer !== 'string') buffer = buffer.toString();
  
      var length = Buffer.byteLength(buffer),
          frame  = Buffer.allocUnsafe(length + 2);
  
      frame[0] = 0x00;
      frame.write(buffer, 1);
      frame[frame.length - 1] = 0xFF;
  
      this._write(frame);
      return true;
    },
  
    _handshakeResponse: function() {
      var start   = 'HTTP/1.1 101 Web Socket Protocol Handshake',
          headers = [start, this._headers.toString(), ''];
  
      return Buffer.from(headers.join('\r\n'), 'utf8');
    },
  
    _parseLeadingByte: function(octet) {
      if ((octet & 0x80) === 0x80) {
        this._length = 0;
        this._stage  = 1;
      } else {
        delete this._length;
        delete this._skipped;
        this._buffer = [];
        this._stage  = 2;
      }
    }
  };
  
  for (var key in instance)
    Draft75.prototype[key] = instance[key];
  
  module.exports = Draft75;
  
  
  /***/ }),
  /* 16 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var Event = __webpack_require__(7);
  
  var EventTarget = {
    onopen:     null,
    onmessage:  null,
    onerror:    null,
    onclose:    null,
  
    addEventListener: function(eventType, listener, useCapture) {
      this.on(eventType, listener);
    },
  
    removeEventListener: function(eventType, listener, useCapture) {
      this.removeListener(eventType, listener);
    },
  
    dispatchEvent: function(event) {
      event.target = event.currentTarget = this;
      event.eventPhase = Event.AT_TARGET;
  
      if (this['on' + event.type])
        this['on' + event.type](event);
  
      this.emit(event.type, event);
    }
  };
  
  module.exports = EventTarget;
  
  
  /***/ }),
  /* 17 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  // Copyright (C) 2016 Dmitry Chestnykh
  // MIT License. See LICENSE file for details.
  Object.defineProperty(exports, "__esModule", { value: true });
  /**
   * Package utf8 implements UTF-8 encoding and decoding.
   */
  var INVALID_UTF16 = "utf8: invalid string";
  var INVALID_UTF8 = "utf8: invalid source encoding";
  /**
   * Encodes the given string into UTF-8 byte array.
   * Throws if the source string has invalid UTF-16 encoding.
   */
  function encode(s) {
      // Calculate result length and allocate output array.
      // encodedLength() also validates string and throws errors,
      // so we don't need repeat validation here.
      var arr = new Uint8Array(encodedLength(s));
      var pos = 0;
      for (var i = 0; i < s.length; i++) {
          var c = s.charCodeAt(i);
          if (c < 0x80) {
              arr[pos++] = c;
          }
          else if (c < 0x800) {
              arr[pos++] = 0xc0 | c >> 6;
              arr[pos++] = 0x80 | c & 0x3f;
          }
          else if (c < 0xd800) {
              arr[pos++] = 0xe0 | c >> 12;
              arr[pos++] = 0x80 | (c >> 6) & 0x3f;
              arr[pos++] = 0x80 | c & 0x3f;
          }
          else {
              i++; // get one more character
              c = (c & 0x3ff) << 10;
              c |= s.charCodeAt(i) & 0x3ff;
              c += 0x10000;
              arr[pos++] = 0xf0 | c >> 18;
              arr[pos++] = 0x80 | (c >> 12) & 0x3f;
              arr[pos++] = 0x80 | (c >> 6) & 0x3f;
              arr[pos++] = 0x80 | c & 0x3f;
          }
      }
      return arr;
  }
  exports.encode = encode;
  /**
   * Returns the number of bytes required to encode the given string into UTF-8.
   * Throws if the source string has invalid UTF-16 encoding.
   */
  function encodedLength(s) {
      var result = 0;
      for (var i = 0; i < s.length; i++) {
          var c = s.charCodeAt(i);
          if (c < 0x80) {
              result += 1;
          }
          else if (c < 0x800) {
              result += 2;
          }
          else if (c < 0xd800) {
              result += 3;
          }
          else if (c <= 0xdfff) {
              if (i >= s.length - 1) {
                  throw new Error(INVALID_UTF16);
              }
              i++; // "eat" next character
              result += 4;
          }
          else {
              throw new Error(INVALID_UTF16);
          }
      }
      return result;
  }
  exports.encodedLength = encodedLength;
  /**
   * Decodes the given byte array from UTF-8 into a string.
   * Throws if encoding is invalid.
   */
  function decode(arr) {
      var chars = [];
      for (var i = 0; i < arr.length; i++) {
          var b = arr[i];
          if (b & 0x80) {
              var min = void 0;
              if (b < 0xe0) {
                  // Need 1 more byte.
                  if (i >= arr.length) {
                      throw new Error(INVALID_UTF8);
                  }
                  var n1 = arr[++i];
                  if ((n1 & 0xc0) !== 0x80) {
                      throw new Error(INVALID_UTF8);
                  }
                  b = (b & 0x1f) << 6 | (n1 & 0x3f);
                  min = 0x80;
              }
              else if (b < 0xf0) {
                  // Need 2 more bytes.
                  if (i >= arr.length - 1) {
                      throw new Error(INVALID_UTF8);
                  }
                  var n1 = arr[++i];
                  var n2 = arr[++i];
                  if ((n1 & 0xc0) !== 0x80 || (n2 & 0xc0) !== 0x80) {
                      throw new Error(INVALID_UTF8);
                  }
                  b = (b & 0x0f) << 12 | (n1 & 0x3f) << 6 | (n2 & 0x3f);
                  min = 0x800;
              }
              else if (b < 0xf8) {
                  // Need 3 more bytes.
                  if (i >= arr.length - 2) {
                      throw new Error(INVALID_UTF8);
                  }
                  var n1 = arr[++i];
                  var n2 = arr[++i];
                  var n3 = arr[++i];
                  if ((n1 & 0xc0) !== 0x80 || (n2 & 0xc0) !== 0x80 || (n3 & 0xc0) !== 0x80) {
                      throw new Error(INVALID_UTF8);
                  }
                  b = (b & 0x0f) << 18 | (n1 & 0x3f) << 12 | (n2 & 0x3f) << 6 | (n3 & 0x3f);
                  min = 0x10000;
              }
              else {
                  throw new Error(INVALID_UTF8);
              }
              if (b < min || (b >= 0xd800 && b <= 0xdfff)) {
                  throw new Error(INVALID_UTF8);
              }
              if (b >= 0x10000) {
                  // Surrogate pair.
                  if (b > 0x10ffff) {
                      throw new Error(INVALID_UTF8);
                  }
                  b -= 0x10000;
                  chars.push(String.fromCharCode(0xd800 | (b >> 10)));
                  b = 0xdc00 | (b & 0x3ff);
              }
          }
          chars.push(String.fromCharCode(b));
      }
      return chars.join("");
  }
  exports.decode = decode;
  //# sourceMappingURL=utf8.js.map
  
  /***/ }),
  /* 18 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // API references:
  //
  // * http://dev.w3.org/html5/websockets/
  // * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-eventtarget
  // * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-event
  
  var util   = __webpack_require__(0),
      driver = __webpack_require__(4),
      API    = __webpack_require__(11);
  
  var WebSocket = function(request, socket, body, protocols, options) {
    options = options || {};
  
    this._stream = socket;
    this._driver = driver.http(request, {maxLength: options.maxLength, protocols: protocols});
  
    var self = this;
    if (!this._stream || !this._stream.writable) return;
    if (!this._stream.readable) return this._stream.end();
  
    var catchup = function() { self._stream.removeListener('data', catchup) };
    this._stream.on('data', catchup);
  
    API.call(this, options);
  
    process.nextTick(function() {
      self._driver.start();
      self._driver.io.write(body);
    });
  };
  util.inherits(WebSocket, API);
  
  WebSocket.isWebSocket = function(request) {
    return driver.isWebSocket(request);
  };
  
  WebSocket.validateOptions = function(options, validKeys) {
    driver.validateOptions(options, validKeys);
  };
  
  WebSocket.WebSocket   = WebSocket;
  WebSocket.Client      = __webpack_require__(39);
  WebSocket.EventSource = __webpack_require__(42);
  
  module.exports        = WebSocket;
  
  
  /***/ }),
  /* 19 */
  /***/ (function(module, exports, __webpack_require__) {
  
  /**
   * Wrapper for built-in http.js to emulate the browser XMLHttpRequest object.
   *
   * This can be used with JS designed for browsers to improve reuse of code and
   * allow the use of existing libraries.
   *
   * Usage: include("XMLHttpRequest.js") and use XMLHttpRequest per W3C specs.
   *
   * @author Dan DeFelippi <dan@driverdan.com>
   * @contributor David Ellis <d.f.ellis@ieee.org>
   * @license MIT
   */
  
  var Url = __webpack_require__(6);
  var spawn = __webpack_require__(43).spawn;
  var fs = __webpack_require__(44);
  
  exports.XMLHttpRequest = function() {
    "use strict";
  
    /**
     * Private variables
     */
    var self = this;
    var http = __webpack_require__(45);
    var https = __webpack_require__(46);
  
    // Holds http.js objects
    var request;
    var response;
  
    // Request settings
    var settings = {};
  
    // Disable header blacklist.
    // Not part of XHR specs.
    var disableHeaderCheck = false;
  
    // Set some default headers
    var defaultHeaders = {
      "User-Agent": "node-XMLHttpRequest",
      "Accept": "*/*",
    };
  
    var headers = {};
    var headersCase = {};
  
    // These headers are not user setable.
    // The following are allowed but banned in the spec:
    // * user-agent
    var forbiddenRequestHeaders = [
      "accept-charset",
      "accept-encoding",
      "access-control-request-headers",
      "access-control-request-method",
      "connection",
      "content-length",
      "content-transfer-encoding",
      "cookie",
      "cookie2",
      "date",
      "expect",
      "host",
      "keep-alive",
      "origin",
      "referer",
      "te",
      "trailer",
      "transfer-encoding",
      "upgrade",
      "via"
    ];
  
    // These request methods are not allowed
    var forbiddenRequestMethods = [
      "TRACE",
      "TRACK",
      "CONNECT"
    ];
  
    // Send flag
    var sendFlag = false;
    // Error flag, used when errors occur or abort is called
    var errorFlag = false;
  
    // Event listeners
    var listeners = {};
  
    /**
     * Constants
     */
  
    this.UNSENT = 0;
    this.OPENED = 1;
    this.HEADERS_RECEIVED = 2;
    this.LOADING = 3;
    this.DONE = 4;
  
    /**
     * Public vars
     */
  
    // Current state
    this.readyState = this.UNSENT;
  
    // default ready state change handler in case one is not set or is set late
    this.onreadystatechange = null;
  
    // Result & response
    this.responseText = "";
    this.responseXML = "";
    this.status = null;
    this.statusText = null;
    
    // Whether cross-site Access-Control requests should be made using
    // credentials such as cookies or authorization headers
    this.withCredentials = false;
  
    /**
     * Private methods
     */
  
    /**
     * Check if the specified header is allowed.
     *
     * @param string header Header to validate
     * @return boolean False if not allowed, otherwise true
     */
    var isAllowedHttpHeader = function(header) {
      return disableHeaderCheck || (header && forbiddenRequestHeaders.indexOf(header.toLowerCase()) === -1);
    };
  
    /**
     * Check if the specified method is allowed.
     *
     * @param string method Request method to validate
     * @return boolean False if not allowed, otherwise true
     */
    var isAllowedHttpMethod = function(method) {
      return (method && forbiddenRequestMethods.indexOf(method) === -1);
    };
  
    /**
     * Public methods
     */
  
    /**
     * Open the connection. Currently supports local server requests.
     *
     * @param string method Connection method (eg GET, POST)
     * @param string url URL for the connection.
     * @param boolean async Asynchronous connection. Default is true.
     * @param string user Username for basic authentication (optional)
     * @param string password Password for basic authentication (optional)
     */
    this.open = function(method, url, async, user, password) {
      this.abort();
      errorFlag = false;
  
      // Check for valid request method
      if (!isAllowedHttpMethod(method)) {
        throw new Error("SecurityError: Request method not allowed");
      }
  
      settings = {
        "method": method,
        "url": url.toString(),
        "async": (typeof async !== "boolean" ? true : async),
        "user": user || null,
        "password": password || null
      };
  
      setState(this.OPENED);
    };
  
    /**
     * Disables or enables isAllowedHttpHeader() check the request. Enabled by default.
     * This does not conform to the W3C spec.
     *
     * @param boolean state Enable or disable header checking.
     */
    this.setDisableHeaderCheck = function(state) {
      disableHeaderCheck = state;
    };
  
    /**
     * Sets a header for the request or appends the value if one is already set.
     *
     * @param string header Header name
     * @param string value Header value
     */
    this.setRequestHeader = function(header, value) {
      if (this.readyState !== this.OPENED) {
        throw new Error("INVALID_STATE_ERR: setRequestHeader can only be called when state is OPEN");
      }
      if (!isAllowedHttpHeader(header)) {
        console.warn("Refused to set unsafe header \"" + header + "\"");
        return;
      }
      if (sendFlag) {
        throw new Error("INVALID_STATE_ERR: send flag is true");
      }
      header = headersCase[header.toLowerCase()] || header;
      headersCase[header.toLowerCase()] = header;
      headers[header] = headers[header] ? headers[header] + ', ' + value : value;
    };
  
    /**
     * Gets a header from the server response.
     *
     * @param string header Name of header to get.
     * @return string Text of the header or null if it doesn't exist.
     */
    this.getResponseHeader = function(header) {
      if (typeof header === "string"
        && this.readyState > this.OPENED
        && response
        && response.headers
        && response.headers[header.toLowerCase()]
        && !errorFlag
      ) {
        return response.headers[header.toLowerCase()];
      }
  
      return null;
    };
  
    /**
     * Gets all the response headers.
     *
     * @return string A string with all response headers separated by CR+LF
     */
    this.getAllResponseHeaders = function() {
      if (this.readyState < this.HEADERS_RECEIVED || errorFlag) {
        return "";
      }
      var result = "";
  
      for (var i in response.headers) {
        // Cookie headers are excluded
        if (i !== "set-cookie" && i !== "set-cookie2") {
          result += i + ": " + response.headers[i] + "\r\n";
        }
      }
      return result.substr(0, result.length - 2);
    };
  
    /**
     * Gets a request header
     *
     * @param string name Name of header to get
     * @return string Returns the request header or empty string if not set
     */
    this.getRequestHeader = function(name) {
      if (typeof name === "string" && headersCase[name.toLowerCase()]) {
        return headers[headersCase[name.toLowerCase()]];
      }
  
      return "";
    };
  
    /**
     * Sends the request to the server.
     *
     * @param string data Optional data to send as request body.
     */
    this.send = function(data) {
      if (this.readyState !== this.OPENED) {
        throw new Error("INVALID_STATE_ERR: connection must be opened before send() is called");
      }
  
      if (sendFlag) {
        throw new Error("INVALID_STATE_ERR: send has already been called");
      }
  
      var ssl = false, local = false;
      var url = Url.parse(settings.url);
      var host;
      // Determine the server
      switch (url.protocol) {
        case "https:":
          ssl = true;
          // SSL & non-SSL both need host, no break here.
        case "http:":
          host = url.hostname;
          break;
  
        case "file:":
          local = true;
          break;
  
        case undefined:
        case null:
        case "":
          host = "localhost";
          break;
  
        default:
          throw new Error("Protocol not supported.");
      }
  
      // Load files off the local filesystem (file://)
      if (local) {
        if (settings.method !== "GET") {
          throw new Error("XMLHttpRequest: Only GET method is supported");
        }
  
        if (settings.async) {
          fs.readFile(url.pathname, "utf8", function(error, data) {
            if (error) {
              self.handleError(error);
            } else {
              self.status = 200;
              self.responseText = data;
              setState(self.DONE);
            }
          });
        } else {
          try {
            this.responseText = fs.readFileSync(url.pathname, "utf8");
            this.status = 200;
            setState(self.DONE);
          } catch(e) {
            this.handleError(e);
          }
        }
  
        return;
      }
  
      // Default to port 80. If accessing localhost on another port be sure
      // to use http://localhost:port/path
      var port = url.port || (ssl ? 443 : 80);
      // Add query string if one is used
      var uri = url.pathname + (url.search ? url.search : "");
  
      // Set the defaults if they haven't been set
      for (var name in defaultHeaders) {
        if (!headersCase[name.toLowerCase()]) {
          headers[name] = defaultHeaders[name];
        }
      }
  
      // Set the Host header or the server may reject the request
      headers.Host = host;
      if (!((ssl && port === 443) || port === 80)) {
        headers.Host += ":" + url.port;
      }
  
      // Set Basic Auth if necessary
      if (settings.user) {
        if (typeof settings.password === "undefined") {
          settings.password = "";
        }
        var authBuf = new Buffer(settings.user + ":" + settings.password);
        headers.Authorization = "Basic " + authBuf.toString("base64");
      }
  
      // Set content length header
      if (settings.method === "GET" || settings.method === "HEAD") {
        data = null;
      } else if (data) {
        headers["Content-Length"] = Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data);
  
        if (!headers["Content-Type"]) {
          headers["Content-Type"] = "text/plain;charset=UTF-8";
        }
      } else if (settings.method === "POST") {
        // For a post with no data set Content-Length: 0.
        // This is required by buggy servers that don't meet the specs.
        headers["Content-Length"] = 0;
      }
  
      var options = {
        host: host,
        port: port,
        path: uri,
        method: settings.method,
        headers: headers,
        agent: false,
        withCredentials: self.withCredentials
      };
  
      // Reset error flag
      errorFlag = false;
  
      // Handle async requests
      if (settings.async) {
        // Use the proper protocol
        var doRequest = ssl ? https.request : http.request;
  
        // Request is being sent, set send flag
        sendFlag = true;
  
        // As per spec, this is called here for historical reasons.
        self.dispatchEvent("readystatechange");
  
        // Handler for the response
        var responseHandler = function responseHandler(resp) {
          // Set response var to the response we got back
          // This is so it remains accessable outside this scope
          response = resp;
          // Check for redirect
          // @TODO Prevent looped redirects
          if (response.statusCode === 301 || response.statusCode === 302 || response.statusCode === 303 || response.statusCode === 307) {
            // Change URL to the redirect location
            settings.url = response.headers.location;
            var url = Url.parse(settings.url);
            // Set host var in case it's used later
            host = url.hostname;
            // Options for the new request
            var newOptions = {
              hostname: url.hostname,
              port: url.port,
              path: url.path,
              method: response.statusCode === 303 ? "GET" : settings.method,
              headers: headers,
              withCredentials: self.withCredentials
            };
  
            // Issue the new request
            request = doRequest(newOptions, responseHandler).on("error", errorHandler);
            request.end();
            // @TODO Check if an XHR event needs to be fired here
            return;
          }
  
          response.setEncoding("utf8");
  
          setState(self.HEADERS_RECEIVED);
          self.status = response.statusCode;
  
          response.on("data", function(chunk) {
            // Make sure there's some data
            if (chunk) {
              self.responseText += chunk;
            }
            // Don't emit state changes if the connection has been aborted.
            if (sendFlag) {
              setState(self.LOADING);
            }
          });
  
          response.on("end", function() {
            if (sendFlag) {
              // Discard the end event if the connection has been aborted
              setState(self.DONE);
              sendFlag = false;
            }
          });
  
          response.on("error", function(error) {
            self.handleError(error);
          });
        };
  
        // Error handler for the request
        var errorHandler = function errorHandler(error) {
          self.handleError(error);
        };
  
        // Create the request
        request = doRequest(options, responseHandler).on("error", errorHandler);
  
        // Node 0.4 and later won't accept empty data. Make sure it's needed.
        if (data) {
          request.write(data);
        }
  
        request.end();
  
        self.dispatchEvent("loadstart");
      } else { // Synchronous
        // Create a temporary file for communication with the other Node process
        var contentFile = ".node-xmlhttprequest-content-" + process.pid;
        var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
        fs.writeFileSync(syncFile, "", "utf8");
        // The async request the other Node process executes
        var execString = "var http = require('http'), https = require('https'), fs = require('fs');"
          + "var doRequest = http" + (ssl ? "s" : "") + ".request;"
          + "var options = " + JSON.stringify(options) + ";"
          + "var responseText = '';"
          + "var req = doRequest(options, function(response) {"
          + "response.setEncoding('utf8');"
          + "response.on('data', function(chunk) {"
          + "  responseText += chunk;"
          + "});"
          + "response.on('end', function() {"
          + "fs.writeFileSync('" + contentFile + "', JSON.stringify({err: null, data: {statusCode: response.statusCode, headers: response.headers, text: responseText}}), 'utf8');"
          + "fs.unlinkSync('" + syncFile + "');"
          + "});"
          + "response.on('error', function(error) {"
          + "fs.writeFileSync('" + contentFile + "', JSON.stringify({err: error}), 'utf8');"
          + "fs.unlinkSync('" + syncFile + "');"
          + "});"
          + "}).on('error', function(error) {"
          + "fs.writeFileSync('" + contentFile + "', JSON.stringify({err: error}), 'utf8');"
          + "fs.unlinkSync('" + syncFile + "');"
          + "});"
          + (data ? "req.write('" + JSON.stringify(data).slice(1,-1).replace(/'/g, "\\'") + "');":"")
          + "req.end();";
        // Start the other Node Process, executing this string
        var syncProc = spawn(process.argv[0], ["-e", execString]);
        while(fs.existsSync(syncFile)) {
          // Wait while the sync file is empty
        }
        var resp = JSON.parse(fs.readFileSync(contentFile, 'utf8'));
        // Kill the child process once the file has data
        syncProc.stdin.end();
        // Remove the temporary file
        fs.unlinkSync(contentFile);
  
        if (resp.err) {
          self.handleError(resp.err);
        } else {
          response = resp.data;
          self.status = resp.data.statusCode;
          self.responseText = resp.data.text;
          setState(self.DONE);
        }
      }
    };
  
    /**
     * Called when an error is encountered to deal with it.
     */
    this.handleError = function(error) {
      this.status = 0;
      this.statusText = error;
      this.responseText = error.stack;
      errorFlag = true;
      setState(this.DONE);
      this.dispatchEvent('error');
    };
  
    /**
     * Aborts a request.
     */
    this.abort = function() {
      if (request) {
        request.abort();
        request = null;
      }
  
      headers = defaultHeaders;
      this.status = 0;
      this.responseText = "";
      this.responseXML = "";
  
      errorFlag = true;
  
      if (this.readyState !== this.UNSENT
          && (this.readyState !== this.OPENED || sendFlag)
          && this.readyState !== this.DONE) {
        sendFlag = false;
        setState(this.DONE);
      }
      this.readyState = this.UNSENT;
      this.dispatchEvent('abort');
    };
  
    /**
     * Adds an event listener. Preferred method of binding to events.
     */
    this.addEventListener = function(event, callback) {
      if (!(event in listeners)) {
        listeners[event] = [];
      }
      // Currently allows duplicate callbacks. Should it?
      listeners[event].push(callback);
    };
  
    /**
     * Remove an event callback that has already been bound.
     * Only works on the matching funciton, cannot be a copy.
     */
    this.removeEventListener = function(event, callback) {
      if (event in listeners) {
        // Filter will return a new array with the callback removed
        listeners[event] = listeners[event].filter(function(ev) {
          return ev !== callback;
        });
      }
    };
  
    /**
     * Dispatch any events, including both "on" methods and events attached using addEventListener.
     */
    this.dispatchEvent = function(event) {
      if (typeof self["on" + event] === "function") {
        self["on" + event]();
      }
      if (event in listeners) {
        for (var i = 0, len = listeners[event].length; i < len; i++) {
          listeners[event][i].call(self);
        }
      }
    };
  
    /**
     * Changes readyState and calls onreadystatechange.
     *
     * @param int state New state
     */
    var setState = function(state) {
      if (state == self.LOADING || self.readyState !== state) {
        self.readyState = state;
  
        if (settings.async || self.readyState < self.OPENED || self.readyState === self.DONE) {
          self.dispatchEvent("readystatechange");
        }
  
        if (self.readyState === self.DONE && !errorFlag) {
          self.dispatchEvent("load");
          // @TODO figure out InspectorInstrumentation::didLoadXHR(cookie)
          self.dispatchEvent("loadend");
        }
      }
    };
  };
  
  
  /***/ }),
  /* 20 */
  /***/ (function(module, exports, __webpack_require__) {
  
  (function(nacl) {
  'use strict';
  
  // Ported in 2014 by Dmitry Chestnykh and Devi Mandiri.
  // Public domain.
  //
  // Implementation derived from TweetNaCl version 20140427.
  // See for details: http://tweetnacl.cr.yp.to/
  
  var gf = function(init) {
    var i, r = new Float64Array(16);
    if (init) for (i = 0; i < init.length; i++) r[i] = init[i];
    return r;
  };
  
  //  Pluggable, initialized in high-level API below.
  var randombytes = function(/* x, n */) { throw new Error('no PRNG'); };
  
  var _0 = new Uint8Array(16);
  var _9 = new Uint8Array(32); _9[0] = 9;
  
  var gf0 = gf(),
      gf1 = gf([1]),
      _121665 = gf([0xdb41, 1]),
      D = gf([0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f, 0x6cee, 0x5203]),
      D2 = gf([0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df, 0xd9dc, 0x2406]),
      X = gf([0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e, 0x36d3, 0x2169]),
      Y = gf([0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666]),
      I = gf([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83]);
  
  function ts64(x, i, h, l) {
    x[i]   = (h >> 24) & 0xff;
    x[i+1] = (h >> 16) & 0xff;
    x[i+2] = (h >>  8) & 0xff;
    x[i+3] = h & 0xff;
    x[i+4] = (l >> 24)  & 0xff;
    x[i+5] = (l >> 16)  & 0xff;
    x[i+6] = (l >>  8)  & 0xff;
    x[i+7] = l & 0xff;
  }
  
  function vn(x, xi, y, yi, n) {
    var i,d = 0;
    for (i = 0; i < n; i++) d |= x[xi+i]^y[yi+i];
    return (1 & ((d - 1) >>> 8)) - 1;
  }
  
  function crypto_verify_16(x, xi, y, yi) {
    return vn(x,xi,y,yi,16);
  }
  
  function crypto_verify_32(x, xi, y, yi) {
    return vn(x,xi,y,yi,32);
  }
  
  function core_salsa20(o, p, k, c) {
    var j0  = c[ 0] & 0xff | (c[ 1] & 0xff)<<8 | (c[ 2] & 0xff)<<16 | (c[ 3] & 0xff)<<24,
        j1  = k[ 0] & 0xff | (k[ 1] & 0xff)<<8 | (k[ 2] & 0xff)<<16 | (k[ 3] & 0xff)<<24,
        j2  = k[ 4] & 0xff | (k[ 5] & 0xff)<<8 | (k[ 6] & 0xff)<<16 | (k[ 7] & 0xff)<<24,
        j3  = k[ 8] & 0xff | (k[ 9] & 0xff)<<8 | (k[10] & 0xff)<<16 | (k[11] & 0xff)<<24,
        j4  = k[12] & 0xff | (k[13] & 0xff)<<8 | (k[14] & 0xff)<<16 | (k[15] & 0xff)<<24,
        j5  = c[ 4] & 0xff | (c[ 5] & 0xff)<<8 | (c[ 6] & 0xff)<<16 | (c[ 7] & 0xff)<<24,
        j6  = p[ 0] & 0xff | (p[ 1] & 0xff)<<8 | (p[ 2] & 0xff)<<16 | (p[ 3] & 0xff)<<24,
        j7  = p[ 4] & 0xff | (p[ 5] & 0xff)<<8 | (p[ 6] & 0xff)<<16 | (p[ 7] & 0xff)<<24,
        j8  = p[ 8] & 0xff | (p[ 9] & 0xff)<<8 | (p[10] & 0xff)<<16 | (p[11] & 0xff)<<24,
        j9  = p[12] & 0xff | (p[13] & 0xff)<<8 | (p[14] & 0xff)<<16 | (p[15] & 0xff)<<24,
        j10 = c[ 8] & 0xff | (c[ 9] & 0xff)<<8 | (c[10] & 0xff)<<16 | (c[11] & 0xff)<<24,
        j11 = k[16] & 0xff | (k[17] & 0xff)<<8 | (k[18] & 0xff)<<16 | (k[19] & 0xff)<<24,
        j12 = k[20] & 0xff | (k[21] & 0xff)<<8 | (k[22] & 0xff)<<16 | (k[23] & 0xff)<<24,
        j13 = k[24] & 0xff | (k[25] & 0xff)<<8 | (k[26] & 0xff)<<16 | (k[27] & 0xff)<<24,
        j14 = k[28] & 0xff | (k[29] & 0xff)<<8 | (k[30] & 0xff)<<16 | (k[31] & 0xff)<<24,
        j15 = c[12] & 0xff | (c[13] & 0xff)<<8 | (c[14] & 0xff)<<16 | (c[15] & 0xff)<<24;
  
    var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7,
        x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14,
        x15 = j15, u;
  
    for (var i = 0; i < 20; i += 2) {
      u = x0 + x12 | 0;
      x4 ^= u<<7 | u>>>(32-7);
      u = x4 + x0 | 0;
      x8 ^= u<<9 | u>>>(32-9);
      u = x8 + x4 | 0;
      x12 ^= u<<13 | u>>>(32-13);
      u = x12 + x8 | 0;
      x0 ^= u<<18 | u>>>(32-18);
  
      u = x5 + x1 | 0;
      x9 ^= u<<7 | u>>>(32-7);
      u = x9 + x5 | 0;
      x13 ^= u<<9 | u>>>(32-9);
      u = x13 + x9 | 0;
      x1 ^= u<<13 | u>>>(32-13);
      u = x1 + x13 | 0;
      x5 ^= u<<18 | u>>>(32-18);
  
      u = x10 + x6 | 0;
      x14 ^= u<<7 | u>>>(32-7);
      u = x14 + x10 | 0;
      x2 ^= u<<9 | u>>>(32-9);
      u = x2 + x14 | 0;
      x6 ^= u<<13 | u>>>(32-13);
      u = x6 + x2 | 0;
      x10 ^= u<<18 | u>>>(32-18);
  
      u = x15 + x11 | 0;
      x3 ^= u<<7 | u>>>(32-7);
      u = x3 + x15 | 0;
      x7 ^= u<<9 | u>>>(32-9);
      u = x7 + x3 | 0;
      x11 ^= u<<13 | u>>>(32-13);
      u = x11 + x7 | 0;
      x15 ^= u<<18 | u>>>(32-18);
  
      u = x0 + x3 | 0;
      x1 ^= u<<7 | u>>>(32-7);
      u = x1 + x0 | 0;
      x2 ^= u<<9 | u>>>(32-9);
      u = x2 + x1 | 0;
      x3 ^= u<<13 | u>>>(32-13);
      u = x3 + x2 | 0;
      x0 ^= u<<18 | u>>>(32-18);
  
      u = x5 + x4 | 0;
      x6 ^= u<<7 | u>>>(32-7);
      u = x6 + x5 | 0;
      x7 ^= u<<9 | u>>>(32-9);
      u = x7 + x6 | 0;
      x4 ^= u<<13 | u>>>(32-13);
      u = x4 + x7 | 0;
      x5 ^= u<<18 | u>>>(32-18);
  
      u = x10 + x9 | 0;
      x11 ^= u<<7 | u>>>(32-7);
      u = x11 + x10 | 0;
      x8 ^= u<<9 | u>>>(32-9);
      u = x8 + x11 | 0;
      x9 ^= u<<13 | u>>>(32-13);
      u = x9 + x8 | 0;
      x10 ^= u<<18 | u>>>(32-18);
  
      u = x15 + x14 | 0;
      x12 ^= u<<7 | u>>>(32-7);
      u = x12 + x15 | 0;
      x13 ^= u<<9 | u>>>(32-9);
      u = x13 + x12 | 0;
      x14 ^= u<<13 | u>>>(32-13);
      u = x14 + x13 | 0;
      x15 ^= u<<18 | u>>>(32-18);
    }
     x0 =  x0 +  j0 | 0;
     x1 =  x1 +  j1 | 0;
     x2 =  x2 +  j2 | 0;
     x3 =  x3 +  j3 | 0;
     x4 =  x4 +  j4 | 0;
     x5 =  x5 +  j5 | 0;
     x6 =  x6 +  j6 | 0;
     x7 =  x7 +  j7 | 0;
     x8 =  x8 +  j8 | 0;
     x9 =  x9 +  j9 | 0;
    x10 = x10 + j10 | 0;
    x11 = x11 + j11 | 0;
    x12 = x12 + j12 | 0;
    x13 = x13 + j13 | 0;
    x14 = x14 + j14 | 0;
    x15 = x15 + j15 | 0;
  
    o[ 0] = x0 >>>  0 & 0xff;
    o[ 1] = x0 >>>  8 & 0xff;
    o[ 2] = x0 >>> 16 & 0xff;
    o[ 3] = x0 >>> 24 & 0xff;
  
    o[ 4] = x1 >>>  0 & 0xff;
    o[ 5] = x1 >>>  8 & 0xff;
    o[ 6] = x1 >>> 16 & 0xff;
    o[ 7] = x1 >>> 24 & 0xff;
  
    o[ 8] = x2 >>>  0 & 0xff;
    o[ 9] = x2 >>>  8 & 0xff;
    o[10] = x2 >>> 16 & 0xff;
    o[11] = x2 >>> 24 & 0xff;
  
    o[12] = x3 >>>  0 & 0xff;
    o[13] = x3 >>>  8 & 0xff;
    o[14] = x3 >>> 16 & 0xff;
    o[15] = x3 >>> 24 & 0xff;
  
    o[16] = x4 >>>  0 & 0xff;
    o[17] = x4 >>>  8 & 0xff;
    o[18] = x4 >>> 16 & 0xff;
    o[19] = x4 >>> 24 & 0xff;
  
    o[20] = x5 >>>  0 & 0xff;
    o[21] = x5 >>>  8 & 0xff;
    o[22] = x5 >>> 16 & 0xff;
    o[23] = x5 >>> 24 & 0xff;
  
    o[24] = x6 >>>  0 & 0xff;
    o[25] = x6 >>>  8 & 0xff;
    o[26] = x6 >>> 16 & 0xff;
    o[27] = x6 >>> 24 & 0xff;
  
    o[28] = x7 >>>  0 & 0xff;
    o[29] = x7 >>>  8 & 0xff;
    o[30] = x7 >>> 16 & 0xff;
    o[31] = x7 >>> 24 & 0xff;
  
    o[32] = x8 >>>  0 & 0xff;
    o[33] = x8 >>>  8 & 0xff;
    o[34] = x8 >>> 16 & 0xff;
    o[35] = x8 >>> 24 & 0xff;
  
    o[36] = x9 >>>  0 & 0xff;
    o[37] = x9 >>>  8 & 0xff;
    o[38] = x9 >>> 16 & 0xff;
    o[39] = x9 >>> 24 & 0xff;
  
    o[40] = x10 >>>  0 & 0xff;
    o[41] = x10 >>>  8 & 0xff;
    o[42] = x10 >>> 16 & 0xff;
    o[43] = x10 >>> 24 & 0xff;
  
    o[44] = x11 >>>  0 & 0xff;
    o[45] = x11 >>>  8 & 0xff;
    o[46] = x11 >>> 16 & 0xff;
    o[47] = x11 >>> 24 & 0xff;
  
    o[48] = x12 >>>  0 & 0xff;
    o[49] = x12 >>>  8 & 0xff;
    o[50] = x12 >>> 16 & 0xff;
    o[51] = x12 >>> 24 & 0xff;
  
    o[52] = x13 >>>  0 & 0xff;
    o[53] = x13 >>>  8 & 0xff;
    o[54] = x13 >>> 16 & 0xff;
    o[55] = x13 >>> 24 & 0xff;
  
    o[56] = x14 >>>  0 & 0xff;
    o[57] = x14 >>>  8 & 0xff;
    o[58] = x14 >>> 16 & 0xff;
    o[59] = x14 >>> 24 & 0xff;
  
    o[60] = x15 >>>  0 & 0xff;
    o[61] = x15 >>>  8 & 0xff;
    o[62] = x15 >>> 16 & 0xff;
    o[63] = x15 >>> 24 & 0xff;
  }
  
  function core_hsalsa20(o,p,k,c) {
    var j0  = c[ 0] & 0xff | (c[ 1] & 0xff)<<8 | (c[ 2] & 0xff)<<16 | (c[ 3] & 0xff)<<24,
        j1  = k[ 0] & 0xff | (k[ 1] & 0xff)<<8 | (k[ 2] & 0xff)<<16 | (k[ 3] & 0xff)<<24,
        j2  = k[ 4] & 0xff | (k[ 5] & 0xff)<<8 | (k[ 6] & 0xff)<<16 | (k[ 7] & 0xff)<<24,
        j3  = k[ 8] & 0xff | (k[ 9] & 0xff)<<8 | (k[10] & 0xff)<<16 | (k[11] & 0xff)<<24,
        j4  = k[12] & 0xff | (k[13] & 0xff)<<8 | (k[14] & 0xff)<<16 | (k[15] & 0xff)<<24,
        j5  = c[ 4] & 0xff | (c[ 5] & 0xff)<<8 | (c[ 6] & 0xff)<<16 | (c[ 7] & 0xff)<<24,
        j6  = p[ 0] & 0xff | (p[ 1] & 0xff)<<8 | (p[ 2] & 0xff)<<16 | (p[ 3] & 0xff)<<24,
        j7  = p[ 4] & 0xff | (p[ 5] & 0xff)<<8 | (p[ 6] & 0xff)<<16 | (p[ 7] & 0xff)<<24,
        j8  = p[ 8] & 0xff | (p[ 9] & 0xff)<<8 | (p[10] & 0xff)<<16 | (p[11] & 0xff)<<24,
        j9  = p[12] & 0xff | (p[13] & 0xff)<<8 | (p[14] & 0xff)<<16 | (p[15] & 0xff)<<24,
        j10 = c[ 8] & 0xff | (c[ 9] & 0xff)<<8 | (c[10] & 0xff)<<16 | (c[11] & 0xff)<<24,
        j11 = k[16] & 0xff | (k[17] & 0xff)<<8 | (k[18] & 0xff)<<16 | (k[19] & 0xff)<<24,
        j12 = k[20] & 0xff | (k[21] & 0xff)<<8 | (k[22] & 0xff)<<16 | (k[23] & 0xff)<<24,
        j13 = k[24] & 0xff | (k[25] & 0xff)<<8 | (k[26] & 0xff)<<16 | (k[27] & 0xff)<<24,
        j14 = k[28] & 0xff | (k[29] & 0xff)<<8 | (k[30] & 0xff)<<16 | (k[31] & 0xff)<<24,
        j15 = c[12] & 0xff | (c[13] & 0xff)<<8 | (c[14] & 0xff)<<16 | (c[15] & 0xff)<<24;
  
    var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7,
        x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14,
        x15 = j15, u;
  
    for (var i = 0; i < 20; i += 2) {
      u = x0 + x12 | 0;
      x4 ^= u<<7 | u>>>(32-7);
      u = x4 + x0 | 0;
      x8 ^= u<<9 | u>>>(32-9);
      u = x8 + x4 | 0;
      x12 ^= u<<13 | u>>>(32-13);
      u = x12 + x8 | 0;
      x0 ^= u<<18 | u>>>(32-18);
  
      u = x5 + x1 | 0;
      x9 ^= u<<7 | u>>>(32-7);
      u = x9 + x5 | 0;
      x13 ^= u<<9 | u>>>(32-9);
      u = x13 + x9 | 0;
      x1 ^= u<<13 | u>>>(32-13);
      u = x1 + x13 | 0;
      x5 ^= u<<18 | u>>>(32-18);
  
      u = x10 + x6 | 0;
      x14 ^= u<<7 | u>>>(32-7);
      u = x14 + x10 | 0;
      x2 ^= u<<9 | u>>>(32-9);
      u = x2 + x14 | 0;
      x6 ^= u<<13 | u>>>(32-13);
      u = x6 + x2 | 0;
      x10 ^= u<<18 | u>>>(32-18);
  
      u = x15 + x11 | 0;
      x3 ^= u<<7 | u>>>(32-7);
      u = x3 + x15 | 0;
      x7 ^= u<<9 | u>>>(32-9);
      u = x7 + x3 | 0;
      x11 ^= u<<13 | u>>>(32-13);
      u = x11 + x7 | 0;
      x15 ^= u<<18 | u>>>(32-18);
  
      u = x0 + x3 | 0;
      x1 ^= u<<7 | u>>>(32-7);
      u = x1 + x0 | 0;
      x2 ^= u<<9 | u>>>(32-9);
      u = x2 + x1 | 0;
      x3 ^= u<<13 | u>>>(32-13);
      u = x3 + x2 | 0;
      x0 ^= u<<18 | u>>>(32-18);
  
      u = x5 + x4 | 0;
      x6 ^= u<<7 | u>>>(32-7);
      u = x6 + x5 | 0;
      x7 ^= u<<9 | u>>>(32-9);
      u = x7 + x6 | 0;
      x4 ^= u<<13 | u>>>(32-13);
      u = x4 + x7 | 0;
      x5 ^= u<<18 | u>>>(32-18);
  
      u = x10 + x9 | 0;
      x11 ^= u<<7 | u>>>(32-7);
      u = x11 + x10 | 0;
      x8 ^= u<<9 | u>>>(32-9);
      u = x8 + x11 | 0;
      x9 ^= u<<13 | u>>>(32-13);
      u = x9 + x8 | 0;
      x10 ^= u<<18 | u>>>(32-18);
  
      u = x15 + x14 | 0;
      x12 ^= u<<7 | u>>>(32-7);
      u = x12 + x15 | 0;
      x13 ^= u<<9 | u>>>(32-9);
      u = x13 + x12 | 0;
      x14 ^= u<<13 | u>>>(32-13);
      u = x14 + x13 | 0;
      x15 ^= u<<18 | u>>>(32-18);
    }
  
    o[ 0] = x0 >>>  0 & 0xff;
    o[ 1] = x0 >>>  8 & 0xff;
    o[ 2] = x0 >>> 16 & 0xff;
    o[ 3] = x0 >>> 24 & 0xff;
  
    o[ 4] = x5 >>>  0 & 0xff;
    o[ 5] = x5 >>>  8 & 0xff;
    o[ 6] = x5 >>> 16 & 0xff;
    o[ 7] = x5 >>> 24 & 0xff;
  
    o[ 8] = x10 >>>  0 & 0xff;
    o[ 9] = x10 >>>  8 & 0xff;
    o[10] = x10 >>> 16 & 0xff;
    o[11] = x10 >>> 24 & 0xff;
  
    o[12] = x15 >>>  0 & 0xff;
    o[13] = x15 >>>  8 & 0xff;
    o[14] = x15 >>> 16 & 0xff;
    o[15] = x15 >>> 24 & 0xff;
  
    o[16] = x6 >>>  0 & 0xff;
    o[17] = x6 >>>  8 & 0xff;
    o[18] = x6 >>> 16 & 0xff;
    o[19] = x6 >>> 24 & 0xff;
  
    o[20] = x7 >>>  0 & 0xff;
    o[21] = x7 >>>  8 & 0xff;
    o[22] = x7 >>> 16 & 0xff;
    o[23] = x7 >>> 24 & 0xff;
  
    o[24] = x8 >>>  0 & 0xff;
    o[25] = x8 >>>  8 & 0xff;
    o[26] = x8 >>> 16 & 0xff;
    o[27] = x8 >>> 24 & 0xff;
  
    o[28] = x9 >>>  0 & 0xff;
    o[29] = x9 >>>  8 & 0xff;
    o[30] = x9 >>> 16 & 0xff;
    o[31] = x9 >>> 24 & 0xff;
  }
  
  function crypto_core_salsa20(out,inp,k,c) {
    core_salsa20(out,inp,k,c);
  }
  
  function crypto_core_hsalsa20(out,inp,k,c) {
    core_hsalsa20(out,inp,k,c);
  }
  
  var sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]);
              // "expand 32-byte k"
  
  function crypto_stream_salsa20_xor(c,cpos,m,mpos,b,n,k) {
    var z = new Uint8Array(16), x = new Uint8Array(64);
    var u, i;
    for (i = 0; i < 16; i++) z[i] = 0;
    for (i = 0; i < 8; i++) z[i] = n[i];
    while (b >= 64) {
      crypto_core_salsa20(x,z,k,sigma);
      for (i = 0; i < 64; i++) c[cpos+i] = m[mpos+i] ^ x[i];
      u = 1;
      for (i = 8; i < 16; i++) {
        u = u + (z[i] & 0xff) | 0;
        z[i] = u & 0xff;
        u >>>= 8;
      }
      b -= 64;
      cpos += 64;
      mpos += 64;
    }
    if (b > 0) {
      crypto_core_salsa20(x,z,k,sigma);
      for (i = 0; i < b; i++) c[cpos+i] = m[mpos+i] ^ x[i];
    }
    return 0;
  }
  
  function crypto_stream_salsa20(c,cpos,b,n,k) {
    var z = new Uint8Array(16), x = new Uint8Array(64);
    var u, i;
    for (i = 0; i < 16; i++) z[i] = 0;
    for (i = 0; i < 8; i++) z[i] = n[i];
    while (b >= 64) {
      crypto_core_salsa20(x,z,k,sigma);
      for (i = 0; i < 64; i++) c[cpos+i] = x[i];
      u = 1;
      for (i = 8; i < 16; i++) {
        u = u + (z[i] & 0xff) | 0;
        z[i] = u & 0xff;
        u >>>= 8;
      }
      b -= 64;
      cpos += 64;
    }
    if (b > 0) {
      crypto_core_salsa20(x,z,k,sigma);
      for (i = 0; i < b; i++) c[cpos+i] = x[i];
    }
    return 0;
  }
  
  function crypto_stream(c,cpos,d,n,k) {
    var s = new Uint8Array(32);
    crypto_core_hsalsa20(s,n,k,sigma);
    var sn = new Uint8Array(8);
    for (var i = 0; i < 8; i++) sn[i] = n[i+16];
    return crypto_stream_salsa20(c,cpos,d,sn,s);
  }
  
  function crypto_stream_xor(c,cpos,m,mpos,d,n,k) {
    var s = new Uint8Array(32);
    crypto_core_hsalsa20(s,n,k,sigma);
    var sn = new Uint8Array(8);
    for (var i = 0; i < 8; i++) sn[i] = n[i+16];
    return crypto_stream_salsa20_xor(c,cpos,m,mpos,d,sn,s);
  }
  
  /*
  * Port of Andrew Moon's Poly1305-donna-16. Public domain.
  * https://github.com/floodyberry/poly1305-donna
  */
  
  var poly1305 = function(key) {
    this.buffer = new Uint8Array(16);
    this.r = new Uint16Array(10);
    this.h = new Uint16Array(10);
    this.pad = new Uint16Array(8);
    this.leftover = 0;
    this.fin = 0;
  
    var t0, t1, t2, t3, t4, t5, t6, t7;
  
    t0 = key[ 0] & 0xff | (key[ 1] & 0xff) << 8; this.r[0] = ( t0                     ) & 0x1fff;
    t1 = key[ 2] & 0xff | (key[ 3] & 0xff) << 8; this.r[1] = ((t0 >>> 13) | (t1 <<  3)) & 0x1fff;
    t2 = key[ 4] & 0xff | (key[ 5] & 0xff) << 8; this.r[2] = ((t1 >>> 10) | (t2 <<  6)) & 0x1f03;
    t3 = key[ 6] & 0xff | (key[ 7] & 0xff) << 8; this.r[3] = ((t2 >>>  7) | (t3 <<  9)) & 0x1fff;
    t4 = key[ 8] & 0xff | (key[ 9] & 0xff) << 8; this.r[4] = ((t3 >>>  4) | (t4 << 12)) & 0x00ff;
    this.r[5] = ((t4 >>>  1)) & 0x1ffe;
    t5 = key[10] & 0xff | (key[11] & 0xff) << 8; this.r[6] = ((t4 >>> 14) | (t5 <<  2)) & 0x1fff;
    t6 = key[12] & 0xff | (key[13] & 0xff) << 8; this.r[7] = ((t5 >>> 11) | (t6 <<  5)) & 0x1f81;
    t7 = key[14] & 0xff | (key[15] & 0xff) << 8; this.r[8] = ((t6 >>>  8) | (t7 <<  8)) & 0x1fff;
    this.r[9] = ((t7 >>>  5)) & 0x007f;
  
    this.pad[0] = key[16] & 0xff | (key[17] & 0xff) << 8;
    this.pad[1] = key[18] & 0xff | (key[19] & 0xff) << 8;
    this.pad[2] = key[20] & 0xff | (key[21] & 0xff) << 8;
    this.pad[3] = key[22] & 0xff | (key[23] & 0xff) << 8;
    this.pad[4] = key[24] & 0xff | (key[25] & 0xff) << 8;
    this.pad[5] = key[26] & 0xff | (key[27] & 0xff) << 8;
    this.pad[6] = key[28] & 0xff | (key[29] & 0xff) << 8;
    this.pad[7] = key[30] & 0xff | (key[31] & 0xff) << 8;
  };
  
  poly1305.prototype.blocks = function(m, mpos, bytes) {
    var hibit = this.fin ? 0 : (1 << 11);
    var t0, t1, t2, t3, t4, t5, t6, t7, c;
    var d0, d1, d2, d3, d4, d5, d6, d7, d8, d9;
  
    var h0 = this.h[0],
        h1 = this.h[1],
        h2 = this.h[2],
        h3 = this.h[3],
        h4 = this.h[4],
        h5 = this.h[5],
        h6 = this.h[6],
        h7 = this.h[7],
        h8 = this.h[8],
        h9 = this.h[9];
  
    var r0 = this.r[0],
        r1 = this.r[1],
        r2 = this.r[2],
        r3 = this.r[3],
        r4 = this.r[4],
        r5 = this.r[5],
        r6 = this.r[6],
        r7 = this.r[7],
        r8 = this.r[8],
        r9 = this.r[9];
  
    while (bytes >= 16) {
      t0 = m[mpos+ 0] & 0xff | (m[mpos+ 1] & 0xff) << 8; h0 += ( t0                     ) & 0x1fff;
      t1 = m[mpos+ 2] & 0xff | (m[mpos+ 3] & 0xff) << 8; h1 += ((t0 >>> 13) | (t1 <<  3)) & 0x1fff;
      t2 = m[mpos+ 4] & 0xff | (m[mpos+ 5] & 0xff) << 8; h2 += ((t1 >>> 10) | (t2 <<  6)) & 0x1fff;
      t3 = m[mpos+ 6] & 0xff | (m[mpos+ 7] & 0xff) << 8; h3 += ((t2 >>>  7) | (t3 <<  9)) & 0x1fff;
      t4 = m[mpos+ 8] & 0xff | (m[mpos+ 9] & 0xff) << 8; h4 += ((t3 >>>  4) | (t4 << 12)) & 0x1fff;
      h5 += ((t4 >>>  1)) & 0x1fff;
      t5 = m[mpos+10] & 0xff | (m[mpos+11] & 0xff) << 8; h6 += ((t4 >>> 14) | (t5 <<  2)) & 0x1fff;
      t6 = m[mpos+12] & 0xff | (m[mpos+13] & 0xff) << 8; h7 += ((t5 >>> 11) | (t6 <<  5)) & 0x1fff;
      t7 = m[mpos+14] & 0xff | (m[mpos+15] & 0xff) << 8; h8 += ((t6 >>>  8) | (t7 <<  8)) & 0x1fff;
      h9 += ((t7 >>> 5)) | hibit;
  
      c = 0;
  
      d0 = c;
      d0 += h0 * r0;
      d0 += h1 * (5 * r9);
      d0 += h2 * (5 * r8);
      d0 += h3 * (5 * r7);
      d0 += h4 * (5 * r6);
      c = (d0 >>> 13); d0 &= 0x1fff;
      d0 += h5 * (5 * r5);
      d0 += h6 * (5 * r4);
      d0 += h7 * (5 * r3);
      d0 += h8 * (5 * r2);
      d0 += h9 * (5 * r1);
      c += (d0 >>> 13); d0 &= 0x1fff;
  
      d1 = c;
      d1 += h0 * r1;
      d1 += h1 * r0;
      d1 += h2 * (5 * r9);
      d1 += h3 * (5 * r8);
      d1 += h4 * (5 * r7);
      c = (d1 >>> 13); d1 &= 0x1fff;
      d1 += h5 * (5 * r6);
      d1 += h6 * (5 * r5);
      d1 += h7 * (5 * r4);
      d1 += h8 * (5 * r3);
      d1 += h9 * (5 * r2);
      c += (d1 >>> 13); d1 &= 0x1fff;
  
      d2 = c;
      d2 += h0 * r2;
      d2 += h1 * r1;
      d2 += h2 * r0;
      d2 += h3 * (5 * r9);
      d2 += h4 * (5 * r8);
      c = (d2 >>> 13); d2 &= 0x1fff;
      d2 += h5 * (5 * r7);
      d2 += h6 * (5 * r6);
      d2 += h7 * (5 * r5);
      d2 += h8 * (5 * r4);
      d2 += h9 * (5 * r3);
      c += (d2 >>> 13); d2 &= 0x1fff;
  
      d3 = c;
      d3 += h0 * r3;
      d3 += h1 * r2;
      d3 += h2 * r1;
      d3 += h3 * r0;
      d3 += h4 * (5 * r9);
      c = (d3 >>> 13); d3 &= 0x1fff;
      d3 += h5 * (5 * r8);
      d3 += h6 * (5 * r7);
      d3 += h7 * (5 * r6);
      d3 += h8 * (5 * r5);
      d3 += h9 * (5 * r4);
      c += (d3 >>> 13); d3 &= 0x1fff;
  
      d4 = c;
      d4 += h0 * r4;
      d4 += h1 * r3;
      d4 += h2 * r2;
      d4 += h3 * r1;
      d4 += h4 * r0;
      c = (d4 >>> 13); d4 &= 0x1fff;
      d4 += h5 * (5 * r9);
      d4 += h6 * (5 * r8);
      d4 += h7 * (5 * r7);
      d4 += h8 * (5 * r6);
      d4 += h9 * (5 * r5);
      c += (d4 >>> 13); d4 &= 0x1fff;
  
      d5 = c;
      d5 += h0 * r5;
      d5 += h1 * r4;
      d5 += h2 * r3;
      d5 += h3 * r2;
      d5 += h4 * r1;
      c = (d5 >>> 13); d5 &= 0x1fff;
      d5 += h5 * r0;
      d5 += h6 * (5 * r9);
      d5 += h7 * (5 * r8);
      d5 += h8 * (5 * r7);
      d5 += h9 * (5 * r6);
      c += (d5 >>> 13); d5 &= 0x1fff;
  
      d6 = c;
      d6 += h0 * r6;
      d6 += h1 * r5;
      d6 += h2 * r4;
      d6 += h3 * r3;
      d6 += h4 * r2;
      c = (d6 >>> 13); d6 &= 0x1fff;
      d6 += h5 * r1;
      d6 += h6 * r0;
      d6 += h7 * (5 * r9);
      d6 += h8 * (5 * r8);
      d6 += h9 * (5 * r7);
      c += (d6 >>> 13); d6 &= 0x1fff;
  
      d7 = c;
      d7 += h0 * r7;
      d7 += h1 * r6;
      d7 += h2 * r5;
      d7 += h3 * r4;
      d7 += h4 * r3;
      c = (d7 >>> 13); d7 &= 0x1fff;
      d7 += h5 * r2;
      d7 += h6 * r1;
      d7 += h7 * r0;
      d7 += h8 * (5 * r9);
      d7 += h9 * (5 * r8);
      c += (d7 >>> 13); d7 &= 0x1fff;
  
      d8 = c;
      d8 += h0 * r8;
      d8 += h1 * r7;
      d8 += h2 * r6;
      d8 += h3 * r5;
      d8 += h4 * r4;
      c = (d8 >>> 13); d8 &= 0x1fff;
      d8 += h5 * r3;
      d8 += h6 * r2;
      d8 += h7 * r1;
      d8 += h8 * r0;
      d8 += h9 * (5 * r9);
      c += (d8 >>> 13); d8 &= 0x1fff;
  
      d9 = c;
      d9 += h0 * r9;
      d9 += h1 * r8;
      d9 += h2 * r7;
      d9 += h3 * r6;
      d9 += h4 * r5;
      c = (d9 >>> 13); d9 &= 0x1fff;
      d9 += h5 * r4;
      d9 += h6 * r3;
      d9 += h7 * r2;
      d9 += h8 * r1;
      d9 += h9 * r0;
      c += (d9 >>> 13); d9 &= 0x1fff;
  
      c = (((c << 2) + c)) | 0;
      c = (c + d0) | 0;
      d0 = c & 0x1fff;
      c = (c >>> 13);
      d1 += c;
  
      h0 = d0;
      h1 = d1;
      h2 = d2;
      h3 = d3;
      h4 = d4;
      h5 = d5;
      h6 = d6;
      h7 = d7;
      h8 = d8;
      h9 = d9;
  
      mpos += 16;
      bytes -= 16;
    }
    this.h[0] = h0;
    this.h[1] = h1;
    this.h[2] = h2;
    this.h[3] = h3;
    this.h[4] = h4;
    this.h[5] = h5;
    this.h[6] = h6;
    this.h[7] = h7;
    this.h[8] = h8;
    this.h[9] = h9;
  };
  
  poly1305.prototype.finish = function(mac, macpos) {
    var g = new Uint16Array(10);
    var c, mask, f, i;
  
    if (this.leftover) {
      i = this.leftover;
      this.buffer[i++] = 1;
      for (; i < 16; i++) this.buffer[i] = 0;
      this.fin = 1;
      this.blocks(this.buffer, 0, 16);
    }
  
    c = this.h[1] >>> 13;
    this.h[1] &= 0x1fff;
    for (i = 2; i < 10; i++) {
      this.h[i] += c;
      c = this.h[i] >>> 13;
      this.h[i] &= 0x1fff;
    }
    this.h[0] += (c * 5);
    c = this.h[0] >>> 13;
    this.h[0] &= 0x1fff;
    this.h[1] += c;
    c = this.h[1] >>> 13;
    this.h[1] &= 0x1fff;
    this.h[2] += c;
  
    g[0] = this.h[0] + 5;
    c = g[0] >>> 13;
    g[0] &= 0x1fff;
    for (i = 1; i < 10; i++) {
      g[i] = this.h[i] + c;
      c = g[i] >>> 13;
      g[i] &= 0x1fff;
    }
    g[9] -= (1 << 13);
  
    mask = (c ^ 1) - 1;
    for (i = 0; i < 10; i++) g[i] &= mask;
    mask = ~mask;
    for (i = 0; i < 10; i++) this.h[i] = (this.h[i] & mask) | g[i];
  
    this.h[0] = ((this.h[0]       ) | (this.h[1] << 13)                    ) & 0xffff;
    this.h[1] = ((this.h[1] >>>  3) | (this.h[2] << 10)                    ) & 0xffff;
    this.h[2] = ((this.h[2] >>>  6) | (this.h[3] <<  7)                    ) & 0xffff;
    this.h[3] = ((this.h[3] >>>  9) | (this.h[4] <<  4)                    ) & 0xffff;
    this.h[4] = ((this.h[4] >>> 12) | (this.h[5] <<  1) | (this.h[6] << 14)) & 0xffff;
    this.h[5] = ((this.h[6] >>>  2) | (this.h[7] << 11)                    ) & 0xffff;
    this.h[6] = ((this.h[7] >>>  5) | (this.h[8] <<  8)                    ) & 0xffff;
    this.h[7] = ((this.h[8] >>>  8) | (this.h[9] <<  5)                    ) & 0xffff;
  
    f = this.h[0] + this.pad[0];
    this.h[0] = f & 0xffff;
    for (i = 1; i < 8; i++) {
      f = (((this.h[i] + this.pad[i]) | 0) + (f >>> 16)) | 0;
      this.h[i] = f & 0xffff;
    }
  
    mac[macpos+ 0] = (this.h[0] >>> 0) & 0xff;
    mac[macpos+ 1] = (this.h[0] >>> 8) & 0xff;
    mac[macpos+ 2] = (this.h[1] >>> 0) & 0xff;
    mac[macpos+ 3] = (this.h[1] >>> 8) & 0xff;
    mac[macpos+ 4] = (this.h[2] >>> 0) & 0xff;
    mac[macpos+ 5] = (this.h[2] >>> 8) & 0xff;
    mac[macpos+ 6] = (this.h[3] >>> 0) & 0xff;
    mac[macpos+ 7] = (this.h[3] >>> 8) & 0xff;
    mac[macpos+ 8] = (this.h[4] >>> 0) & 0xff;
    mac[macpos+ 9] = (this.h[4] >>> 8) & 0xff;
    mac[macpos+10] = (this.h[5] >>> 0) & 0xff;
    mac[macpos+11] = (this.h[5] >>> 8) & 0xff;
    mac[macpos+12] = (this.h[6] >>> 0) & 0xff;
    mac[macpos+13] = (this.h[6] >>> 8) & 0xff;
    mac[macpos+14] = (this.h[7] >>> 0) & 0xff;
    mac[macpos+15] = (this.h[7] >>> 8) & 0xff;
  };
  
  poly1305.prototype.update = function(m, mpos, bytes) {
    var i, want;
  
    if (this.leftover) {
      want = (16 - this.leftover);
      if (want > bytes)
        want = bytes;
      for (i = 0; i < want; i++)
        this.buffer[this.leftover + i] = m[mpos+i];
      bytes -= want;
      mpos += want;
      this.leftover += want;
      if (this.leftover < 16)
        return;
      this.blocks(this.buffer, 0, 16);
      this.leftover = 0;
    }
  
    if (bytes >= 16) {
      want = bytes - (bytes % 16);
      this.blocks(m, mpos, want);
      mpos += want;
      bytes -= want;
    }
  
    if (bytes) {
      for (i = 0; i < bytes; i++)
        this.buffer[this.leftover + i] = m[mpos+i];
      this.leftover += bytes;
    }
  };
  
  function crypto_onetimeauth(out, outpos, m, mpos, n, k) {
    var s = new poly1305(k);
    s.update(m, mpos, n);
    s.finish(out, outpos);
    return 0;
  }
  
  function crypto_onetimeauth_verify(h, hpos, m, mpos, n, k) {
    var x = new Uint8Array(16);
    crypto_onetimeauth(x,0,m,mpos,n,k);
    return crypto_verify_16(h,hpos,x,0);
  }
  
  function crypto_secretbox(c,m,d,n,k) {
    var i;
    if (d < 32) return -1;
    crypto_stream_xor(c,0,m,0,d,n,k);
    crypto_onetimeauth(c, 16, c, 32, d - 32, c);
    for (i = 0; i < 16; i++) c[i] = 0;
    return 0;
  }
  
  function crypto_secretbox_open(m,c,d,n,k) {
    var i;
    var x = new Uint8Array(32);
    if (d < 32) return -1;
    crypto_stream(x,0,32,n,k);
    if (crypto_onetimeauth_verify(c, 16,c, 32,d - 32,x) !== 0) return -1;
    crypto_stream_xor(m,0,c,0,d,n,k);
    for (i = 0; i < 32; i++) m[i] = 0;
    return 0;
  }
  
  function set25519(r, a) {
    var i;
    for (i = 0; i < 16; i++) r[i] = a[i]|0;
  }
  
  function car25519(o) {
    var i, v, c = 1;
    for (i = 0; i < 16; i++) {
      v = o[i] + c + 65535;
      c = Math.floor(v / 65536);
      o[i] = v - c * 65536;
    }
    o[0] += c-1 + 37 * (c-1);
  }
  
  function sel25519(p, q, b) {
    var t, c = ~(b-1);
    for (var i = 0; i < 16; i++) {
      t = c & (p[i] ^ q[i]);
      p[i] ^= t;
      q[i] ^= t;
    }
  }
  
  function pack25519(o, n) {
    var i, j, b;
    var m = gf(), t = gf();
    for (i = 0; i < 16; i++) t[i] = n[i];
    car25519(t);
    car25519(t);
    car25519(t);
    for (j = 0; j < 2; j++) {
      m[0] = t[0] - 0xffed;
      for (i = 1; i < 15; i++) {
        m[i] = t[i] - 0xffff - ((m[i-1]>>16) & 1);
        m[i-1] &= 0xffff;
      }
      m[15] = t[15] - 0x7fff - ((m[14]>>16) & 1);
      b = (m[15]>>16) & 1;
      m[14] &= 0xffff;
      sel25519(t, m, 1-b);
    }
    for (i = 0; i < 16; i++) {
      o[2*i] = t[i] & 0xff;
      o[2*i+1] = t[i]>>8;
    }
  }
  
  function neq25519(a, b) {
    var c = new Uint8Array(32), d = new Uint8Array(32);
    pack25519(c, a);
    pack25519(d, b);
    return crypto_verify_32(c, 0, d, 0);
  }
  
  function par25519(a) {
    var d = new Uint8Array(32);
    pack25519(d, a);
    return d[0] & 1;
  }
  
  function unpack25519(o, n) {
    var i;
    for (i = 0; i < 16; i++) o[i] = n[2*i] + (n[2*i+1] << 8);
    o[15] &= 0x7fff;
  }
  
  function A(o, a, b) {
    for (var i = 0; i < 16; i++) o[i] = a[i] + b[i];
  }
  
  function Z(o, a, b) {
    for (var i = 0; i < 16; i++) o[i] = a[i] - b[i];
  }
  
  function M(o, a, b) {
    var v, c,
       t0 = 0,  t1 = 0,  t2 = 0,  t3 = 0,  t4 = 0,  t5 = 0,  t6 = 0,  t7 = 0,
       t8 = 0,  t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0,
      t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0,
      t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0,
      b0 = b[0],
      b1 = b[1],
      b2 = b[2],
      b3 = b[3],
      b4 = b[4],
      b5 = b[5],
      b6 = b[6],
      b7 = b[7],
      b8 = b[8],
      b9 = b[9],
      b10 = b[10],
      b11 = b[11],
      b12 = b[12],
      b13 = b[13],
      b14 = b[14],
      b15 = b[15];
  
    v = a[0];
    t0 += v * b0;
    t1 += v * b1;
    t2 += v * b2;
    t3 += v * b3;
    t4 += v * b4;
    t5 += v * b5;
    t6 += v * b6;
    t7 += v * b7;
    t8 += v * b8;
    t9 += v * b9;
    t10 += v * b10;
    t11 += v * b11;
    t12 += v * b12;
    t13 += v * b13;
    t14 += v * b14;
    t15 += v * b15;
    v = a[1];
    t1 += v * b0;
    t2 += v * b1;
    t3 += v * b2;
    t4 += v * b3;
    t5 += v * b4;
    t6 += v * b5;
    t7 += v * b6;
    t8 += v * b7;
    t9 += v * b8;
    t10 += v * b9;
    t11 += v * b10;
    t12 += v * b11;
    t13 += v * b12;
    t14 += v * b13;
    t15 += v * b14;
    t16 += v * b15;
    v = a[2];
    t2 += v * b0;
    t3 += v * b1;
    t4 += v * b2;
    t5 += v * b3;
    t6 += v * b4;
    t7 += v * b5;
    t8 += v * b6;
    t9 += v * b7;
    t10 += v * b8;
    t11 += v * b9;
    t12 += v * b10;
    t13 += v * b11;
    t14 += v * b12;
    t15 += v * b13;
    t16 += v * b14;
    t17 += v * b15;
    v = a[3];
    t3 += v * b0;
    t4 += v * b1;
    t5 += v * b2;
    t6 += v * b3;
    t7 += v * b4;
    t8 += v * b5;
    t9 += v * b6;
    t10 += v * b7;
    t11 += v * b8;
    t12 += v * b9;
    t13 += v * b10;
    t14 += v * b11;
    t15 += v * b12;
    t16 += v * b13;
    t17 += v * b14;
    t18 += v * b15;
    v = a[4];
    t4 += v * b0;
    t5 += v * b1;
    t6 += v * b2;
    t7 += v * b3;
    t8 += v * b4;
    t9 += v * b5;
    t10 += v * b6;
    t11 += v * b7;
    t12 += v * b8;
    t13 += v * b9;
    t14 += v * b10;
    t15 += v * b11;
    t16 += v * b12;
    t17 += v * b13;
    t18 += v * b14;
    t19 += v * b15;
    v = a[5];
    t5 += v * b0;
    t6 += v * b1;
    t7 += v * b2;
    t8 += v * b3;
    t9 += v * b4;
    t10 += v * b5;
    t11 += v * b6;
    t12 += v * b7;
    t13 += v * b8;
    t14 += v * b9;
    t15 += v * b10;
    t16 += v * b11;
    t17 += v * b12;
    t18 += v * b13;
    t19 += v * b14;
    t20 += v * b15;
    v = a[6];
    t6 += v * b0;
    t7 += v * b1;
    t8 += v * b2;
    t9 += v * b3;
    t10 += v * b4;
    t11 += v * b5;
    t12 += v * b6;
    t13 += v * b7;
    t14 += v * b8;
    t15 += v * b9;
    t16 += v * b10;
    t17 += v * b11;
    t18 += v * b12;
    t19 += v * b13;
    t20 += v * b14;
    t21 += v * b15;
    v = a[7];
    t7 += v * b0;
    t8 += v * b1;
    t9 += v * b2;
    t10 += v * b3;
    t11 += v * b4;
    t12 += v * b5;
    t13 += v * b6;
    t14 += v * b7;
    t15 += v * b8;
    t16 += v * b9;
    t17 += v * b10;
    t18 += v * b11;
    t19 += v * b12;
    t20 += v * b13;
    t21 += v * b14;
    t22 += v * b15;
    v = a[8];
    t8 += v * b0;
    t9 += v * b1;
    t10 += v * b2;
    t11 += v * b3;
    t12 += v * b4;
    t13 += v * b5;
    t14 += v * b6;
    t15 += v * b7;
    t16 += v * b8;
    t17 += v * b9;
    t18 += v * b10;
    t19 += v * b11;
    t20 += v * b12;
    t21 += v * b13;
    t22 += v * b14;
    t23 += v * b15;
    v = a[9];
    t9 += v * b0;
    t10 += v * b1;
    t11 += v * b2;
    t12 += v * b3;
    t13 += v * b4;
    t14 += v * b5;
    t15 += v * b6;
    t16 += v * b7;
    t17 += v * b8;
    t18 += v * b9;
    t19 += v * b10;
    t20 += v * b11;
    t21 += v * b12;
    t22 += v * b13;
    t23 += v * b14;
    t24 += v * b15;
    v = a[10];
    t10 += v * b0;
    t11 += v * b1;
    t12 += v * b2;
    t13 += v * b3;
    t14 += v * b4;
    t15 += v * b5;
    t16 += v * b6;
    t17 += v * b7;
    t18 += v * b8;
    t19 += v * b9;
    t20 += v * b10;
    t21 += v * b11;
    t22 += v * b12;
    t23 += v * b13;
    t24 += v * b14;
    t25 += v * b15;
    v = a[11];
    t11 += v * b0;
    t12 += v * b1;
    t13 += v * b2;
    t14 += v * b3;
    t15 += v * b4;
    t16 += v * b5;
    t17 += v * b6;
    t18 += v * b7;
    t19 += v * b8;
    t20 += v * b9;
    t21 += v * b10;
    t22 += v * b11;
    t23 += v * b12;
    t24 += v * b13;
    t25 += v * b14;
    t26 += v * b15;
    v = a[12];
    t12 += v * b0;
    t13 += v * b1;
    t14 += v * b2;
    t15 += v * b3;
    t16 += v * b4;
    t17 += v * b5;
    t18 += v * b6;
    t19 += v * b7;
    t20 += v * b8;
    t21 += v * b9;
    t22 += v * b10;
    t23 += v * b11;
    t24 += v * b12;
    t25 += v * b13;
    t26 += v * b14;
    t27 += v * b15;
    v = a[13];
    t13 += v * b0;
    t14 += v * b1;
    t15 += v * b2;
    t16 += v * b3;
    t17 += v * b4;
    t18 += v * b5;
    t19 += v * b6;
    t20 += v * b7;
    t21 += v * b8;
    t22 += v * b9;
    t23 += v * b10;
    t24 += v * b11;
    t25 += v * b12;
    t26 += v * b13;
    t27 += v * b14;
    t28 += v * b15;
    v = a[14];
    t14 += v * b0;
    t15 += v * b1;
    t16 += v * b2;
    t17 += v * b3;
    t18 += v * b4;
    t19 += v * b5;
    t20 += v * b6;
    t21 += v * b7;
    t22 += v * b8;
    t23 += v * b9;
    t24 += v * b10;
    t25 += v * b11;
    t26 += v * b12;
    t27 += v * b13;
    t28 += v * b14;
    t29 += v * b15;
    v = a[15];
    t15 += v * b0;
    t16 += v * b1;
    t17 += v * b2;
    t18 += v * b3;
    t19 += v * b4;
    t20 += v * b5;
    t21 += v * b6;
    t22 += v * b7;
    t23 += v * b8;
    t24 += v * b9;
    t25 += v * b10;
    t26 += v * b11;
    t27 += v * b12;
    t28 += v * b13;
    t29 += v * b14;
    t30 += v * b15;
  
    t0  += 38 * t16;
    t1  += 38 * t17;
    t2  += 38 * t18;
    t3  += 38 * t19;
    t4  += 38 * t20;
    t5  += 38 * t21;
    t6  += 38 * t22;
    t7  += 38 * t23;
    t8  += 38 * t24;
    t9  += 38 * t25;
    t10 += 38 * t26;
    t11 += 38 * t27;
    t12 += 38 * t28;
    t13 += 38 * t29;
    t14 += 38 * t30;
    // t15 left as is
  
    // first car
    c = 1;
    v =  t0 + c + 65535; c = Math.floor(v / 65536);  t0 = v - c * 65536;
    v =  t1 + c + 65535; c = Math.floor(v / 65536);  t1 = v - c * 65536;
    v =  t2 + c + 65535; c = Math.floor(v / 65536);  t2 = v - c * 65536;
    v =  t3 + c + 65535; c = Math.floor(v / 65536);  t3 = v - c * 65536;
    v =  t4 + c + 65535; c = Math.floor(v / 65536);  t4 = v - c * 65536;
    v =  t5 + c + 65535; c = Math.floor(v / 65536);  t5 = v - c * 65536;
    v =  t6 + c + 65535; c = Math.floor(v / 65536);  t6 = v - c * 65536;
    v =  t7 + c + 65535; c = Math.floor(v / 65536);  t7 = v - c * 65536;
    v =  t8 + c + 65535; c = Math.floor(v / 65536);  t8 = v - c * 65536;
    v =  t9 + c + 65535; c = Math.floor(v / 65536);  t9 = v - c * 65536;
    v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536;
    v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536;
    v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536;
    v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536;
    v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536;
    v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536;
    t0 += c-1 + 37 * (c-1);
  
    // second car
    c = 1;
    v =  t0 + c + 65535; c = Math.floor(v / 65536);  t0 = v - c * 65536;
    v =  t1 + c + 65535; c = Math.floor(v / 65536);  t1 = v - c * 65536;
    v =  t2 + c + 65535; c = Math.floor(v / 65536);  t2 = v - c * 65536;
    v =  t3 + c + 65535; c = Math.floor(v / 65536);  t3 = v - c * 65536;
    v =  t4 + c + 65535; c = Math.floor(v / 65536);  t4 = v - c * 65536;
    v =  t5 + c + 65535; c = Math.floor(v / 65536);  t5 = v - c * 65536;
    v =  t6 + c + 65535; c = Math.floor(v / 65536);  t6 = v - c * 65536;
    v =  t7 + c + 65535; c = Math.floor(v / 65536);  t7 = v - c * 65536;
    v =  t8 + c + 65535; c = Math.floor(v / 65536);  t8 = v - c * 65536;
    v =  t9 + c + 65535; c = Math.floor(v / 65536);  t9 = v - c * 65536;
    v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536;
    v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536;
    v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536;
    v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536;
    v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536;
    v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536;
    t0 += c-1 + 37 * (c-1);
  
    o[ 0] = t0;
    o[ 1] = t1;
    o[ 2] = t2;
    o[ 3] = t3;
    o[ 4] = t4;
    o[ 5] = t5;
    o[ 6] = t6;
    o[ 7] = t7;
    o[ 8] = t8;
    o[ 9] = t9;
    o[10] = t10;
    o[11] = t11;
    o[12] = t12;
    o[13] = t13;
    o[14] = t14;
    o[15] = t15;
  }
  
  function S(o, a) {
    M(o, a, a);
  }
  
  function inv25519(o, i) {
    var c = gf();
    var a;
    for (a = 0; a < 16; a++) c[a] = i[a];
    for (a = 253; a >= 0; a--) {
      S(c, c);
      if(a !== 2 && a !== 4) M(c, c, i);
    }
    for (a = 0; a < 16; a++) o[a] = c[a];
  }
  
  function pow2523(o, i) {
    var c = gf();
    var a;
    for (a = 0; a < 16; a++) c[a] = i[a];
    for (a = 250; a >= 0; a--) {
        S(c, c);
        if(a !== 1) M(c, c, i);
    }
    for (a = 0; a < 16; a++) o[a] = c[a];
  }
  
  function crypto_scalarmult(q, n, p) {
    var z = new Uint8Array(32);
    var x = new Float64Array(80), r, i;
    var a = gf(), b = gf(), c = gf(),
        d = gf(), e = gf(), f = gf();
    for (i = 0; i < 31; i++) z[i] = n[i];
    z[31]=(n[31]&127)|64;
    z[0]&=248;
    unpack25519(x,p);
    for (i = 0; i < 16; i++) {
      b[i]=x[i];
      d[i]=a[i]=c[i]=0;
    }
    a[0]=d[0]=1;
    for (i=254; i>=0; --i) {
      r=(z[i>>>3]>>>(i&7))&1;
      sel25519(a,b,r);
      sel25519(c,d,r);
      A(e,a,c);
      Z(a,a,c);
      A(c,b,d);
      Z(b,b,d);
      S(d,e);
      S(f,a);
      M(a,c,a);
      M(c,b,e);
      A(e,a,c);
      Z(a,a,c);
      S(b,a);
      Z(c,d,f);
      M(a,c,_121665);
      A(a,a,d);
      M(c,c,a);
      M(a,d,f);
      M(d,b,x);
      S(b,e);
      sel25519(a,b,r);
      sel25519(c,d,r);
    }
    for (i = 0; i < 16; i++) {
      x[i+16]=a[i];
      x[i+32]=c[i];
      x[i+48]=b[i];
      x[i+64]=d[i];
    }
    var x32 = x.subarray(32);
    var x16 = x.subarray(16);
    inv25519(x32,x32);
    M(x16,x16,x32);
    pack25519(q,x16);
    return 0;
  }
  
  function crypto_scalarmult_base(q, n) {
    return crypto_scalarmult(q, n, _9);
  }
  
  function crypto_box_keypair(y, x) {
    randombytes(x, 32);
    return crypto_scalarmult_base(y, x);
  }
  
  function crypto_box_beforenm(k, y, x) {
    var s = new Uint8Array(32);
    crypto_scalarmult(s, x, y);
    return crypto_core_hsalsa20(k, _0, s, sigma);
  }
  
  var crypto_box_afternm = crypto_secretbox;
  var crypto_box_open_afternm = crypto_secretbox_open;
  
  function crypto_box(c, m, d, n, y, x) {
    var k = new Uint8Array(32);
    crypto_box_beforenm(k, y, x);
    return crypto_box_afternm(c, m, d, n, k);
  }
  
  function crypto_box_open(m, c, d, n, y, x) {
    var k = new Uint8Array(32);
    crypto_box_beforenm(k, y, x);
    return crypto_box_open_afternm(m, c, d, n, k);
  }
  
  var K = [
    0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
    0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
    0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
    0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
    0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
    0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
    0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
    0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
    0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
    0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
    0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
    0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
    0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
    0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
    0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
    0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
    0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
    0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
    0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
    0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
    0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
    0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
    0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
    0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
    0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
    0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
    0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
    0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
    0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
    0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
    0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
    0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
    0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
    0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
    0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
    0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
    0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
    0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
    0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
    0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817
  ];
  
  function crypto_hashblocks_hl(hh, hl, m, n) {
    var wh = new Int32Array(16), wl = new Int32Array(16),
        bh0, bh1, bh2, bh3, bh4, bh5, bh6, bh7,
        bl0, bl1, bl2, bl3, bl4, bl5, bl6, bl7,
        th, tl, i, j, h, l, a, b, c, d;
  
    var ah0 = hh[0],
        ah1 = hh[1],
        ah2 = hh[2],
        ah3 = hh[3],
        ah4 = hh[4],
        ah5 = hh[5],
        ah6 = hh[6],
        ah7 = hh[7],
  
        al0 = hl[0],
        al1 = hl[1],
        al2 = hl[2],
        al3 = hl[3],
        al4 = hl[4],
        al5 = hl[5],
        al6 = hl[6],
        al7 = hl[7];
  
    var pos = 0;
    while (n >= 128) {
      for (i = 0; i < 16; i++) {
        j = 8 * i + pos;
        wh[i] = (m[j+0] << 24) | (m[j+1] << 16) | (m[j+2] << 8) | m[j+3];
        wl[i] = (m[j+4] << 24) | (m[j+5] << 16) | (m[j+6] << 8) | m[j+7];
      }
      for (i = 0; i < 80; i++) {
        bh0 = ah0;
        bh1 = ah1;
        bh2 = ah2;
        bh3 = ah3;
        bh4 = ah4;
        bh5 = ah5;
        bh6 = ah6;
        bh7 = ah7;
  
        bl0 = al0;
        bl1 = al1;
        bl2 = al2;
        bl3 = al3;
        bl4 = al4;
        bl5 = al5;
        bl6 = al6;
        bl7 = al7;
  
        // add
        h = ah7;
        l = al7;
  
        a = l & 0xffff; b = l >>> 16;
        c = h & 0xffff; d = h >>> 16;
  
        // Sigma1
        h = ((ah4 >>> 14) | (al4 << (32-14))) ^ ((ah4 >>> 18) | (al4 << (32-18))) ^ ((al4 >>> (41-32)) | (ah4 << (32-(41-32))));
        l = ((al4 >>> 14) | (ah4 << (32-14))) ^ ((al4 >>> 18) | (ah4 << (32-18))) ^ ((ah4 >>> (41-32)) | (al4 << (32-(41-32))));
  
        a += l & 0xffff; b += l >>> 16;
        c += h & 0xffff; d += h >>> 16;
  
        // Ch
        h = (ah4 & ah5) ^ (~ah4 & ah6);
        l = (al4 & al5) ^ (~al4 & al6);
  
        a += l & 0xffff; b += l >>> 16;
        c += h & 0xffff; d += h >>> 16;
  
        // K
        h = K[i*2];
        l = K[i*2+1];
  
        a += l & 0xffff; b += l >>> 16;
        c += h & 0xffff; d += h >>> 16;
  
        // w
        h = wh[i%16];
        l = wl[i%16];
  
        a += l & 0xffff; b += l >>> 16;
        c += h & 0xffff; d += h >>> 16;
  
        b += a >>> 16;
        c += b >>> 16;
        d += c >>> 16;
  
        th = c & 0xffff | d << 16;
        tl = a & 0xffff | b << 16;
  
        // add
        h = th;
        l = tl;
  
        a = l & 0xffff; b = l >>> 16;
        c = h & 0xffff; d = h >>> 16;
  
        // Sigma0
        h = ((ah0 >>> 28) | (al0 << (32-28))) ^ ((al0 >>> (34-32)) | (ah0 << (32-(34-32)))) ^ ((al0 >>> (39-32)) | (ah0 << (32-(39-32))));
        l = ((al0 >>> 28) | (ah0 << (32-28))) ^ ((ah0 >>> (34-32)) | (al0 << (32-(34-32)))) ^ ((ah0 >>> (39-32)) | (al0 << (32-(39-32))));
  
        a += l & 0xffff; b += l >>> 16;
        c += h & 0xffff; d += h >>> 16;
  
        // Maj
        h = (ah0 & ah1) ^ (ah0 & ah2) ^ (ah1 & ah2);
        l = (al0 & al1) ^ (al0 & al2) ^ (al1 & al2);
  
        a += l & 0xffff; b += l >>> 16;
        c += h & 0xffff; d += h >>> 16;
  
        b += a >>> 16;
        c += b >>> 16;
        d += c >>> 16;
  
        bh7 = (c & 0xffff) | (d << 16);
        bl7 = (a & 0xffff) | (b << 16);
  
        // add
        h = bh3;
        l = bl3;
  
        a = l & 0xffff; b = l >>> 16;
        c = h & 0xffff; d = h >>> 16;
  
        h = th;
        l = tl;
  
        a += l & 0xffff; b += l >>> 16;
        c += h & 0xffff; d += h >>> 16;
  
        b += a >>> 16;
        c += b >>> 16;
        d += c >>> 16;
  
        bh3 = (c & 0xffff) | (d << 16);
        bl3 = (a & 0xffff) | (b << 16);
  
        ah1 = bh0;
        ah2 = bh1;
        ah3 = bh2;
        ah4 = bh3;
        ah5 = bh4;
        ah6 = bh5;
        ah7 = bh6;
        ah0 = bh7;
  
        al1 = bl0;
        al2 = bl1;
        al3 = bl2;
        al4 = bl3;
        al5 = bl4;
        al6 = bl5;
        al7 = bl6;
        al0 = bl7;
  
        if (i%16 === 15) {
          for (j = 0; j < 16; j++) {
            // add
            h = wh[j];
            l = wl[j];
  
            a = l & 0xffff; b = l >>> 16;
            c = h & 0xffff; d = h >>> 16;
  
            h = wh[(j+9)%16];
            l = wl[(j+9)%16];
  
            a += l & 0xffff; b += l >>> 16;
            c += h & 0xffff; d += h >>> 16;
  
            // sigma0
            th = wh[(j+1)%16];
            tl = wl[(j+1)%16];
            h = ((th >>> 1) | (tl << (32-1))) ^ ((th >>> 8) | (tl << (32-8))) ^ (th >>> 7);
            l = ((tl >>> 1) | (th << (32-1))) ^ ((tl >>> 8) | (th << (32-8))) ^ ((tl >>> 7) | (th << (32-7)));
  
            a += l & 0xffff; b += l >>> 16;
            c += h & 0xffff; d += h >>> 16;
  
            // sigma1
            th = wh[(j+14)%16];
            tl = wl[(j+14)%16];
            h = ((th >>> 19) | (tl << (32-19))) ^ ((tl >>> (61-32)) | (th << (32-(61-32)))) ^ (th >>> 6);
            l = ((tl >>> 19) | (th << (32-19))) ^ ((th >>> (61-32)) | (tl << (32-(61-32)))) ^ ((tl >>> 6) | (th << (32-6)));
  
            a += l & 0xffff; b += l >>> 16;
            c += h & 0xffff; d += h >>> 16;
  
            b += a >>> 16;
            c += b >>> 16;
            d += c >>> 16;
  
            wh[j] = (c & 0xffff) | (d << 16);
            wl[j] = (a & 0xffff) | (b << 16);
          }
        }
      }
  
      // add
      h = ah0;
      l = al0;
  
      a = l & 0xffff; b = l >>> 16;
      c = h & 0xffff; d = h >>> 16;
  
      h = hh[0];
      l = hl[0];
  
      a += l & 0xffff; b += l >>> 16;
      c += h & 0xffff; d += h >>> 16;
  
      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;
  
      hh[0] = ah0 = (c & 0xffff) | (d << 16);
      hl[0] = al0 = (a & 0xffff) | (b << 16);
  
      h = ah1;
      l = al1;
  
      a = l & 0xffff; b = l >>> 16;
      c = h & 0xffff; d = h >>> 16;
  
      h = hh[1];
      l = hl[1];
  
      a += l & 0xffff; b += l >>> 16;
      c += h & 0xffff; d += h >>> 16;
  
      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;
  
      hh[1] = ah1 = (c & 0xffff) | (d << 16);
      hl[1] = al1 = (a & 0xffff) | (b << 16);
  
      h = ah2;
      l = al2;
  
      a = l & 0xffff; b = l >>> 16;
      c = h & 0xffff; d = h >>> 16;
  
      h = hh[2];
      l = hl[2];
  
      a += l & 0xffff; b += l >>> 16;
      c += h & 0xffff; d += h >>> 16;
  
      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;
  
      hh[2] = ah2 = (c & 0xffff) | (d << 16);
      hl[2] = al2 = (a & 0xffff) | (b << 16);
  
      h = ah3;
      l = al3;
  
      a = l & 0xffff; b = l >>> 16;
      c = h & 0xffff; d = h >>> 16;
  
      h = hh[3];
      l = hl[3];
  
      a += l & 0xffff; b += l >>> 16;
      c += h & 0xffff; d += h >>> 16;
  
      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;
  
      hh[3] = ah3 = (c & 0xffff) | (d << 16);
      hl[3] = al3 = (a & 0xffff) | (b << 16);
  
      h = ah4;
      l = al4;
  
      a = l & 0xffff; b = l >>> 16;
      c = h & 0xffff; d = h >>> 16;
  
      h = hh[4];
      l = hl[4];
  
      a += l & 0xffff; b += l >>> 16;
      c += h & 0xffff; d += h >>> 16;
  
      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;
  
      hh[4] = ah4 = (c & 0xffff) | (d << 16);
      hl[4] = al4 = (a & 0xffff) | (b << 16);
  
      h = ah5;
      l = al5;
  
      a = l & 0xffff; b = l >>> 16;
      c = h & 0xffff; d = h >>> 16;
  
      h = hh[5];
      l = hl[5];
  
      a += l & 0xffff; b += l >>> 16;
      c += h & 0xffff; d += h >>> 16;
  
      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;
  
      hh[5] = ah5 = (c & 0xffff) | (d << 16);
      hl[5] = al5 = (a & 0xffff) | (b << 16);
  
      h = ah6;
      l = al6;
  
      a = l & 0xffff; b = l >>> 16;
      c = h & 0xffff; d = h >>> 16;
  
      h = hh[6];
      l = hl[6];
  
      a += l & 0xffff; b += l >>> 16;
      c += h & 0xffff; d += h >>> 16;
  
      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;
  
      hh[6] = ah6 = (c & 0xffff) | (d << 16);
      hl[6] = al6 = (a & 0xffff) | (b << 16);
  
      h = ah7;
      l = al7;
  
      a = l & 0xffff; b = l >>> 16;
      c = h & 0xffff; d = h >>> 16;
  
      h = hh[7];
      l = hl[7];
  
      a += l & 0xffff; b += l >>> 16;
      c += h & 0xffff; d += h >>> 16;
  
      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;
  
      hh[7] = ah7 = (c & 0xffff) | (d << 16);
      hl[7] = al7 = (a & 0xffff) | (b << 16);
  
      pos += 128;
      n -= 128;
    }
  
    return n;
  }
  
  function crypto_hash(out, m, n) {
    var hh = new Int32Array(8),
        hl = new Int32Array(8),
        x = new Uint8Array(256),
        i, b = n;
  
    hh[0] = 0x6a09e667;
    hh[1] = 0xbb67ae85;
    hh[2] = 0x3c6ef372;
    hh[3] = 0xa54ff53a;
    hh[4] = 0x510e527f;
    hh[5] = 0x9b05688c;
    hh[6] = 0x1f83d9ab;
    hh[7] = 0x5be0cd19;
  
    hl[0] = 0xf3bcc908;
    hl[1] = 0x84caa73b;
    hl[2] = 0xfe94f82b;
    hl[3] = 0x5f1d36f1;
    hl[4] = 0xade682d1;
    hl[5] = 0x2b3e6c1f;
    hl[6] = 0xfb41bd6b;
    hl[7] = 0x137e2179;
  
    crypto_hashblocks_hl(hh, hl, m, n);
    n %= 128;
  
    for (i = 0; i < n; i++) x[i] = m[b-n+i];
    x[n] = 128;
  
    n = 256-128*(n<112?1:0);
    x[n-9] = 0;
    ts64(x, n-8,  (b / 0x20000000) | 0, b << 3);
    crypto_hashblocks_hl(hh, hl, x, n);
  
    for (i = 0; i < 8; i++) ts64(out, 8*i, hh[i], hl[i]);
  
    return 0;
  }
  
  function add(p, q) {
    var a = gf(), b = gf(), c = gf(),
        d = gf(), e = gf(), f = gf(),
        g = gf(), h = gf(), t = gf();
  
    Z(a, p[1], p[0]);
    Z(t, q[1], q[0]);
    M(a, a, t);
    A(b, p[0], p[1]);
    A(t, q[0], q[1]);
    M(b, b, t);
    M(c, p[3], q[3]);
    M(c, c, D2);
    M(d, p[2], q[2]);
    A(d, d, d);
    Z(e, b, a);
    Z(f, d, c);
    A(g, d, c);
    A(h, b, a);
  
    M(p[0], e, f);
    M(p[1], h, g);
    M(p[2], g, f);
    M(p[3], e, h);
  }
  
  function cswap(p, q, b) {
    var i;
    for (i = 0; i < 4; i++) {
      sel25519(p[i], q[i], b);
    }
  }
  
  function pack(r, p) {
    var tx = gf(), ty = gf(), zi = gf();
    inv25519(zi, p[2]);
    M(tx, p[0], zi);
    M(ty, p[1], zi);
    pack25519(r, ty);
    r[31] ^= par25519(tx) << 7;
  }
  
  function scalarmult(p, q, s) {
    var b, i;
    set25519(p[0], gf0);
    set25519(p[1], gf1);
    set25519(p[2], gf1);
    set25519(p[3], gf0);
    for (i = 255; i >= 0; --i) {
      b = (s[(i/8)|0] >> (i&7)) & 1;
      cswap(p, q, b);
      add(q, p);
      add(p, p);
      cswap(p, q, b);
    }
  }
  
  function scalarbase(p, s) {
    var q = [gf(), gf(), gf(), gf()];
    set25519(q[0], X);
    set25519(q[1], Y);
    set25519(q[2], gf1);
    M(q[3], X, Y);
    scalarmult(p, q, s);
  }
  
  function crypto_sign_keypair(pk, sk, seeded) {
    var d = new Uint8Array(64);
    var p = [gf(), gf(), gf(), gf()];
    var i;
  
    if (!seeded) randombytes(sk, 32);
    crypto_hash(d, sk, 32);
    d[0] &= 248;
    d[31] &= 127;
    d[31] |= 64;
  
    scalarbase(p, d);
    pack(pk, p);
  
    for (i = 0; i < 32; i++) sk[i+32] = pk[i];
    return 0;
  }
  
  var L = new Float64Array([0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x10]);
  
  function modL(r, x) {
    var carry, i, j, k;
    for (i = 63; i >= 32; --i) {
      carry = 0;
      for (j = i - 32, k = i - 12; j < k; ++j) {
        x[j] += carry - 16 * x[i] * L[j - (i - 32)];
        carry = Math.floor((x[j] + 128) / 256);
        x[j] -= carry * 256;
      }
      x[j] += carry;
      x[i] = 0;
    }
    carry = 0;
    for (j = 0; j < 32; j++) {
      x[j] += carry - (x[31] >> 4) * L[j];
      carry = x[j] >> 8;
      x[j] &= 255;
    }
    for (j = 0; j < 32; j++) x[j] -= carry * L[j];
    for (i = 0; i < 32; i++) {
      x[i+1] += x[i] >> 8;
      r[i] = x[i] & 255;
    }
  }
  
  function reduce(r) {
    var x = new Float64Array(64), i;
    for (i = 0; i < 64; i++) x[i] = r[i];
    for (i = 0; i < 64; i++) r[i] = 0;
    modL(r, x);
  }
  
  // Note: difference from C - smlen returned, not passed as argument.
  function crypto_sign(sm, m, n, sk) {
    var d = new Uint8Array(64), h = new Uint8Array(64), r = new Uint8Array(64);
    var i, j, x = new Float64Array(64);
    var p = [gf(), gf(), gf(), gf()];
  
    crypto_hash(d, sk, 32);
    d[0] &= 248;
    d[31] &= 127;
    d[31] |= 64;
  
    var smlen = n + 64;
    for (i = 0; i < n; i++) sm[64 + i] = m[i];
    for (i = 0; i < 32; i++) sm[32 + i] = d[32 + i];
  
    crypto_hash(r, sm.subarray(32), n+32);
    reduce(r);
    scalarbase(p, r);
    pack(sm, p);
  
    for (i = 32; i < 64; i++) sm[i] = sk[i];
    crypto_hash(h, sm, n + 64);
    reduce(h);
  
    for (i = 0; i < 64; i++) x[i] = 0;
    for (i = 0; i < 32; i++) x[i] = r[i];
    for (i = 0; i < 32; i++) {
      for (j = 0; j < 32; j++) {
        x[i+j] += h[i] * d[j];
      }
    }
  
    modL(sm.subarray(32), x);
    return smlen;
  }
  
  function unpackneg(r, p) {
    var t = gf(), chk = gf(), num = gf(),
        den = gf(), den2 = gf(), den4 = gf(),
        den6 = gf();
  
    set25519(r[2], gf1);
    unpack25519(r[1], p);
    S(num, r[1]);
    M(den, num, D);
    Z(num, num, r[2]);
    A(den, r[2], den);
  
    S(den2, den);
    S(den4, den2);
    M(den6, den4, den2);
    M(t, den6, num);
    M(t, t, den);
  
    pow2523(t, t);
    M(t, t, num);
    M(t, t, den);
    M(t, t, den);
    M(r[0], t, den);
  
    S(chk, r[0]);
    M(chk, chk, den);
    if (neq25519(chk, num)) M(r[0], r[0], I);
  
    S(chk, r[0]);
    M(chk, chk, den);
    if (neq25519(chk, num)) return -1;
  
    if (par25519(r[0]) === (p[31]>>7)) Z(r[0], gf0, r[0]);
  
    M(r[3], r[0], r[1]);
    return 0;
  }
  
  function crypto_sign_open(m, sm, n, pk) {
    var i;
    var t = new Uint8Array(32), h = new Uint8Array(64);
    var p = [gf(), gf(), gf(), gf()],
        q = [gf(), gf(), gf(), gf()];
  
    if (n < 64) return -1;
  
    if (unpackneg(q, pk)) return -1;
  
    for (i = 0; i < n; i++) m[i] = sm[i];
    for (i = 0; i < 32; i++) m[i+32] = pk[i];
    crypto_hash(h, m, n);
    reduce(h);
    scalarmult(p, q, h);
  
    scalarbase(q, sm.subarray(32));
    add(p, q);
    pack(t, p);
  
    n -= 64;
    if (crypto_verify_32(sm, 0, t, 0)) {
      for (i = 0; i < n; i++) m[i] = 0;
      return -1;
    }
  
    for (i = 0; i < n; i++) m[i] = sm[i + 64];
    return n;
  }
  
  var crypto_secretbox_KEYBYTES = 32,
      crypto_secretbox_NONCEBYTES = 24,
      crypto_secretbox_ZEROBYTES = 32,
      crypto_secretbox_BOXZEROBYTES = 16,
      crypto_scalarmult_BYTES = 32,
      crypto_scalarmult_SCALARBYTES = 32,
      crypto_box_PUBLICKEYBYTES = 32,
      crypto_box_SECRETKEYBYTES = 32,
      crypto_box_BEFORENMBYTES = 32,
      crypto_box_NONCEBYTES = crypto_secretbox_NONCEBYTES,
      crypto_box_ZEROBYTES = crypto_secretbox_ZEROBYTES,
      crypto_box_BOXZEROBYTES = crypto_secretbox_BOXZEROBYTES,
      crypto_sign_BYTES = 64,
      crypto_sign_PUBLICKEYBYTES = 32,
      crypto_sign_SECRETKEYBYTES = 64,
      crypto_sign_SEEDBYTES = 32,
      crypto_hash_BYTES = 64;
  
  nacl.lowlevel = {
    crypto_core_hsalsa20: crypto_core_hsalsa20,
    crypto_stream_xor: crypto_stream_xor,
    crypto_stream: crypto_stream,
    crypto_stream_salsa20_xor: crypto_stream_salsa20_xor,
    crypto_stream_salsa20: crypto_stream_salsa20,
    crypto_onetimeauth: crypto_onetimeauth,
    crypto_onetimeauth_verify: crypto_onetimeauth_verify,
    crypto_verify_16: crypto_verify_16,
    crypto_verify_32: crypto_verify_32,
    crypto_secretbox: crypto_secretbox,
    crypto_secretbox_open: crypto_secretbox_open,
    crypto_scalarmult: crypto_scalarmult,
    crypto_scalarmult_base: crypto_scalarmult_base,
    crypto_box_beforenm: crypto_box_beforenm,
    crypto_box_afternm: crypto_box_afternm,
    crypto_box: crypto_box,
    crypto_box_open: crypto_box_open,
    crypto_box_keypair: crypto_box_keypair,
    crypto_hash: crypto_hash,
    crypto_sign: crypto_sign,
    crypto_sign_keypair: crypto_sign_keypair,
    crypto_sign_open: crypto_sign_open,
  
    crypto_secretbox_KEYBYTES: crypto_secretbox_KEYBYTES,
    crypto_secretbox_NONCEBYTES: crypto_secretbox_NONCEBYTES,
    crypto_secretbox_ZEROBYTES: crypto_secretbox_ZEROBYTES,
    crypto_secretbox_BOXZEROBYTES: crypto_secretbox_BOXZEROBYTES,
    crypto_scalarmult_BYTES: crypto_scalarmult_BYTES,
    crypto_scalarmult_SCALARBYTES: crypto_scalarmult_SCALARBYTES,
    crypto_box_PUBLICKEYBYTES: crypto_box_PUBLICKEYBYTES,
    crypto_box_SECRETKEYBYTES: crypto_box_SECRETKEYBYTES,
    crypto_box_BEFORENMBYTES: crypto_box_BEFORENMBYTES,
    crypto_box_NONCEBYTES: crypto_box_NONCEBYTES,
    crypto_box_ZEROBYTES: crypto_box_ZEROBYTES,
    crypto_box_BOXZEROBYTES: crypto_box_BOXZEROBYTES,
    crypto_sign_BYTES: crypto_sign_BYTES,
    crypto_sign_PUBLICKEYBYTES: crypto_sign_PUBLICKEYBYTES,
    crypto_sign_SECRETKEYBYTES: crypto_sign_SECRETKEYBYTES,
    crypto_sign_SEEDBYTES: crypto_sign_SEEDBYTES,
    crypto_hash_BYTES: crypto_hash_BYTES,
  
    gf: gf,
    D: D,
    L: L,
    pack25519: pack25519,
    unpack25519: unpack25519,
    M: M,
    A: A,
    S: S,
    Z: Z,
    pow2523: pow2523,
    add: add,
    set25519: set25519,
    modL: modL,
    scalarmult: scalarmult,
    scalarbase: scalarbase,
  };
  
  /* High-level API */
  
  function checkLengths(k, n) {
    if (k.length !== crypto_secretbox_KEYBYTES) throw new Error('bad key size');
    if (n.length !== crypto_secretbox_NONCEBYTES) throw new Error('bad nonce size');
  }
  
  function checkBoxLengths(pk, sk) {
    if (pk.length !== crypto_box_PUBLICKEYBYTES) throw new Error('bad public key size');
    if (sk.length !== crypto_box_SECRETKEYBYTES) throw new Error('bad secret key size');
  }
  
  function checkArrayTypes() {
    for (var i = 0; i < arguments.length; i++) {
      if (!(arguments[i] instanceof Uint8Array))
        throw new TypeError('unexpected type, use Uint8Array');
    }
  }
  
  function cleanup(arr) {
    for (var i = 0; i < arr.length; i++) arr[i] = 0;
  }
  
  nacl.randomBytes = function(n) {
    var b = new Uint8Array(n);
    randombytes(b, n);
    return b;
  };
  
  nacl.secretbox = function(msg, nonce, key) {
    checkArrayTypes(msg, nonce, key);
    checkLengths(key, nonce);
    var m = new Uint8Array(crypto_secretbox_ZEROBYTES + msg.length);
    var c = new Uint8Array(m.length);
    for (var i = 0; i < msg.length; i++) m[i+crypto_secretbox_ZEROBYTES] = msg[i];
    crypto_secretbox(c, m, m.length, nonce, key);
    return c.subarray(crypto_secretbox_BOXZEROBYTES);
  };
  
  nacl.secretbox.open = function(box, nonce, key) {
    checkArrayTypes(box, nonce, key);
    checkLengths(key, nonce);
    var c = new Uint8Array(crypto_secretbox_BOXZEROBYTES + box.length);
    var m = new Uint8Array(c.length);
    for (var i = 0; i < box.length; i++) c[i+crypto_secretbox_BOXZEROBYTES] = box[i];
    if (c.length < 32) return null;
    if (crypto_secretbox_open(m, c, c.length, nonce, key) !== 0) return null;
    return m.subarray(crypto_secretbox_ZEROBYTES);
  };
  
  nacl.secretbox.keyLength = crypto_secretbox_KEYBYTES;
  nacl.secretbox.nonceLength = crypto_secretbox_NONCEBYTES;
  nacl.secretbox.overheadLength = crypto_secretbox_BOXZEROBYTES;
  
  nacl.scalarMult = function(n, p) {
    checkArrayTypes(n, p);
    if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error('bad n size');
    if (p.length !== crypto_scalarmult_BYTES) throw new Error('bad p size');
    var q = new Uint8Array(crypto_scalarmult_BYTES);
    crypto_scalarmult(q, n, p);
    return q;
  };
  
  nacl.scalarMult.base = function(n) {
    checkArrayTypes(n);
    if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error('bad n size');
    var q = new Uint8Array(crypto_scalarmult_BYTES);
    crypto_scalarmult_base(q, n);
    return q;
  };
  
  nacl.scalarMult.scalarLength = crypto_scalarmult_SCALARBYTES;
  nacl.scalarMult.groupElementLength = crypto_scalarmult_BYTES;
  
  nacl.box = function(msg, nonce, publicKey, secretKey) {
    var k = nacl.box.before(publicKey, secretKey);
    return nacl.secretbox(msg, nonce, k);
  };
  
  nacl.box.before = function(publicKey, secretKey) {
    checkArrayTypes(publicKey, secretKey);
    checkBoxLengths(publicKey, secretKey);
    var k = new Uint8Array(crypto_box_BEFORENMBYTES);
    crypto_box_beforenm(k, publicKey, secretKey);
    return k;
  };
  
  nacl.box.after = nacl.secretbox;
  
  nacl.box.open = function(msg, nonce, publicKey, secretKey) {
    var k = nacl.box.before(publicKey, secretKey);
    return nacl.secretbox.open(msg, nonce, k);
  };
  
  nacl.box.open.after = nacl.secretbox.open;
  
  nacl.box.keyPair = function() {
    var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);
    var sk = new Uint8Array(crypto_box_SECRETKEYBYTES);
    crypto_box_keypair(pk, sk);
    return {publicKey: pk, secretKey: sk};
  };
  
  nacl.box.keyPair.fromSecretKey = function(secretKey) {
    checkArrayTypes(secretKey);
    if (secretKey.length !== crypto_box_SECRETKEYBYTES)
      throw new Error('bad secret key size');
    var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);
    crypto_scalarmult_base(pk, secretKey);
    return {publicKey: pk, secretKey: new Uint8Array(secretKey)};
  };
  
  nacl.box.publicKeyLength = crypto_box_PUBLICKEYBYTES;
  nacl.box.secretKeyLength = crypto_box_SECRETKEYBYTES;
  nacl.box.sharedKeyLength = crypto_box_BEFORENMBYTES;
  nacl.box.nonceLength = crypto_box_NONCEBYTES;
  nacl.box.overheadLength = nacl.secretbox.overheadLength;
  
  nacl.sign = function(msg, secretKey) {
    checkArrayTypes(msg, secretKey);
    if (secretKey.length !== crypto_sign_SECRETKEYBYTES)
      throw new Error('bad secret key size');
    var signedMsg = new Uint8Array(crypto_sign_BYTES+msg.length);
    crypto_sign(signedMsg, msg, msg.length, secretKey);
    return signedMsg;
  };
  
  nacl.sign.open = function(signedMsg, publicKey) {
    checkArrayTypes(signedMsg, publicKey);
    if (publicKey.length !== crypto_sign_PUBLICKEYBYTES)
      throw new Error('bad public key size');
    var tmp = new Uint8Array(signedMsg.length);
    var mlen = crypto_sign_open(tmp, signedMsg, signedMsg.length, publicKey);
    if (mlen < 0) return null;
    var m = new Uint8Array(mlen);
    for (var i = 0; i < m.length; i++) m[i] = tmp[i];
    return m;
  };
  
  nacl.sign.detached = function(msg, secretKey) {
    var signedMsg = nacl.sign(msg, secretKey);
    var sig = new Uint8Array(crypto_sign_BYTES);
    for (var i = 0; i < sig.length; i++) sig[i] = signedMsg[i];
    return sig;
  };
  
  nacl.sign.detached.verify = function(msg, sig, publicKey) {
    checkArrayTypes(msg, sig, publicKey);
    if (sig.length !== crypto_sign_BYTES)
      throw new Error('bad signature size');
    if (publicKey.length !== crypto_sign_PUBLICKEYBYTES)
      throw new Error('bad public key size');
    var sm = new Uint8Array(crypto_sign_BYTES + msg.length);
    var m = new Uint8Array(crypto_sign_BYTES + msg.length);
    var i;
    for (i = 0; i < crypto_sign_BYTES; i++) sm[i] = sig[i];
    for (i = 0; i < msg.length; i++) sm[i+crypto_sign_BYTES] = msg[i];
    return (crypto_sign_open(m, sm, sm.length, publicKey) >= 0);
  };
  
  nacl.sign.keyPair = function() {
    var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
    var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
    crypto_sign_keypair(pk, sk);
    return {publicKey: pk, secretKey: sk};
  };
  
  nacl.sign.keyPair.fromSecretKey = function(secretKey) {
    checkArrayTypes(secretKey);
    if (secretKey.length !== crypto_sign_SECRETKEYBYTES)
      throw new Error('bad secret key size');
    var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
    for (var i = 0; i < pk.length; i++) pk[i] = secretKey[32+i];
    return {publicKey: pk, secretKey: new Uint8Array(secretKey)};
  };
  
  nacl.sign.keyPair.fromSeed = function(seed) {
    checkArrayTypes(seed);
    if (seed.length !== crypto_sign_SEEDBYTES)
      throw new Error('bad seed size');
    var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
    var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
    for (var i = 0; i < 32; i++) sk[i] = seed[i];
    crypto_sign_keypair(pk, sk, true);
    return {publicKey: pk, secretKey: sk};
  };
  
  nacl.sign.publicKeyLength = crypto_sign_PUBLICKEYBYTES;
  nacl.sign.secretKeyLength = crypto_sign_SECRETKEYBYTES;
  nacl.sign.seedLength = crypto_sign_SEEDBYTES;
  nacl.sign.signatureLength = crypto_sign_BYTES;
  
  nacl.hash = function(msg) {
    checkArrayTypes(msg);
    var h = new Uint8Array(crypto_hash_BYTES);
    crypto_hash(h, msg, msg.length);
    return h;
  };
  
  nacl.hash.hashLength = crypto_hash_BYTES;
  
  nacl.verify = function(x, y) {
    checkArrayTypes(x, y);
    // Zero length arguments are considered not equal.
    if (x.length === 0 || y.length === 0) return false;
    if (x.length !== y.length) return false;
    return (vn(x, 0, y, 0, x.length) === 0) ? true : false;
  };
  
  nacl.setPRNG = function(fn) {
    randombytes = fn;
  };
  
  (function() {
    // Initialize PRNG if environment provides CSPRNG.
    // If not, methods calling randombytes will throw.
    var crypto = typeof self !== 'undefined' ? (self.crypto || self.msCrypto) : null;
    if (crypto && crypto.getRandomValues) {
      // Browsers.
      var QUOTA = 65536;
      nacl.setPRNG(function(x, n) {
        var i, v = new Uint8Array(n);
        for (i = 0; i < n; i += QUOTA) {
          crypto.getRandomValues(v.subarray(i, i + Math.min(n - i, QUOTA)));
        }
        for (i = 0; i < n; i++) x[i] = v[i];
        cleanup(v);
      });
    } else if (true) {
      // Node.js.
      crypto = __webpack_require__(3);
      if (crypto && crypto.randomBytes) {
        nacl.setPRNG(function(x, n) {
          var i, v = crypto.randomBytes(n);
          for (i = 0; i < n; i++) x[i] = v[i];
          cleanup(v);
        });
      }
    }
  })();
  
  })( true && module.exports ? module.exports : (self.nacl = self.nacl || {}));
  
  
  /***/ }),
  /* 21 */
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = __webpack_require__(47).default;
  
  
  /***/ }),
  /* 22 */
  /***/ (function(module, exports) {
  
  module.exports = require("buffer");
  
  /***/ }),
  /* 23 */
  /***/ (function(module, exports) {
  
  module.exports = require("events");
  
  /***/ }),
  /* 24 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  /**
  
  Streams in a WebSocket connection
  ---------------------------------
  
  We model a WebSocket as two duplex streams: one stream is for the wire protocol
  over an I/O socket, and the other is for incoming/outgoing messages.
  
  
                          +----------+      +---------+      +----------+
      [1] write(chunk) -->| ~~~~~~~~ +----->| parse() +----->| ~~~~~~~~ +--> emit('data') [2]
                          |          |      +----+----+      |          |
                          |          |           |           |          |
                          |    IO    |           | [5]       | Messages |
                          |          |           V           |          |
                          |          |      +---------+      |          |
      [4] emit('data') <--+ ~~~~~~~~ |<-----+ frame() |<-----+ ~~~~~~~~ |<-- write(chunk) [3]
                          +----------+      +---------+      +----------+
  
  
  Message transfer in each direction is simple: IO receives a byte stream [1] and
  sends this stream for parsing. The parser will periodically emit a complete
  message text on the Messages stream [2]. Similarly, when messages are written
  to the Messages stream [3], they are framed using the WebSocket wire format and
  emitted via IO [4].
  
  There is a feedback loop via [5] since some input from [1] will be things like
  ping, pong and close frames. In these cases the protocol responds by emitting
  responses directly back to [4] rather than emitting messages via [2].
  
  For the purposes of flow control, we consider the sources of each Readable
  stream to be as follows:
  
  * [2] receives input from [1]
  * [4] receives input from [1] and [3]
  
  The classes below express the relationships described above without prescribing
  anything about how parse() and frame() work, other than assuming they emit
  'data' events to the IO and Messages streams. They will work with any protocol
  driver having these two methods.
  **/
  
  
  var Stream = __webpack_require__(5).Stream,
      util   = __webpack_require__(0);
  
  
  var IO = function(driver) {
    this.readable = this.writable = true;
    this._paused  = false;
    this._driver  = driver;
  };
  util.inherits(IO, Stream);
  
  // The IO pause() and resume() methods will be called when the socket we are
  // piping to gets backed up and drains. Since IO output [4] comes from IO input
  // [1] and Messages input [3], we need to tell both of those to return false
  // from write() when this stream is paused.
  
  IO.prototype.pause = function() {
    this._paused = true;
    this._driver.messages._paused = true;
  };
  
  IO.prototype.resume = function() {
    this._paused = false;
    this.emit('drain');
  
    var messages = this._driver.messages;
    messages._paused = false;
    messages.emit('drain');
  };
  
  // When we receive input from a socket, send it to the parser and tell the
  // source whether to back off.
  IO.prototype.write = function(chunk) {
    if (!this.writable) return false;
    this._driver.parse(chunk);
    return !this._paused;
  };
  
  // The IO end() method will be called when the socket piping into it emits
  // 'close' or 'end', i.e. the socket is closed. In this situation the Messages
  // stream will not emit any more data so we emit 'end'.
  IO.prototype.end = function(chunk) {
    if (!this.writable) return;
    if (chunk !== undefined) this.write(chunk);
    this.writable = false;
  
    var messages = this._driver.messages;
    if (messages.readable) {
      messages.readable = messages.writable = false;
      messages.emit('end');
    }
  };
  
  IO.prototype.destroy = function() {
    this.end();
  };
  
  
  var Messages = function(driver) {
    this.readable = this.writable = true;
    this._paused  = false;
    this._driver  = driver;
  };
  util.inherits(Messages, Stream);
  
  // The Messages pause() and resume() methods will be called when the app that's
  // processing the messages gets backed up and drains. If we're emitting
  // messages too fast we should tell the source to slow down. Message output [2]
  // comes from IO input [1].
  
  Messages.prototype.pause = function() {
    this._driver.io._paused = true;
  };
  
  Messages.prototype.resume = function() {
    this._driver.io._paused = false;
    this._driver.io.emit('drain');
  };
  
  // When we receive messages from the user, send them to the formatter and tell
  // the source whether to back off.
  Messages.prototype.write = function(message) {
    if (!this.writable) return false;
    if (typeof message === 'string') this._driver.text(message);
    else this._driver.binary(message);
    return !this._paused;
  };
  
  // The Messages end() method will be called when a stream piping into it emits
  // 'end'. Many streams may be piped into the WebSocket and one of them ending
  // does not mean the whole socket is done, so just process the input and move
  // on leaving the socket open.
  Messages.prototype.end = function(message) {
    if (message !== undefined) this.write(message);
  };
  
  Messages.prototype.destroy = function() {};
  
  
  exports.IO = IO;
  exports.Messages = Messages;
  
  
  /***/ }),
  /* 25 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var Buffer = __webpack_require__(1).Buffer;
  
  var StreamReader = function() {
    this._queue     = [];
    this._queueSize = 0;
    this._offset    = 0;
  };
  
  StreamReader.prototype.put = function(buffer) {
    if (!buffer || buffer.length === 0) return;
    if (!Buffer.isBuffer(buffer)) buffer = Buffer.from(buffer);
    this._queue.push(buffer);
    this._queueSize += buffer.length;
  };
  
  StreamReader.prototype.read = function(length) {
    if (length > this._queueSize) return null;
    if (length === 0) return Buffer.alloc(0);
  
    this._queueSize -= length;
  
    var queue  = this._queue,
        remain = length,
        first  = queue[0],
        buffers, buffer;
  
    if (first.length >= length) {
      if (first.length === length) {
        return queue.shift();
      } else {
        buffer = first.slice(0, length);
        queue[0] = first.slice(length);
        return buffer;
      }
    }
  
    for (var i = 0, n = queue.length; i < n; i++) {
      if (remain < queue[i].length) break;
      remain -= queue[i].length;
    }
    buffers = queue.splice(0, i);
  
    if (remain > 0 && queue.length > 0) {
      buffers.push(queue[0].slice(0, remain));
      queue[0] = queue[0].slice(remain);
    }
    return Buffer.concat(buffers, length);
  };
  
  StreamReader.prototype.eachByte = function(callback, context) {
    var buffer, n, index;
  
    while (this._queue.length > 0) {
      buffer = this._queue[0];
      n = buffer.length;
  
      while (this._offset < n) {
        index = this._offset;
        this._offset += 1;
        callback.call(context, buffer[index]);
      }
      this._offset = 0;
      this._queue.shift();
    }
  };
  
  module.exports = StreamReader;
  
  
  /***/ }),
  /* 26 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var Buffer     = __webpack_require__(1).Buffer,
      crypto     = __webpack_require__(3),
      url        = __webpack_require__(6),
      util       = __webpack_require__(0),
      HttpParser = __webpack_require__(10),
      Base       = __webpack_require__(2),
      Hybi       = __webpack_require__(12),
      Proxy      = __webpack_require__(36);
  
  var Client = function(_url, options) {
    this.version = 'hybi-' + Hybi.VERSION;
    Hybi.call(this, null, _url, options);
  
    this.readyState = -1;
    this._key       = Client.generateKey();
    this._accept    = Hybi.generateAccept(this._key);
    this._http      = new HttpParser('response');
  
    var uri  = url.parse(this.url),
        auth = uri.auth && Buffer.from(uri.auth, 'utf8').toString('base64');
  
    if (this.VALID_PROTOCOLS.indexOf(uri.protocol) < 0)
      throw new Error(this.url + ' is not a valid WebSocket URL');
  
    this._pathname = (uri.pathname || '/') + (uri.search || '');
  
    this._headers.set('Host', uri.host);
    this._headers.set('Upgrade', 'websocket');
    this._headers.set('Connection', 'Upgrade');
    this._headers.set('Sec-WebSocket-Key', this._key);
    this._headers.set('Sec-WebSocket-Version', Hybi.VERSION);
  
    if (this._protocols.length > 0)
      this._headers.set('Sec-WebSocket-Protocol', this._protocols.join(', '));
  
    if (auth)
      this._headers.set('Authorization', 'Basic ' + auth);
  };
  util.inherits(Client, Hybi);
  
  Client.generateKey = function() {
    return crypto.randomBytes(16).toString('base64');
  };
  
  var instance = {
    VALID_PROTOCOLS: ['ws:', 'wss:'],
  
    proxy: function(origin, options) {
      return new Proxy(this, origin, options);
    },
  
    start: function() {
      if (this.readyState !== -1) return false;
      this._write(this._handshakeRequest());
      this.readyState = 0;
      return true;
    },
  
    parse: function(chunk) {
      if (this.readyState === 3) return;
      if (this.readyState > 0) return Hybi.prototype.parse.call(this, chunk);
  
      this._http.parse(chunk);
      if (!this._http.isComplete()) return;
  
      this._validateHandshake();
      if (this.readyState === 3) return;
  
      this._open();
      this.parse(this._http.body);
    },
  
    _handshakeRequest: function() {
      var extensions = this._extensions.generateOffer();
      if (extensions)
        this._headers.set('Sec-WebSocket-Extensions', extensions);
  
      var start   = 'GET ' + this._pathname + ' HTTP/1.1',
          headers = [start, this._headers.toString(), ''];
  
      return Buffer.from(headers.join('\r\n'), 'utf8');
    },
  
    _failHandshake: function(message) {
      message = 'Error during WebSocket handshake: ' + message;
      this.readyState = 3;
      this.emit('error', new Error(message));
      this.emit('close', new Base.CloseEvent(this.ERRORS.protocol_error, message));
    },
  
    _validateHandshake: function() {
      this.statusCode = this._http.statusCode;
      this.headers    = this._http.headers;
  
      if (this._http.error)
        return this._failHandshake(this._http.error.message);
  
      if (this._http.statusCode !== 101)
        return this._failHandshake('Unexpected response code: ' + this._http.statusCode);
  
      var headers    = this._http.headers,
          upgrade    = headers['upgrade'] || '',
          connection = headers['connection'] || '',
          accept     = headers['sec-websocket-accept'] || '',
          protocol   = headers['sec-websocket-protocol'] || '';
  
      if (upgrade === '')
        return this._failHandshake("'Upgrade' header is missing");
      if (upgrade.toLowerCase() !== 'websocket')
        return this._failHandshake("'Upgrade' header value is not 'WebSocket'");
  
      if (connection === '')
        return this._failHandshake("'Connection' header is missing");
      if (connection.toLowerCase() !== 'upgrade')
        return this._failHandshake("'Connection' header value is not 'Upgrade'");
  
      if (accept !== this._accept)
        return this._failHandshake('Sec-WebSocket-Accept mismatch');
  
      this.protocol = null;
  
      if (protocol !== '') {
        if (this._protocols.indexOf(protocol) < 0)
          return this._failHandshake('Sec-WebSocket-Protocol mismatch');
        else
          this.protocol = protocol;
      }
  
      try {
        this._extensions.activate(this.headers['sec-websocket-extensions']);
      } catch (e) {
        return this._failHandshake(e.message);
      }
    }
  };
  
  for (var key in instance)
    Client.prototype[key] = instance[key];
  
  module.exports = Client;
  
  
  /***/ }),
  /* 27 */
  /***/ (function(module, exports, __webpack_require__) {
  
  /*jshint node:true */
  
  var assert = __webpack_require__(28);
  
  exports.HTTPParser = HTTPParser;
  function HTTPParser(type) {
    assert.ok(type === HTTPParser.REQUEST || type === HTTPParser.RESPONSE);
    this.type = type;
    this.state = type + '_LINE';
    this.info = {
      headers: [],
      upgrade: false
    };
    this.trailers = [];
    this.line = '';
    this.isChunked = false;
    this.connection = '';
    this.headerSize = 0; // for preventing too big headers
    this.body_bytes = null;
    this.isUserCall = false;
    this.hadError = false;
  }
  HTTPParser.maxHeaderSize = 80 * 1024; // maxHeaderSize (in bytes) is configurable, but 80kb by default;
  HTTPParser.REQUEST = 'REQUEST';
  HTTPParser.RESPONSE = 'RESPONSE';
  var kOnHeaders = HTTPParser.kOnHeaders = 0;
  var kOnHeadersComplete = HTTPParser.kOnHeadersComplete = 1;
  var kOnBody = HTTPParser.kOnBody = 2;
  var kOnMessageComplete = HTTPParser.kOnMessageComplete = 3;
  
  // Some handler stubs, needed for compatibility
  HTTPParser.prototype[kOnHeaders] =
  HTTPParser.prototype[kOnHeadersComplete] =
  HTTPParser.prototype[kOnBody] =
  HTTPParser.prototype[kOnMessageComplete] = function () {};
  
  var compatMode0_12 = true;
  Object.defineProperty(HTTPParser, 'kOnExecute', {
      get: function () {
        // hack for backward compatibility
        compatMode0_12 = false;
        return 4;
      }
    });
  
  var methods = exports.methods = HTTPParser.methods = [
    'DELETE',
    'GET',
    'HEAD',
    'POST',
    'PUT',
    'CONNECT',
    'OPTIONS',
    'TRACE',
    'COPY',
    'LOCK',
    'MKCOL',
    'MOVE',
    'PROPFIND',
    'PROPPATCH',
    'SEARCH',
    'UNLOCK',
    'BIND',
    'REBIND',
    'UNBIND',
    'ACL',
    'REPORT',
    'MKACTIVITY',
    'CHECKOUT',
    'MERGE',
    'M-SEARCH',
    'NOTIFY',
    'SUBSCRIBE',
    'UNSUBSCRIBE',
    'PATCH',
    'PURGE',
    'MKCALENDAR',
    'LINK',
    'UNLINK'
  ];
  HTTPParser.prototype.reinitialize = HTTPParser;
  HTTPParser.prototype.close =
  HTTPParser.prototype.pause =
  HTTPParser.prototype.resume =
  HTTPParser.prototype.free = function () {};
  HTTPParser.prototype._compatMode0_11 = false;
  HTTPParser.prototype.getAsyncId = function() { return 0; };
  
  var headerState = {
    REQUEST_LINE: true,
    RESPONSE_LINE: true,
    HEADER: true
  };
  HTTPParser.prototype.execute = function (chunk, start, length) {
    if (!(this instanceof HTTPParser)) {
      throw new TypeError('not a HTTPParser');
    }
  
    // backward compat to node < 0.11.4
    // Note: the start and length params were removed in newer version
    start = start || 0;
    length = typeof length === 'number' ? length : chunk.length;
  
    this.chunk = chunk;
    this.offset = start;
    var end = this.end = start + length;
    try {
      while (this.offset < end) {
        if (this[this.state]()) {
          break;
        }
      }
    } catch (err) {
      if (this.isUserCall) {
        throw err;
      }
      this.hadError = true;
      return err;
    }
    this.chunk = null;
    length = this.offset - start;
    if (headerState[this.state]) {
      this.headerSize += length;
      if (this.headerSize > HTTPParser.maxHeaderSize) {
        return new Error('max header size exceeded');
      }
    }
    return length;
  };
  
  var stateFinishAllowed = {
    REQUEST_LINE: true,
    RESPONSE_LINE: true,
    BODY_RAW: true
  };
  HTTPParser.prototype.finish = function () {
    if (this.hadError) {
      return;
    }
    if (!stateFinishAllowed[this.state]) {
      return new Error('invalid state for EOF');
    }
    if (this.state === 'BODY_RAW') {
      this.userCall()(this[kOnMessageComplete]());
    }
  };
  
  // These three methods are used for an internal speed optimization, and it also
  // works if theses are noops. Basically consume() asks us to read the bytes
  // ourselves, but if we don't do it we get them through execute().
  HTTPParser.prototype.consume =
  HTTPParser.prototype.unconsume =
  HTTPParser.prototype.getCurrentBuffer = function () {};
  
  //For correct error handling - see HTTPParser#execute
  //Usage: this.userCall()(userFunction('arg'));
  HTTPParser.prototype.userCall = function () {
    this.isUserCall = true;
    var self = this;
    return function (ret) {
      self.isUserCall = false;
      return ret;
    };
  };
  
  HTTPParser.prototype.nextRequest = function () {
    this.userCall()(this[kOnMessageComplete]());
    this.reinitialize(this.type);
  };
  
  HTTPParser.prototype.consumeLine = function () {
    var end = this.end,
        chunk = this.chunk;
    for (var i = this.offset; i < end; i++) {
      if (chunk[i] === 0x0a) { // \n
        var line = this.line + chunk.toString('ascii', this.offset, i);
        if (line.charAt(line.length - 1) === '\r') {
          line = line.substr(0, line.length - 1);
        }
        this.line = '';
        this.offset = i + 1;
        return line;
      }
    }
    //line split over multiple chunks
    this.line += chunk.toString('ascii', this.offset, this.end);
    this.offset = this.end;
  };
  
  var headerExp = /^([^: \t]+):[ \t]*((?:.*[^ \t])|)/;
  var headerContinueExp = /^[ \t]+(.*[^ \t])/;
  HTTPParser.prototype.parseHeader = function (line, headers) {
    if (line.indexOf('\r') !== -1) {
      throw parseErrorCode('HPE_LF_EXPECTED');
    }
  
    var match = headerExp.exec(line);
    var k = match && match[1];
    if (k) { // skip empty string (malformed header)
      headers.push(k);
      headers.push(match[2]);
    } else {
      var matchContinue = headerContinueExp.exec(line);
      if (matchContinue && headers.length) {
        if (headers[headers.length - 1]) {
          headers[headers.length - 1] += ' ';
        }
        headers[headers.length - 1] += matchContinue[1];
      }
    }
  };
  
  var requestExp = /^([A-Z-]+) ([^ ]+) HTTP\/(\d)\.(\d)$/;
  HTTPParser.prototype.REQUEST_LINE = function () {
    var line = this.consumeLine();
    if (!line) {
      return;
    }
    var match = requestExp.exec(line);
    if (match === null) {
      throw parseErrorCode('HPE_INVALID_CONSTANT');
    }
    this.info.method = this._compatMode0_11 ? match[1] : methods.indexOf(match[1]);
    if (this.info.method === -1) {
      throw new Error('invalid request method');
    }
    if (match[1] === 'CONNECT') {
      this.info.upgrade = true;
    }
    this.info.url = match[2];
    this.info.versionMajor = +match[3];
    this.info.versionMinor = +match[4];
    this.body_bytes = 0;
    this.state = 'HEADER';
  };
  
  var responseExp = /^HTTP\/(\d)\.(\d) (\d{3}) ?(.*)$/;
  HTTPParser.prototype.RESPONSE_LINE = function () {
    var line = this.consumeLine();
    if (!line) {
      return;
    }
    var match = responseExp.exec(line);
    if (match === null) {
      throw parseErrorCode('HPE_INVALID_CONSTANT');
    }
    this.info.versionMajor = +match[1];
    this.info.versionMinor = +match[2];
    var statusCode = this.info.statusCode = +match[3];
    this.info.statusMessage = match[4];
    // Implied zero length.
    if ((statusCode / 100 | 0) === 1 || statusCode === 204 || statusCode === 304) {
      this.body_bytes = 0;
    }
    this.state = 'HEADER';
  };
  
  HTTPParser.prototype.shouldKeepAlive = function () {
    if (this.info.versionMajor > 0 && this.info.versionMinor > 0) {
      if (this.connection.indexOf('close') !== -1) {
        return false;
      }
    } else if (this.connection.indexOf('keep-alive') === -1) {
      return false;
    }
    if (this.body_bytes !== null || this.isChunked) { // || skipBody
      return true;
    }
    return false;
  };
  
  HTTPParser.prototype.HEADER = function () {
    var line = this.consumeLine();
    if (line === undefined) {
      return;
    }
    var info = this.info;
    if (line) {
      this.parseHeader(line, info.headers);
    } else {
      var headers = info.headers;
      var hasContentLength = false;
      var currentContentLengthValue;
      for (var i = 0; i < headers.length; i += 2) {
        switch (headers[i].toLowerCase()) {
          case 'transfer-encoding':
            this.isChunked = headers[i + 1].toLowerCase() === 'chunked';
            break;
          case 'content-length':
            currentContentLengthValue = +headers[i + 1];
            if (hasContentLength) {
              // Fix duplicate Content-Length header with same values.
              // Throw error only if values are different.
              // Known issues:
              // https://github.com/request/request/issues/2091#issuecomment-328715113
              // https://github.com/nodejs/node/issues/6517#issuecomment-216263771
              if (currentContentLengthValue !== this.body_bytes) {
                throw parseErrorCode('HPE_UNEXPECTED_CONTENT_LENGTH');
              }
            } else {
              hasContentLength = true;
              this.body_bytes = currentContentLengthValue;
            }
            break;
          case 'connection':
            this.connection += headers[i + 1].toLowerCase();
            break;
          case 'upgrade':
            info.upgrade = true;
            break;
        }
      }
  
      if (this.isChunked && hasContentLength) {
        throw parseErrorCode('HPE_UNEXPECTED_CONTENT_LENGTH');
      }
  
      info.shouldKeepAlive = this.shouldKeepAlive();
      //problem which also exists in original node: we should know skipBody before calling onHeadersComplete
      var skipBody;
      if (compatMode0_12) {
        skipBody = this.userCall()(this[kOnHeadersComplete](info));
      } else {
        skipBody = this.userCall()(this[kOnHeadersComplete](info.versionMajor,
            info.versionMinor, info.headers, info.method, info.url, info.statusCode,
            info.statusMessage, info.upgrade, info.shouldKeepAlive));
      }
      if (info.upgrade || skipBody === 2) {
        this.nextRequest();
        return true;
      } else if (this.isChunked && !skipBody) {
        this.state = 'BODY_CHUNKHEAD';
      } else if (skipBody || this.body_bytes === 0) {
        this.nextRequest();
      } else if (this.body_bytes === null) {
        this.state = 'BODY_RAW';
      } else {
        this.state = 'BODY_SIZED';
      }
    }
  };
  
  HTTPParser.prototype.BODY_CHUNKHEAD = function () {
    var line = this.consumeLine();
    if (line === undefined) {
      return;
    }
    this.body_bytes = parseInt(line, 16);
    if (!this.body_bytes) {
      this.state = 'BODY_CHUNKTRAILERS';
    } else {
      this.state = 'BODY_CHUNK';
    }
  };
  
  HTTPParser.prototype.BODY_CHUNK = function () {
    var length = Math.min(this.end - this.offset, this.body_bytes);
    this.userCall()(this[kOnBody](this.chunk, this.offset, length));
    this.offset += length;
    this.body_bytes -= length;
    if (!this.body_bytes) {
      this.state = 'BODY_CHUNKEMPTYLINE';
    }
  };
  
  HTTPParser.prototype.BODY_CHUNKEMPTYLINE = function () {
    var line = this.consumeLine();
    if (line === undefined) {
      return;
    }
    assert.equal(line, '');
    this.state = 'BODY_CHUNKHEAD';
  };
  
  HTTPParser.prototype.BODY_CHUNKTRAILERS = function () {
    var line = this.consumeLine();
    if (line === undefined) {
      return;
    }
    if (line) {
      this.parseHeader(line, this.trailers);
    } else {
      if (this.trailers.length) {
        this.userCall()(this[kOnHeaders](this.trailers, ''));
      }
      this.nextRequest();
    }
  };
  
  HTTPParser.prototype.BODY_RAW = function () {
    var length = this.end - this.offset;
    this.userCall()(this[kOnBody](this.chunk, this.offset, length));
    this.offset = this.end;
  };
  
  HTTPParser.prototype.BODY_SIZED = function () {
    var length = Math.min(this.end - this.offset, this.body_bytes);
    this.userCall()(this[kOnBody](this.chunk, this.offset, length));
    this.offset += length;
    this.body_bytes -= length;
    if (!this.body_bytes) {
      this.nextRequest();
    }
  };
  
  // backward compat to node < 0.11.6
  ['Headers', 'HeadersComplete', 'Body', 'MessageComplete'].forEach(function (name) {
    var k = HTTPParser['kOn' + name];
    Object.defineProperty(HTTPParser.prototype, 'on' + name, {
      get: function () {
        return this[k];
      },
      set: function (to) {
        // hack for backward compatibility
        this._compatMode0_11 = true;
        return (this[k] = to);
      }
    });
  });
  
  function parseErrorCode(code) {
    var err = new Error('Parse Error');
    err.code = code;
    return err;
  }
  
  
  /***/ }),
  /* 28 */
  /***/ (function(module, exports) {
  
  module.exports = require("assert");
  
  /***/ }),
  /* 29 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var Parser   = __webpack_require__(30),
      Pipeline = __webpack_require__(31);
  
  var Extensions = function() {
    this._rsv1 = this._rsv2 = this._rsv3 = null;
  
    this._byName   = {};
    this._inOrder  = [];
    this._sessions = [];
    this._index    = {};
  };
  
  Extensions.MESSAGE_OPCODES = [1, 2];
  
  var instance = {
    add: function(ext) {
      if (typeof ext.name !== 'string') throw new TypeError('extension.name must be a string');
      if (ext.type !== 'permessage') throw new TypeError('extension.type must be "permessage"');
  
      if (typeof ext.rsv1 !== 'boolean') throw new TypeError('extension.rsv1 must be true or false');
      if (typeof ext.rsv2 !== 'boolean') throw new TypeError('extension.rsv2 must be true or false');
      if (typeof ext.rsv3 !== 'boolean') throw new TypeError('extension.rsv3 must be true or false');
  
      if (this._byName.hasOwnProperty(ext.name))
        throw new TypeError('An extension with name "' + ext.name + '" is already registered');
  
      this._byName[ext.name] = ext;
      this._inOrder.push(ext);
    },
  
    generateOffer: function() {
      var sessions = [],
          offer    = [],
          index    = {};
  
      this._inOrder.forEach(function(ext) {
        var session = ext.createClientSession();
        if (!session) return;
  
        var record = [ext, session];
        sessions.push(record);
        index[ext.name] = record;
  
        var offers = session.generateOffer();
        offers = offers ? [].concat(offers) : [];
  
        offers.forEach(function(off) {
          offer.push(Parser.serializeParams(ext.name, off));
        }, this);
      }, this);
  
      this._sessions = sessions;
      this._index    = index;
  
      return offer.length > 0 ? offer.join(', ') : null;
    },
  
    activate: function(header) {
      var responses = Parser.parseHeader(header),
          sessions  = [];
  
      responses.eachOffer(function(name, params) {
        var record = this._index[name];
  
        if (!record)
          throw new Error('Server sent an extension response for unknown extension "' + name + '"');
  
        var ext      = record[0],
            session  = record[1],
            reserved = this._reserved(ext);
  
        if (reserved)
          throw new Error('Server sent two extension responses that use the RSV' +
                          reserved[0] + ' bit: "' +
                          reserved[1] + '" and "' + ext.name + '"');
  
        if (session.activate(params) !== true)
          throw new Error('Server sent unacceptable extension parameters: ' +
                          Parser.serializeParams(name, params));
  
        this._reserve(ext);
        sessions.push(record);
      }, this);
  
      this._sessions = sessions;
      this._pipeline = new Pipeline(sessions);
    },
  
    generateResponse: function(header) {
      var sessions = [],
          response = [],
          offers   = Parser.parseHeader(header);
  
      this._inOrder.forEach(function(ext) {
        var offer = offers.byName(ext.name);
        if (offer.length === 0 || this._reserved(ext)) return;
  
        var session = ext.createServerSession(offer);
        if (!session) return;
  
        this._reserve(ext);
        sessions.push([ext, session]);
        response.push(Parser.serializeParams(ext.name, session.generateResponse()));
      }, this);
  
      this._sessions = sessions;
      this._pipeline = new Pipeline(sessions);
  
      return response.length > 0 ? response.join(', ') : null;
    },
  
    validFrameRsv: function(frame) {
      var allowed = { rsv1: false, rsv2: false, rsv3: false },
          ext;
  
      if (Extensions.MESSAGE_OPCODES.indexOf(frame.opcode) >= 0) {
        for (var i = 0, n = this._sessions.length; i < n; i++) {
          ext = this._sessions[i][0];
          allowed.rsv1 = allowed.rsv1 || ext.rsv1;
          allowed.rsv2 = allowed.rsv2 || ext.rsv2;
          allowed.rsv3 = allowed.rsv3 || ext.rsv3;
        }
      }
  
      return (allowed.rsv1 || !frame.rsv1) &&
             (allowed.rsv2 || !frame.rsv2) &&
             (allowed.rsv3 || !frame.rsv3);
    },
  
    processIncomingMessage: function(message, callback, context) {
      this._pipeline.processIncomingMessage(message, callback, context);
    },
  
    processOutgoingMessage: function(message, callback, context) {
      this._pipeline.processOutgoingMessage(message, callback, context);
    },
  
    close: function(callback, context) {
      if (!this._pipeline) return callback.call(context);
      this._pipeline.close(callback, context);
    },
  
    _reserve: function(ext) {
      this._rsv1 = this._rsv1 || (ext.rsv1 && ext.name);
      this._rsv2 = this._rsv2 || (ext.rsv2 && ext.name);
      this._rsv3 = this._rsv3 || (ext.rsv3 && ext.name);
    },
  
    _reserved: function(ext) {
      if (this._rsv1 && ext.rsv1) return [1, this._rsv1];
      if (this._rsv2 && ext.rsv2) return [2, this._rsv2];
      if (this._rsv3 && ext.rsv3) return [3, this._rsv3];
      return false;
    }
  };
  
  for (var key in instance)
    Extensions.prototype[key] = instance[key];
  
  module.exports = Extensions;
  
  
  /***/ }),
  /* 30 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var TOKEN    = /([!#\$%&'\*\+\-\.\^_`\|~0-9A-Za-z]+)/,
      NOTOKEN  = /([^!#\$%&'\*\+\-\.\^_`\|~0-9A-Za-z])/g,
      QUOTED   = /"((?:\\[\x00-\x7f]|[^\x00-\x08\x0a-\x1f\x7f"\\])*)"/,
      PARAM    = new RegExp(TOKEN.source + '(?:=(?:' + TOKEN.source + '|' + QUOTED.source + '))?'),
      EXT      = new RegExp(TOKEN.source + '(?: *; *' + PARAM.source + ')*', 'g'),
      EXT_LIST = new RegExp('^' + EXT.source + '(?: *, *' + EXT.source + ')*$'),
      NUMBER   = /^-?(0|[1-9][0-9]*)(\.[0-9]+)?$/;
  
  var hasOwnProperty = Object.prototype.hasOwnProperty;
  
  var Parser = {
    parseHeader: function(header) {
      var offers = new Offers();
      if (header === '' || header === undefined) return offers;
  
      if (!EXT_LIST.test(header))
        throw new SyntaxError('Invalid Sec-WebSocket-Extensions header: ' + header);
  
      var values = header.match(EXT);
  
      values.forEach(function(value) {
        var params = value.match(new RegExp(PARAM.source, 'g')),
            name   = params.shift(),
            offer  = {};
  
        params.forEach(function(param) {
          var args = param.match(PARAM), key = args[1], data;
  
          if (args[2] !== undefined) {
            data = args[2];
          } else if (args[3] !== undefined) {
            data = args[3].replace(/\\/g, '');
          } else {
            data = true;
          }
          if (NUMBER.test(data)) data = parseFloat(data);
  
          if (hasOwnProperty.call(offer, key)) {
            offer[key] = [].concat(offer[key]);
            offer[key].push(data);
          } else {
            offer[key] = data;
          }
        }, this);
        offers.push(name, offer);
      }, this);
  
      return offers;
    },
  
    serializeParams: function(name, params) {
      var values = [];
  
      var print = function(key, value) {
        if (value instanceof Array) {
          value.forEach(function(v) { print(key, v) });
        } else if (value === true) {
          values.push(key);
        } else if (typeof value === 'number') {
          values.push(key + '=' + value);
        } else if (NOTOKEN.test(value)) {
          values.push(key + '="' + value.replace(/"/g, '\\"') + '"');
        } else {
          values.push(key + '=' + value);
        }
      };
  
      for (var key in params) print(key, params[key]);
  
      return [name].concat(values).join('; ');
    }
  };
  
  var Offers = function() {
    this._byName  = {};
    this._inOrder = [];
  };
  
  Offers.prototype.push = function(name, params) {
    if (!hasOwnProperty.call(this._byName, name))
      this._byName[name] = [];
  
    this._byName[name].push(params);
    this._inOrder.push({ name: name, params: params });
  };
  
  Offers.prototype.eachOffer = function(callback, context) {
    var list = this._inOrder;
    for (var i = 0, n = list.length; i < n; i++)
      callback.call(context, list[i].name, list[i].params);
  };
  
  Offers.prototype.byName = function(name) {
    return this._byName[name] || [];
  };
  
  Offers.prototype.toArray = function() {
    return this._inOrder.slice();
  };
  
  module.exports = Parser;
  
  
  /***/ }),
  /* 31 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var Cell   = __webpack_require__(32),
      Pledge = __webpack_require__(14);
  
  var Pipeline = function(sessions) {
    this._cells   = sessions.map(function(session) { return new Cell(session) });
    this._stopped = { incoming: false, outgoing: false };
  };
  
  Pipeline.prototype.processIncomingMessage = function(message, callback, context) {
    if (this._stopped.incoming) return;
    this._loop('incoming', this._cells.length - 1, -1, -1, message, callback, context);
  };
  
  Pipeline.prototype.processOutgoingMessage = function(message, callback, context) {
    if (this._stopped.outgoing) return;
    this._loop('outgoing', 0, this._cells.length, 1, message, callback, context);
  };
  
  Pipeline.prototype.close = function(callback, context) {
    this._stopped = { incoming: true, outgoing: true };
  
    var closed = this._cells.map(function(a) { return a.close() });
    if (callback)
      Pledge.all(closed).then(function() { callback.call(context) });
  };
  
  Pipeline.prototype._loop = function(direction, start, end, step, message, callback, context) {
    var cells = this._cells,
        n     = cells.length,
        self  = this;
  
    while (n--) cells[n].pending(direction);
  
    var pipe = function(index, error, msg) {
      if (index === end) return callback.call(context, error, msg);
  
      cells[index][direction](error, msg, function(err, m) {
        if (err) self._stopped[direction] = true;
        pipe(index + step, err, m);
      });
    };
    pipe(start, null, message);
  };
  
  module.exports = Pipeline;
  
  
  /***/ }),
  /* 32 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var Functor = __webpack_require__(33),
      Pledge  = __webpack_require__(14);
  
  var Cell = function(tuple) {
    this._ext     = tuple[0];
    this._session = tuple[1];
  
    this._functors = {
      incoming: new Functor(this._session, 'processIncomingMessage'),
      outgoing: new Functor(this._session, 'processOutgoingMessage')
    };
  };
  
  Cell.prototype.pending = function(direction) {
    var functor = this._functors[direction];
    if (!functor._stopped) functor.pending += 1;
  };
  
  Cell.prototype.incoming = function(error, message, callback, context) {
    this._exec('incoming', error, message, callback, context);
  };
  
  Cell.prototype.outgoing = function(error, message, callback, context) {
    this._exec('outgoing', error, message, callback, context);
  };
  
  Cell.prototype.close = function() {
    this._closed = this._closed || new Pledge();
    this._doClose();
    return this._closed;
  };
  
  Cell.prototype._exec = function(direction, error, message, callback, context) {
    this._functors[direction].call(error, message, function(err, msg) {
      if (err) err.message = this._ext.name + ': ' + err.message;
      callback.call(context, err, msg);
      this._doClose();
    }, this);
  };
  
  Cell.prototype._doClose = function() {
    var fin  = this._functors.incoming,
        fout = this._functors.outgoing;
  
    if (!this._closed || fin.pending + fout.pending !== 0) return;
    if (this._session) this._session.close();
    this._session = null;
    this._closed.done();
  };
  
  module.exports = Cell;
  
  
  /***/ }),
  /* 33 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var RingBuffer = __webpack_require__(13);
  
  var Functor = function(session, method) {
    this._session = session;
    this._method  = method;
    this._queue   = new RingBuffer(Functor.QUEUE_SIZE);
    this._stopped = false;
    this.pending  = 0;
  };
  
  Functor.QUEUE_SIZE = 8;
  
  Functor.prototype.call = function(error, message, callback, context) {
    if (this._stopped) return;
  
    var record = { error: error, message: message, callback: callback, context: context, done: false },
        called = false,
        self   = this;
  
    this._queue.push(record);
  
    if (record.error) {
      record.done = true;
      this._stop();
      return this._flushQueue();
    }
  
    var handler = function(err, msg) {
      if (!(called ^ (called = true))) return;
  
      if (err) {
        self._stop();
        record.error   = err;
        record.message = null;
      } else {
        record.message = msg;
      }
  
      record.done = true;
      self._flushQueue();
    };
  
    try {
      this._session[this._method](message, handler);
    } catch (err) {
      handler(err);
    }
  };
  
  Functor.prototype._stop = function() {
    this.pending  = this._queue.length;
    this._stopped = true;
  };
  
  Functor.prototype._flushQueue = function() {
    var queue = this._queue, record;
  
    while (queue.length > 0 && queue.peek().done) {
      record = queue.shift();
      if (record.error) {
        this.pending = 0;
        queue.clear();
      } else {
        this.pending -= 1;
      }
      record.callback.call(record.context, record.error, record.message);
    }
  };
  
  module.exports = Functor;
  
  
  /***/ }),
  /* 34 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var Frame = function() {};
  
  var instance = {
    final:        false,
    rsv1:         false,
    rsv2:         false,
    rsv3:         false,
    opcode:       null,
    masked:       false,
    maskingKey:   null,
    lengthBytes:  1,
    length:       0,
    payload:      null
  };
  
  for (var key in instance)
    Frame.prototype[key] = instance[key];
  
  module.exports = Frame;
  
  
  /***/ }),
  /* 35 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var Buffer = __webpack_require__(1).Buffer;
  
  var Message = function() {
    this.rsv1    = false;
    this.rsv2    = false;
    this.rsv3    = false;
    this.opcode  = null;
    this.length  = 0;
    this._chunks = [];
  };
  
  var instance = {
    read: function() {
      return this.data = this.data || Buffer.concat(this._chunks, this.length);
    },
  
    pushFrame: function(frame) {
      this.rsv1 = this.rsv1 || frame.rsv1;
      this.rsv2 = this.rsv2 || frame.rsv2;
      this.rsv3 = this.rsv3 || frame.rsv3;
  
      if (this.opcode === null) this.opcode = frame.opcode;
  
      this._chunks.push(frame.payload);
      this.length += frame.length;
    }
  };
  
  for (var key in instance)
    Message.prototype[key] = instance[key];
  
  module.exports = Message;
  
  
  /***/ }),
  /* 36 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var Buffer     = __webpack_require__(1).Buffer,
      Stream     = __webpack_require__(5).Stream,
      url        = __webpack_require__(6),
      util       = __webpack_require__(0),
      Base       = __webpack_require__(2),
      Headers    = __webpack_require__(9),
      HttpParser = __webpack_require__(10);
  
  var PORTS = { 'ws:': 80, 'wss:': 443 };
  
  var Proxy = function(client, origin, options) {
    this._client  = client;
    this._http    = new HttpParser('response');
    this._origin  = (typeof client.url === 'object') ? client.url : url.parse(client.url);
    this._url     = (typeof origin === 'object') ? origin : url.parse(origin);
    this._options = options || {};
    this._state   = 0;
  
    this.readable = this.writable = true;
    this._paused  = false;
  
    this._headers = new Headers();
    this._headers.set('Host', this._origin.host);
    this._headers.set('Connection', 'keep-alive');
    this._headers.set('Proxy-Connection', 'keep-alive');
  
    var auth = this._url.auth && Buffer.from(this._url.auth, 'utf8').toString('base64');
    if (auth) this._headers.set('Proxy-Authorization', 'Basic ' + auth);
  };
  util.inherits(Proxy, Stream);
  
  var instance = {
    setHeader: function(name, value) {
      if (this._state !== 0) return false;
      this._headers.set(name, value);
      return true;
    },
  
    start: function() {
      if (this._state !== 0) return false;
      this._state = 1;
  
      var origin = this._origin,
          port   = origin.port || PORTS[origin.protocol],
          start  = 'CONNECT ' + origin.hostname + ':' + port + ' HTTP/1.1';
  
      var headers = [start, this._headers.toString(), ''];
  
      this.emit('data', Buffer.from(headers.join('\r\n'), 'utf8'));
      return true;
    },
  
    pause: function() {
      this._paused = true;
    },
  
    resume: function() {
      this._paused = false;
      this.emit('drain');
    },
  
    write: function(chunk) {
      if (!this.writable) return false;
  
      this._http.parse(chunk);
      if (!this._http.isComplete()) return !this._paused;
  
      this.statusCode = this._http.statusCode;
      this.headers    = this._http.headers;
  
      if (this.statusCode === 200) {
        this.emit('connect', new Base.ConnectEvent());
      } else {
        var message = "Can't establish a connection to the server at " + this._origin.href;
        this.emit('error', new Error(message));
      }
      this.end();
      return !this._paused;
    },
  
    end: function(chunk) {
      if (!this.writable) return;
      if (chunk !== undefined) this.write(chunk);
      this.readable = this.writable = false;
      this.emit('close');
      this.emit('end');
    },
  
    destroy: function() {
      this.end();
    }
  };
  
  for (var key in instance)
    Proxy.prototype[key] = instance[key];
  
  module.exports = Proxy;
  
  
  /***/ }),
  /* 37 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var util       = __webpack_require__(0),
      HttpParser = __webpack_require__(10),
      Base       = __webpack_require__(2),
      Draft75    = __webpack_require__(15),
      Draft76    = __webpack_require__(38),
      Hybi       = __webpack_require__(12);
  
  var Server = function(options) {
    Base.call(this, null, null, options);
    this._http = new HttpParser('request');
  };
  util.inherits(Server, Base);
  
  var instance = {
    EVENTS: ['open', 'message', 'error', 'close'],
  
    _bindEventListeners: function() {
      this.messages.on('error', function() {});
      this.on('error', function() {});
    },
  
    parse: function(chunk) {
      if (this._delegate) return this._delegate.parse(chunk);
  
      this._http.parse(chunk);
      if (!this._http.isComplete()) return;
  
      this.method  = this._http.method;
      this.url     = this._http.url;
      this.headers = this._http.headers;
      this.body    = this._http.body;
  
      var self = this;
      this._delegate = Server.http(this, this._options);
      this._delegate.messages = this.messages;
      this._delegate.io = this.io;
      this._open();
  
      this.EVENTS.forEach(function(event) {
        this._delegate.on(event, function(e) { self.emit(event, e) });
      }, this);
  
      this.protocol = this._delegate.protocol;
      this.version  = this._delegate.version;
  
      this.parse(this._http.body);
      this.emit('connect', new Base.ConnectEvent());
    },
  
    _open: function() {
      this.__queue.forEach(function(msg) {
        this._delegate[msg[0]].apply(this._delegate, msg[1]);
      }, this);
      this.__queue = [];
    }
  };
  
  ['addExtension', 'setHeader', 'start', 'frame', 'text', 'binary', 'ping', 'close'].forEach(function(method) {
    instance[method] = function() {
      if (this._delegate) {
        return this._delegate[method].apply(this._delegate, arguments);
      } else {
        this.__queue.push([method, arguments]);
        return true;
      }
    };
  });
  
  for (var key in instance)
    Server.prototype[key] = instance[key];
  
  Server.isSecureRequest = function(request) {
    if (request.connection && request.connection.authorized !== undefined) return true;
    if (request.socket && request.socket.secure) return true;
  
    var headers = request.headers;
    if (!headers) return false;
    if (headers['https'] === 'on') return true;
    if (headers['x-forwarded-ssl'] === 'on') return true;
    if (headers['x-forwarded-scheme'] === 'https') return true;
    if (headers['x-forwarded-proto'] === 'https') return true;
  
    return false;
  };
  
  Server.determineUrl = function(request) {
    var scheme = this.isSecureRequest(request) ? 'wss:' : 'ws:';
    return scheme + '//' + request.headers.host + request.url;
  };
  
  Server.http = function(request, options) {
    options = options || {};
    if (options.requireMasking === undefined) options.requireMasking = true;
  
    var headers = request.headers,
        version = headers['sec-websocket-version'],
        key     = headers['sec-websocket-key'],
        key1    = headers['sec-websocket-key1'],
        key2    = headers['sec-websocket-key2'],
        url     = this.determineUrl(request);
  
    if (version || key)
      return new Hybi(request, url, options);
    else if (key1 || key2)
      return new Draft76(request, url, options);
    else
      return new Draft75(request, url, options);
  };
  
  module.exports = Server;
  
  
  /***/ }),
  /* 38 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var Buffer  = __webpack_require__(1).Buffer,
      Base    = __webpack_require__(2),
      Draft75 = __webpack_require__(15),
      crypto  = __webpack_require__(3),
      util    = __webpack_require__(0);
  
  
  var numberFromKey = function(key) {
    return parseInt((key.match(/[0-9]/g) || []).join(''), 10);
  };
  
  var spacesInKey = function(key) {
    return (key.match(/ /g) || []).length;
  };
  
  
  var Draft76 = function(request, url, options) {
    Draft75.apply(this, arguments);
    this._stage  = -1;
    this._body   = [];
    this.version = 'hixie-76';
  
    this._headers.clear();
  
    this._headers.set('Upgrade', 'WebSocket');
    this._headers.set('Connection', 'Upgrade');
    this._headers.set('Sec-WebSocket-Origin', this._request.headers.origin);
    this._headers.set('Sec-WebSocket-Location', this.url);
  };
  util.inherits(Draft76, Draft75);
  
  var instance = {
    BODY_SIZE: 8,
  
    start: function() {
      if (!Draft75.prototype.start.call(this)) return false;
      this._started = true;
      this._sendHandshakeBody();
      return true;
    },
  
    close: function() {
      if (this.readyState === 3) return false;
      if (this.readyState === 1) this._write(Buffer.from([0xFF, 0x00]));
      this.readyState = 3;
      this.emit('close', new Base.CloseEvent(null, null));
      return true;
    },
  
    _handshakeResponse: function() {
      var headers = this._request.headers,
          key1    = headers['sec-websocket-key1'],
          key2    = headers['sec-websocket-key2'];
  
      if (!key1) throw new Error('Missing required header: Sec-WebSocket-Key1');
      if (!key2) throw new Error('Missing required header: Sec-WebSocket-Key2');
  
      var number1 = numberFromKey(key1),
          spaces1 = spacesInKey(key1),
  
          number2 = numberFromKey(key2),
          spaces2 = spacesInKey(key2);
  
      if (number1 % spaces1 !== 0 || number2 % spaces2 !== 0)
        throw new Error('Client sent invalid Sec-WebSocket-Key headers');
  
      this._keyValues = [number1 / spaces1, number2 / spaces2];
  
      var start   = 'HTTP/1.1 101 WebSocket Protocol Handshake',
          headers = [start, this._headers.toString(), ''];
  
      return Buffer.from(headers.join('\r\n'), 'binary');
    },
  
    _handshakeSignature: function() {
      if (this._body.length < this.BODY_SIZE) return null;
  
      var md5    = crypto.createHash('md5'),
          buffer = Buffer.allocUnsafe(8 + this.BODY_SIZE);
  
      buffer.writeUInt32BE(this._keyValues[0], 0);
      buffer.writeUInt32BE(this._keyValues[1], 4);
      Buffer.from(this._body).copy(buffer, 8, 0, this.BODY_SIZE);
  
      md5.update(buffer);
      return Buffer.from(md5.digest('binary'), 'binary');
    },
  
    _sendHandshakeBody: function() {
      if (!this._started) return;
      var signature = this._handshakeSignature();
      if (!signature) return;
  
      this._write(signature);
      this._stage = 0;
      this._open();
  
      if (this._body.length > this.BODY_SIZE)
        this.parse(this._body.slice(this.BODY_SIZE));
    },
  
    _parseLeadingByte: function(octet) {
      if (octet !== 0xFF)
        return Draft75.prototype._parseLeadingByte.call(this, octet);
  
      this._closing = true;
      this._length  = 0;
      this._stage   = 1;
    }
  };
  
  for (var key in instance)
    Draft76.prototype[key] = instance[key];
  
  module.exports = Draft76;
  
  
  /***/ }),
  /* 39 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var util   = __webpack_require__(0),
      net    = __webpack_require__(40),
      tls    = __webpack_require__(41),
      crypto = __webpack_require__(3),
      url    = __webpack_require__(6),
      driver = __webpack_require__(4),
      API    = __webpack_require__(11),
      Event  = __webpack_require__(7);
  
  var DEFAULT_PORTS    = {'http:': 80, 'https:': 443, 'ws:':80, 'wss:': 443},
      SECURE_PROTOCOLS = ['https:', 'wss:'];
  
  var Client = function(_url, protocols, options) {
    options = options || {};
  
    this.url     = _url;
    this._driver = driver.client(this.url, {maxLength: options.maxLength, protocols: protocols});
  
    ['open', 'error'].forEach(function(event) {
      this._driver.on(event, function() {
        self.headers    = self._driver.headers;
        self.statusCode = self._driver.statusCode;
      });
    }, this);
  
    var proxy     = options.proxy || {},
        endpoint  = url.parse(proxy.origin || this.url),
        port      = endpoint.port || DEFAULT_PORTS[endpoint.protocol],
        secure    = SECURE_PROTOCOLS.indexOf(endpoint.protocol) >= 0,
        onConnect = function() { self._onConnect() },
        originTLS = options.tls || {},
        socketTLS = proxy.origin ? (proxy.tls || {}) : originTLS,
        self      = this;
  
    originTLS.ca = originTLS.ca || options.ca;
  
    this._stream = secure
                 ? tls.connect(port, endpoint.hostname, socketTLS, onConnect)
                 : net.connect(port, endpoint.hostname, onConnect);
  
    if (proxy.origin) this._configureProxy(proxy, originTLS);
  
    API.call(this, options);
  };
  util.inherits(Client, API);
  
  Client.prototype._onConnect = function() {
    var worker = this._proxy || this._driver;
    worker.start();
  };
  
  Client.prototype._configureProxy = function(proxy, originTLS) {
    var uri    = url.parse(this.url),
        secure = SECURE_PROTOCOLS.indexOf(uri.protocol) >= 0,
        self   = this,
        name;
  
    this._proxy = this._driver.proxy(proxy.origin);
  
    if (proxy.headers) {
      for (name in proxy.headers) this._proxy.setHeader(name, proxy.headers[name]);
    }
  
    this._proxy.pipe(this._stream, {end: false});
    this._stream.pipe(this._proxy);
  
    this._proxy.on('connect', function() {
      if (secure) {
        var options = {socket: self._stream, servername: uri.hostname};
        for (name in originTLS) options[name] = originTLS[name];
        self._stream = tls.connect(options);
        self._configureStream();
      }
      self._driver.io.pipe(self._stream);
      self._stream.pipe(self._driver.io);
      self._driver.start();
    });
  
    this._proxy.on('error', function(error) {
      self._driver.emit('error', error);
    });
  };
  
  module.exports = Client;
  
  
  /***/ }),
  /* 40 */
  /***/ (function(module, exports) {
  
  module.exports = require("net");
  
  /***/ }),
  /* 41 */
  /***/ (function(module, exports) {
  
  module.exports = require("tls");
  
  /***/ }),
  /* 42 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var Stream      = __webpack_require__(5).Stream,
      util        = __webpack_require__(0),
      driver      = __webpack_require__(4),
      Headers     = __webpack_require__(9),
      API         = __webpack_require__(11),
      EventTarget = __webpack_require__(16),
      Event       = __webpack_require__(7);
  
  var EventSource = function(request, response, options) {
    this.writable = true;
    options = options || {};
  
    this._stream = response.socket;
    this._ping   = options.ping  || this.DEFAULT_PING;
    this._retry  = options.retry || this.DEFAULT_RETRY;
  
    var scheme       = driver.isSecureRequest(request) ? 'https:' : 'http:';
    this.url         = scheme + '//' + request.headers.host + request.url;
    this.lastEventId = request.headers['last-event-id'] || '';
    this.readyState  = API.CONNECTING;
  
    var headers = new Headers(),
        self    = this;
  
    if (options.headers) {
      for (var key in options.headers) headers.set(key, options.headers[key]);
    }
  
    if (!this._stream || !this._stream.writable) return;
    process.nextTick(function() { self._open() });
  
    this._stream.setTimeout(0);
    this._stream.setNoDelay(true);
  
    var handshake = 'HTTP/1.1 200 OK\r\n' +
                    'Content-Type: text/event-stream\r\n' +
                    'Cache-Control: no-cache, no-store\r\n' +
                    'Connection: close\r\n' +
                    headers.toString() +
                    '\r\n' +
                    'retry: ' + Math.floor(this._retry * 1000) + '\r\n\r\n';
  
    this._write(handshake);
  
    this._stream.on('drain', function() { self.emit('drain') });
  
    if (this._ping)
      this._pingTimer = setInterval(function() { self.ping() }, this._ping * 1000);
  
    ['error', 'end'].forEach(function(event) {
      self._stream.on(event, function() { self.close() });
    });
  };
  util.inherits(EventSource, Stream);
  
  EventSource.isEventSource = function(request) {
    if (request.method !== 'GET') return false;
    var accept = (request.headers.accept || '').split(/\s*,\s*/);
    return accept.indexOf('text/event-stream') >= 0;
  };
  
  var instance = {
    DEFAULT_PING:   10,
    DEFAULT_RETRY:  5,
  
    _write: function(chunk) {
      if (!this.writable) return false;
      try {
        return this._stream.write(chunk, 'utf8');
      } catch (e) {
        return false;
      }
    },
  
    _open: function() {
      if (this.readyState !== API.CONNECTING) return;
  
      this.readyState = API.OPEN;
  
      var event = new Event('open');
      event.initEvent('open', false, false);
      this.dispatchEvent(event);
    },
  
    write: function(message) {
      return this.send(message);
    },
  
    end: function(message) {
      if (message !== undefined) this.write(message);
      this.close();
    },
  
    send: function(message, options) {
      if (this.readyState > API.OPEN) return false;
  
      message = String(message).replace(/(\r\n|\r|\n)/g, '$1data: ');
      options = options || {};
  
      var frame = '';
      if (options.event) frame += 'event: ' + options.event + '\r\n';
      if (options.id)    frame += 'id: '    + options.id    + '\r\n';
      frame += 'data: ' + message + '\r\n\r\n';
  
      return this._write(frame);
    },
  
    ping: function() {
      return this._write(':\r\n\r\n');
    },
  
    close: function() {
      if (this.readyState > API.OPEN) return false;
  
      this.readyState = API.CLOSED;
      this.writable = false;
      if (this._pingTimer) clearInterval(this._pingTimer);
      if (this._stream) this._stream.end();
  
      var event = new Event('close');
      event.initEvent('close', false, false);
      this.dispatchEvent(event);
  
      return true;
    }
  };
  
  for (var method in instance) EventSource.prototype[method] = instance[method];
  for (var key in EventTarget) EventSource.prototype[key] = EventTarget[key];
  
  module.exports = EventSource;
  
  
  /***/ }),
  /* 43 */
  /***/ (function(module, exports) {
  
  module.exports = require("child_process");
  
  /***/ }),
  /* 44 */
  /***/ (function(module, exports) {
  
  module.exports = require("fs");
  
  /***/ }),
  /* 45 */
  /***/ (function(module, exports) {
  
  module.exports = require("http");
  
  /***/ }),
  /* 46 */
  /***/ (function(module, exports) {
  
  module.exports = require("https");
  
  /***/ }),
  /* 47 */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  
  // CONCATENATED MODULE: ./src/core/base64.ts
  function encode(s) {
      return btoa(utob(s));
  }
  var fromCharCode = String.fromCharCode;
  var b64chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
  var b64tab = {};
  for (var base64_i = 0, l = b64chars.length; base64_i < l; base64_i++) {
      b64tab[b64chars.charAt(base64_i)] = base64_i;
  }
  var cb_utob = function (c) {
      var cc = c.charCodeAt(0);
      return cc < 0x80
          ? c
          : cc < 0x800
              ? fromCharCode(0xc0 | (cc >>> 6)) + fromCharCode(0x80 | (cc & 0x3f))
              : fromCharCode(0xe0 | ((cc >>> 12) & 0x0f)) +
                  fromCharCode(0x80 | ((cc >>> 6) & 0x3f)) +
                  fromCharCode(0x80 | (cc & 0x3f));
  };
  var utob = function (u) {
      return u.replace(/[^\x00-\x7F]/g, cb_utob);
  };
  var cb_encode = function (ccc) {
      var padlen = [0, 2, 1][ccc.length % 3];
      var ord = (ccc.charCodeAt(0) << 16) |
          ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8) |
          (ccc.length > 2 ? ccc.charCodeAt(2) : 0);
      var chars = [
          b64chars.charAt(ord >>> 18),
          b64chars.charAt((ord >>> 12) & 63),
          padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),
          padlen >= 1 ? '=' : b64chars.charAt(ord & 63)
      ];
      return chars.join('');
  };
  var btoa = global.btoa ||
      function (b) {
          return b.replace(/[\s\S]{1,3}/g, cb_encode);
      };
  
  // CONCATENATED MODULE: ./src/core/utils/timers/abstract_timer.ts
  var Timer = (function () {
      function Timer(set, clear, delay, callback) {
          var _this = this;
          this.clear = clear;
          this.timer = set(function () {
              if (_this.timer) {
                  _this.timer = callback(_this.timer);
              }
          }, delay);
      }
      Timer.prototype.isRunning = function () {
          return this.timer !== null;
      };
      Timer.prototype.ensureAborted = function () {
          if (this.timer) {
              this.clear(this.timer);
              this.timer = null;
          }
      };
      return Timer;
  }());
  /* harmony default export */ var abstract_timer = (Timer);
  
  // CONCATENATED MODULE: ./src/core/utils/timers/index.ts
  var __extends = (undefined && undefined.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  
  function timers_clearTimeout(timer) {
      global.clearTimeout(timer);
  }
  function timers_clearInterval(timer) {
      global.clearInterval(timer);
  }
  var OneOffTimer = (function (_super) {
      __extends(OneOffTimer, _super);
      function OneOffTimer(delay, callback) {
          return _super.call(this, setTimeout, timers_clearTimeout, delay, function (timer) {
              callback();
              return null;
          }) || this;
      }
      return OneOffTimer;
  }(abstract_timer));
  
  var PeriodicTimer = (function (_super) {
      __extends(PeriodicTimer, _super);
      function PeriodicTimer(delay, callback) {
          return _super.call(this, setInterval, timers_clearInterval, delay, function (timer) {
              callback();
              return timer;
          }) || this;
      }
      return PeriodicTimer;
  }(abstract_timer));
  
  
  // CONCATENATED MODULE: ./src/core/util.ts
  
  var Util = {
      now: function () {
          if (Date.now) {
              return Date.now();
          }
          else {
              return new Date().valueOf();
          }
      },
      defer: function (callback) {
          return new OneOffTimer(0, callback);
      },
      method: function (name) {
          var args = [];
          for (var _i = 1; _i < arguments.length; _i++) {
              args[_i - 1] = arguments[_i];
          }
          var boundArguments = Array.prototype.slice.call(arguments, 1);
          return function (object) {
              return object[name].apply(object, boundArguments.concat(arguments));
          };
      }
  };
  /* harmony default export */ var util = (Util);
  
  // CONCATENATED MODULE: ./src/core/utils/collections.ts
  
  
  function extend(target) {
      var sources = [];
      for (var _i = 1; _i < arguments.length; _i++) {
          sources[_i - 1] = arguments[_i];
      }
      for (var i = 0; i < sources.length; i++) {
          var extensions = sources[i];
          for (var property in extensions) {
              if (extensions[property] &&
                  extensions[property].constructor &&
                  extensions[property].constructor === Object) {
                  target[property] = extend(target[property] || {}, extensions[property]);
              }
              else {
                  target[property] = extensions[property];
              }
          }
      }
      return target;
  }
  function stringify() {
      var m = ['Pusher'];
      for (var i = 0; i < arguments.length; i++) {
          if (typeof arguments[i] === 'string') {
              m.push(arguments[i]);
          }
          else {
              m.push(safeJSONStringify(arguments[i]));
          }
      }
      return m.join(' : ');
  }
  function arrayIndexOf(array, item) {
      var nativeIndexOf = Array.prototype.indexOf;
      if (array === null) {
          return -1;
      }
      if (nativeIndexOf && array.indexOf === nativeIndexOf) {
          return array.indexOf(item);
      }
      for (var i = 0, l = array.length; i < l; i++) {
          if (array[i] === item) {
              return i;
          }
      }
      return -1;
  }
  function objectApply(object, f) {
      for (var key in object) {
          if (Object.prototype.hasOwnProperty.call(object, key)) {
              f(object[key], key, object);
          }
      }
  }
  function keys(object) {
      var keys = [];
      objectApply(object, function (_, key) {
          keys.push(key);
      });
      return keys;
  }
  function values(object) {
      var values = [];
      objectApply(object, function (value) {
          values.push(value);
      });
      return values;
  }
  function apply(array, f, context) {
      for (var i = 0; i < array.length; i++) {
          f.call(context || global, array[i], i, array);
      }
  }
  function map(array, f) {
      var result = [];
      for (var i = 0; i < array.length; i++) {
          result.push(f(array[i], i, array, result));
      }
      return result;
  }
  function mapObject(object, f) {
      var result = {};
      objectApply(object, function (value, key) {
          result[key] = f(value);
      });
      return result;
  }
  function filter(array, test) {
      test =
          test ||
              function (value) {
                  return !!value;
              };
      var result = [];
      for (var i = 0; i < array.length; i++) {
          if (test(array[i], i, array, result)) {
              result.push(array[i]);
          }
      }
      return result;
  }
  function filterObject(object, test) {
      var result = {};
      objectApply(object, function (value, key) {
          if ((test && test(value, key, object, result)) || Boolean(value)) {
              result[key] = value;
          }
      });
      return result;
  }
  function flatten(object) {
      var result = [];
      objectApply(object, function (value, key) {
          result.push([key, value]);
      });
      return result;
  }
  function any(array, test) {
      for (var i = 0; i < array.length; i++) {
          if (test(array[i], i, array)) {
              return true;
          }
      }
      return false;
  }
  function collections_all(array, test) {
      for (var i = 0; i < array.length; i++) {
          if (!test(array[i], i, array)) {
              return false;
          }
      }
      return true;
  }
  function encodeParamsObject(data) {
      return mapObject(data, function (value) {
          if (typeof value === 'object') {
              value = safeJSONStringify(value);
          }
          return encodeURIComponent(encode(value.toString()));
      });
  }
  function buildQueryString(data) {
      var params = filterObject(data, function (value) {
          return value !== undefined;
      });
      var query = map(flatten(encodeParamsObject(params)), util.method('join', '=')).join('&');
      return query;
  }
  function decycleObject(object) {
      var objects = [], paths = [];
      return (function derez(value, path) {
          var i, name, nu;
          switch (typeof value) {
              case 'object':
                  if (!value) {
                      return null;
                  }
                  for (i = 0; i < objects.length; i += 1) {
                      if (objects[i] === value) {
                          return { $ref: paths[i] };
                      }
                  }
                  objects.push(value);
                  paths.push(path);
                  if (Object.prototype.toString.apply(value) === '[object Array]') {
                      nu = [];
                      for (i = 0; i < value.length; i += 1) {
                          nu[i] = derez(value[i], path + '[' + i + ']');
                      }
                  }
                  else {
                      nu = {};
                      for (name in value) {
                          if (Object.prototype.hasOwnProperty.call(value, name)) {
                              nu[name] = derez(value[name], path + '[' + JSON.stringify(name) + ']');
                          }
                      }
                  }
                  return nu;
              case 'number':
              case 'string':
              case 'boolean':
                  return value;
          }
      })(object, '$');
  }
  function safeJSONStringify(source) {
      try {
          return JSON.stringify(source);
      }
      catch (e) {
          return JSON.stringify(decycleObject(source));
      }
  }
  
  // CONCATENATED MODULE: ./src/core/defaults.ts
  var Defaults = {
      VERSION: "7.0.2",
      PROTOCOL: 7,
      wsPort: 80,
      wssPort: 443,
      wsPath: '',
      httpHost: 'sockjs.pusher.com',
      httpPort: 80,
      httpsPort: 443,
      httpPath: '/pusher',
      stats_host: 'stats.pusher.com',
      authEndpoint: '/pusher/auth',
      authTransport: 'ajax',
      activityTimeout: 120000,
      pongTimeout: 30000,
      unavailableTimeout: 10000,
      cluster: 'mt1',
      cdn_http: "http://js.pusher.com",
      cdn_https: "https://js.pusher.com",
      dependency_suffix: ""
  };
  /* harmony default export */ var defaults = (Defaults);
  
  // CONCATENATED MODULE: ./src/core/transports/url_schemes.ts
  
  function getGenericURL(baseScheme, params, path) {
      var scheme = baseScheme + (params.useTLS ? 's' : '');
      var host = params.useTLS ? params.hostTLS : params.hostNonTLS;
      return scheme + '://' + host + path;
  }
  function getGenericPath(key, queryString) {
      var path = '/app/' + key;
      var query = '?protocol=' +
          defaults.PROTOCOL +
          '&client=js' +
          '&version=' +
          defaults.VERSION +
          (queryString ? '&' + queryString : '');
      return path + query;
  }
  var ws = {
      getInitial: function (key, params) {
          var path = (params.httpPath || '') + getGenericPath(key, 'flash=false');
          return getGenericURL('ws', params, path);
      }
  };
  var http = {
      getInitial: function (key, params) {
          var path = (params.httpPath || '/pusher') + getGenericPath(key);
          return getGenericURL('http', params, path);
      }
  };
  var sockjs = {
      getInitial: function (key, params) {
          return getGenericURL('http', params, params.httpPath || '/pusher');
      },
      getPath: function (key, params) {
          return getGenericPath(key);
      }
  };
  
  // CONCATENATED MODULE: ./src/core/events/callback_registry.ts
  
  var callback_registry_CallbackRegistry = (function () {
      function CallbackRegistry() {
          this._callbacks = {};
      }
      CallbackRegistry.prototype.get = function (name) {
          return this._callbacks[prefix(name)];
      };
      CallbackRegistry.prototype.add = function (name, callback, context) {
          var prefixedEventName = prefix(name);
          this._callbacks[prefixedEventName] =
              this._callbacks[prefixedEventName] || [];
          this._callbacks[prefixedEventName].push({
              fn: callback,
              context: context
          });
      };
      CallbackRegistry.prototype.remove = function (name, callback, context) {
          if (!name && !callback && !context) {
              this._callbacks = {};
              return;
          }
          var names = name ? [prefix(name)] : keys(this._callbacks);
          if (callback || context) {
              this.removeCallback(names, callback, context);
          }
          else {
              this.removeAllCallbacks(names);
          }
      };
      CallbackRegistry.prototype.removeCallback = function (names, callback, context) {
          apply(names, function (name) {
              this._callbacks[name] = filter(this._callbacks[name] || [], function (binding) {
                  return ((callback && callback !== binding.fn) ||
                      (context && context !== binding.context));
              });
              if (this._callbacks[name].length === 0) {
                  delete this._callbacks[name];
              }
          }, this);
      };
      CallbackRegistry.prototype.removeAllCallbacks = function (names) {
          apply(names, function (name) {
              delete this._callbacks[name];
          }, this);
      };
      return CallbackRegistry;
  }());
  /* harmony default export */ var callback_registry = (callback_registry_CallbackRegistry);
  function prefix(name) {
      return '_' + name;
  }
  
  // CONCATENATED MODULE: ./src/core/events/dispatcher.ts
  
  
  var dispatcher_Dispatcher = (function () {
      function Dispatcher(failThrough) {
          this.callbacks = new callback_registry();
          this.global_callbacks = [];
          this.failThrough = failThrough;
      }
      Dispatcher.prototype.bind = function (eventName, callback, context) {
          this.callbacks.add(eventName, callback, context);
          return this;
      };
      Dispatcher.prototype.bind_global = function (callback) {
          this.global_callbacks.push(callback);
          return this;
      };
      Dispatcher.prototype.unbind = function (eventName, callback, context) {
          this.callbacks.remove(eventName, callback, context);
          return this;
      };
      Dispatcher.prototype.unbind_global = function (callback) {
          if (!callback) {
              this.global_callbacks = [];
              return this;
          }
          this.global_callbacks = filter(this.global_callbacks || [], function (c) { return c !== callback; });
          return this;
      };
      Dispatcher.prototype.unbind_all = function () {
          this.unbind();
          this.unbind_global();
          return this;
      };
      Dispatcher.prototype.emit = function (eventName, data, metadata) {
          for (var i = 0; i < this.global_callbacks.length; i++) {
              this.global_callbacks[i](eventName, data);
          }
          var callbacks = this.callbacks.get(eventName);
          var args = [];
          if (metadata) {
              args.push(data, metadata);
          }
          else if (data) {
              args.push(data);
          }
          if (callbacks && callbacks.length > 0) {
              for (var i = 0; i < callbacks.length; i++) {
                  callbacks[i].fn.apply(callbacks[i].context || global, args);
              }
          }
          else if (this.failThrough) {
              this.failThrough(eventName, data);
          }
          return this;
      };
      return Dispatcher;
  }());
  /* harmony default export */ var dispatcher = (dispatcher_Dispatcher);
  
  // CONCATENATED MODULE: ./src/core/logger.ts
  
  
  var logger_Logger = (function () {
      function Logger() {
          this.globalLog = function (message) {
              if (global.console && global.console.log) {
                  global.console.log(message);
              }
          };
      }
      Logger.prototype.debug = function () {
          var args = [];
          for (var _i = 0; _i < arguments.length; _i++) {
              args[_i] = arguments[_i];
          }
          this.log(this.globalLog, args);
      };
      Logger.prototype.warn = function () {
          var args = [];
          for (var _i = 0; _i < arguments.length; _i++) {
              args[_i] = arguments[_i];
          }
          this.log(this.globalLogWarn, args);
      };
      Logger.prototype.error = function () {
          var args = [];
          for (var _i = 0; _i < arguments.length; _i++) {
              args[_i] = arguments[_i];
          }
          this.log(this.globalLogError, args);
      };
      Logger.prototype.globalLogWarn = function (message) {
          if (global.console && global.console.warn) {
              global.console.warn(message);
          }
          else {
              this.globalLog(message);
          }
      };
      Logger.prototype.globalLogError = function (message) {
          if (global.console && global.console.error) {
              global.console.error(message);
          }
          else {
              this.globalLogWarn(message);
          }
      };
      Logger.prototype.log = function (defaultLoggingFunction) {
          var args = [];
          for (var _i = 1; _i < arguments.length; _i++) {
              args[_i - 1] = arguments[_i];
          }
          var message = stringify.apply(this, arguments);
          if (core_pusher.log) {
              core_pusher.log(message);
          }
          else if (core_pusher.logToConsole) {
              var log = defaultLoggingFunction.bind(this);
              log(message);
          }
      };
      return Logger;
  }());
  /* harmony default export */ var logger = (new logger_Logger());
  
  // CONCATENATED MODULE: ./src/core/transports/transport_connection.ts
  var transport_connection_extends = (undefined && undefined.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  
  
  
  
  
  var transport_connection_TransportConnection = (function (_super) {
      transport_connection_extends(TransportConnection, _super);
      function TransportConnection(hooks, name, priority, key, options) {
          var _this = _super.call(this) || this;
          _this.initialize = node_runtime.transportConnectionInitializer;
          _this.hooks = hooks;
          _this.name = name;
          _this.priority = priority;
          _this.key = key;
          _this.options = options;
          _this.state = 'new';
          _this.timeline = options.timeline;
          _this.activityTimeout = options.activityTimeout;
          _this.id = _this.timeline.generateUniqueID();
          return _this;
      }
      TransportConnection.prototype.handlesActivityChecks = function () {
          return Boolean(this.hooks.handlesActivityChecks);
      };
      TransportConnection.prototype.supportsPing = function () {
          return Boolean(this.hooks.supportsPing);
      };
      TransportConnection.prototype.connect = function () {
          var _this = this;
          if (this.socket || this.state !== 'initialized') {
              return false;
          }
          var url = this.hooks.urls.getInitial(this.key, this.options);
          try {
              this.socket = this.hooks.getSocket(url, this.options);
          }
          catch (e) {
              util.defer(function () {
                  _this.onError(e);
                  _this.changeState('closed');
              });
              return false;
          }
          this.bindListeners();
          logger.debug('Connecting', { transport: this.name, url: url });
          this.changeState('connecting');
          return true;
      };
      TransportConnection.prototype.close = function () {
          if (this.socket) {
              this.socket.close();
              return true;
          }
          else {
              return false;
          }
      };
      TransportConnection.prototype.send = function (data) {
          var _this = this;
          if (this.state === 'open') {
              util.defer(function () {
                  if (_this.socket) {
                      _this.socket.send(data);
                  }
              });
              return true;
          }
          else {
              return false;
          }
      };
      TransportConnection.prototype.ping = function () {
          if (this.state === 'open' && this.supportsPing()) {
              this.socket.ping();
          }
      };
      TransportConnection.prototype.onOpen = function () {
          if (this.hooks.beforeOpen) {
              this.hooks.beforeOpen(this.socket, this.hooks.urls.getPath(this.key, this.options));
          }
          this.changeState('open');
          this.socket.onopen = undefined;
      };
      TransportConnection.prototype.onError = function (error) {
          this.emit('error', { type: 'WebSocketError', error: error });
          this.timeline.error(this.buildTimelineMessage({ error: error.toString() }));
      };
      TransportConnection.prototype.onClose = function (closeEvent) {
          if (closeEvent) {
              this.changeState('closed', {
                  code: closeEvent.code,
                  reason: closeEvent.reason,
                  wasClean: closeEvent.wasClean
              });
          }
          else {
              this.changeState('closed');
          }
          this.unbindListeners();
          this.socket = undefined;
      };
      TransportConnection.prototype.onMessage = function (message) {
          this.emit('message', message);
      };
      TransportConnection.prototype.onActivity = function () {
          this.emit('activity');
      };
      TransportConnection.prototype.bindListeners = function () {
          var _this = this;
          this.socket.onopen = function () {
              _this.onOpen();
          };
          this.socket.onerror = function (error) {
              _this.onError(error);
          };
          this.socket.onclose = function (closeEvent) {
              _this.onClose(closeEvent);
          };
          this.socket.onmessage = function (message) {
              _this.onMessage(message);
          };
          if (this.supportsPing()) {
              this.socket.onactivity = function () {
                  _this.onActivity();
              };
          }
      };
      TransportConnection.prototype.unbindListeners = function () {
          if (this.socket) {
              this.socket.onopen = undefined;
              this.socket.onerror = undefined;
              this.socket.onclose = undefined;
              this.socket.onmessage = undefined;
              if (this.supportsPing()) {
                  this.socket.onactivity = undefined;
              }
          }
      };
      TransportConnection.prototype.changeState = function (state, params) {
          this.state = state;
          this.timeline.info(this.buildTimelineMessage({
              state: state,
              params: params
          }));
          this.emit(state, params);
      };
      TransportConnection.prototype.buildTimelineMessage = function (message) {
          return extend({ cid: this.id }, message);
      };
      return TransportConnection;
  }(dispatcher));
  /* harmony default export */ var transport_connection = (transport_connection_TransportConnection);
  
  // CONCATENATED MODULE: ./src/core/transports/transport.ts
  
  var transport_Transport = (function () {
      function Transport(hooks) {
          this.hooks = hooks;
      }
      Transport.prototype.isSupported = function (environment) {
          return this.hooks.isSupported(environment);
      };
      Transport.prototype.createConnection = function (name, priority, key, options) {
          return new transport_connection(this.hooks, name, priority, key, options);
      };
      return Transport;
  }());
  /* harmony default export */ var transports_transport = (transport_Transport);
  
  // CONCATENATED MODULE: ./src/runtimes/isomorphic/transports/transports.ts
  
  
  
  
  var WSTransport = new transports_transport({
      urls: ws,
      handlesActivityChecks: false,
      supportsPing: false,
      isInitialized: function () {
          return Boolean(node_runtime.getWebSocketAPI());
      },
      isSupported: function () {
          return Boolean(node_runtime.getWebSocketAPI());
      },
      getSocket: function (url) {
          return node_runtime.createWebSocket(url);
      }
  });
  var httpConfiguration = {
      urls: http,
      handlesActivityChecks: false,
      supportsPing: true,
      isInitialized: function () {
          return true;
      }
  };
  var streamingConfiguration = extend({
      getSocket: function (url) {
          return node_runtime.HTTPFactory.createStreamingSocket(url);
      }
  }, httpConfiguration);
  var pollingConfiguration = extend({
      getSocket: function (url) {
          return node_runtime.HTTPFactory.createPollingSocket(url);
      }
  }, httpConfiguration);
  var xhrConfiguration = {
      isSupported: function () {
          return node_runtime.isXHRSupported();
      }
  };
  var XHRStreamingTransport = new transports_transport((extend({}, streamingConfiguration, xhrConfiguration)));
  var XHRPollingTransport = new transports_transport(extend({}, pollingConfiguration, xhrConfiguration));
  var Transports = {
      ws: WSTransport,
      xhr_streaming: XHRStreamingTransport,
      xhr_polling: XHRPollingTransport
  };
  /* harmony default export */ var transports = (Transports);
  
  // CONCATENATED MODULE: ./src/core/transports/assistant_to_the_transport_manager.ts
  
  
  var assistant_to_the_transport_manager_AssistantToTheTransportManager = (function () {
      function AssistantToTheTransportManager(manager, transport, options) {
          this.manager = manager;
          this.transport = transport;
          this.minPingDelay = options.minPingDelay;
          this.maxPingDelay = options.maxPingDelay;
          this.pingDelay = undefined;
      }
      AssistantToTheTransportManager.prototype.createConnection = function (name, priority, key, options) {
          var _this = this;
          options = extend({}, options, {
              activityTimeout: this.pingDelay
          });
          var connection = this.transport.createConnection(name, priority, key, options);
          var openTimestamp = null;
          var onOpen = function () {
              connection.unbind('open', onOpen);
              connection.bind('closed', onClosed);
              openTimestamp = util.now();
          };
          var onClosed = function (closeEvent) {
              connection.unbind('closed', onClosed);
              if (closeEvent.code === 1002 || closeEvent.code === 1003) {
                  _this.manager.reportDeath();
              }
              else if (!closeEvent.wasClean && openTimestamp) {
                  var lifespan = util.now() - openTimestamp;
                  if (lifespan < 2 * _this.maxPingDelay) {
                      _this.manager.reportDeath();
                      _this.pingDelay = Math.max(lifespan / 2, _this.minPingDelay);
                  }
              }
          };
          connection.bind('open', onOpen);
          return connection;
      };
      AssistantToTheTransportManager.prototype.isSupported = function (environment) {
          return this.manager.isAlive() && this.transport.isSupported(environment);
      };
      return AssistantToTheTransportManager;
  }());
  /* harmony default export */ var assistant_to_the_transport_manager = (assistant_to_the_transport_manager_AssistantToTheTransportManager);
  
  // CONCATENATED MODULE: ./src/core/connection/protocol/protocol.ts
  var Protocol = {
      decodeMessage: function (messageEvent) {
          try {
              var messageData = JSON.parse(messageEvent.data);
              var pusherEventData = messageData.data;
              if (typeof pusherEventData === 'string') {
                  try {
                      pusherEventData = JSON.parse(messageData.data);
                  }
                  catch (e) { }
              }
              var pusherEvent = {
                  event: messageData.event,
                  channel: messageData.channel,
                  data: pusherEventData
              };
              if (messageData.user_id) {
                  pusherEvent.user_id = messageData.user_id;
              }
              return pusherEvent;
          }
          catch (e) {
              throw { type: 'MessageParseError', error: e, data: messageEvent.data };
          }
      },
      encodeMessage: function (event) {
          return JSON.stringify(event);
      },
      processHandshake: function (messageEvent) {
          var message = Protocol.decodeMessage(messageEvent);
          if (message.event === 'pusher:connection_established') {
              if (!message.data.activity_timeout) {
                  throw 'No activity timeout specified in handshake';
              }
              return {
                  action: 'connected',
                  id: message.data.socket_id,
                  activityTimeout: message.data.activity_timeout * 1000
              };
          }
          else if (message.event === 'pusher:error') {
              return {
                  action: this.getCloseAction(message.data),
                  error: this.getCloseError(message.data)
              };
          }
          else {
              throw 'Invalid handshake';
          }
      },
      getCloseAction: function (closeEvent) {
          if (closeEvent.code < 4000) {
              if (closeEvent.code >= 1002 && closeEvent.code <= 1004) {
                  return 'backoff';
              }
              else {
                  return null;
              }
          }
          else if (closeEvent.code === 4000) {
              return 'tls_only';
          }
          else if (closeEvent.code < 4100) {
              return 'refused';
          }
          else if (closeEvent.code < 4200) {
              return 'backoff';
          }
          else if (closeEvent.code < 4300) {
              return 'retry';
          }
          else {
              return 'refused';
          }
      },
      getCloseError: function (closeEvent) {
          if (closeEvent.code !== 1000 && closeEvent.code !== 1001) {
              return {
                  type: 'PusherError',
                  data: {
                      code: closeEvent.code,
                      message: closeEvent.reason || closeEvent.message
                  }
              };
          }
          else {
              return null;
          }
      }
  };
  /* harmony default export */ var protocol = (Protocol);
  
  // CONCATENATED MODULE: ./src/core/connection/connection.ts
  var connection_extends = (undefined && undefined.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  
  
  
  
  var connection_Connection = (function (_super) {
      connection_extends(Connection, _super);
      function Connection(id, transport) {
          var _this = _super.call(this) || this;
          _this.id = id;
          _this.transport = transport;
          _this.activityTimeout = transport.activityTimeout;
          _this.bindListeners();
          return _this;
      }
      Connection.prototype.handlesActivityChecks = function () {
          return this.transport.handlesActivityChecks();
      };
      Connection.prototype.send = function (data) {
          return this.transport.send(data);
      };
      Connection.prototype.send_event = function (name, data, channel) {
          var event = { event: name, data: data };
          if (channel) {
              event.channel = channel;
          }
          logger.debug('Event sent', event);
          return this.send(protocol.encodeMessage(event));
      };
      Connection.prototype.ping = function () {
          if (this.transport.supportsPing()) {
              this.transport.ping();
          }
          else {
              this.send_event('pusher:ping', {});
          }
      };
      Connection.prototype.close = function () {
          this.transport.close();
      };
      Connection.prototype.bindListeners = function () {
          var _this = this;
          var listeners = {
              message: function (messageEvent) {
                  var pusherEvent;
                  try {
                      pusherEvent = protocol.decodeMessage(messageEvent);
                  }
                  catch (e) {
                      _this.emit('error', {
                          type: 'MessageParseError',
                          error: e,
                          data: messageEvent.data
                      });
                  }
                  if (pusherEvent !== undefined) {
                      logger.debug('Event recd', pusherEvent);
                      switch (pusherEvent.event) {
                          case 'pusher:error':
                              _this.emit('error', {
                                  type: 'PusherError',
                                  data: pusherEvent.data
                              });
                              break;
                          case 'pusher:ping':
                              _this.emit('ping');
                              break;
                          case 'pusher:pong':
                              _this.emit('pong');
                              break;
                      }
                      _this.emit('message', pusherEvent);
                  }
              },
              activity: function () {
                  _this.emit('activity');
              },
              error: function (error) {
                  _this.emit('error', error);
              },
              closed: function (closeEvent) {
                  unbindListeners();
                  if (closeEvent && closeEvent.code) {
                      _this.handleCloseEvent(closeEvent);
                  }
                  _this.transport = null;
                  _this.emit('closed');
              }
          };
          var unbindListeners = function () {
              objectApply(listeners, function (listener, event) {
                  _this.transport.unbind(event, listener);
              });
          };
          objectApply(listeners, function (listener, event) {
              _this.transport.bind(event, listener);
          });
      };
      Connection.prototype.handleCloseEvent = function (closeEvent) {
          var action = protocol.getCloseAction(closeEvent);
          var error = protocol.getCloseError(closeEvent);
          if (error) {
              this.emit('error', error);
          }
          if (action) {
              this.emit(action, { action: action, error: error });
          }
      };
      return Connection;
  }(dispatcher));
  /* harmony default export */ var connection_connection = (connection_Connection);
  
  // CONCATENATED MODULE: ./src/core/connection/handshake/index.ts
  
  
  
  var handshake_Handshake = (function () {
      function Handshake(transport, callback) {
          this.transport = transport;
          this.callback = callback;
          this.bindListeners();
      }
      Handshake.prototype.close = function () {
          this.unbindListeners();
          this.transport.close();
      };
      Handshake.prototype.bindListeners = function () {
          var _this = this;
          this.onMessage = function (m) {
              _this.unbindListeners();
              var result;
              try {
                  result = protocol.processHandshake(m);
              }
              catch (e) {
                  _this.finish('error', { error: e });
                  _this.transport.close();
                  return;
              }
              if (result.action === 'connected') {
                  _this.finish('connected', {
                      connection: new connection_connection(result.id, _this.transport),
                      activityTimeout: result.activityTimeout
                  });
              }
              else {
                  _this.finish(result.action, { error: result.error });
                  _this.transport.close();
              }
          };
          this.onClosed = function (closeEvent) {
              _this.unbindListeners();
              var action = protocol.getCloseAction(closeEvent) || 'backoff';
              var error = protocol.getCloseError(closeEvent);
              _this.finish(action, { error: error });
          };
          this.transport.bind('message', this.onMessage);
          this.transport.bind('closed', this.onClosed);
      };
      Handshake.prototype.unbindListeners = function () {
          this.transport.unbind('message', this.onMessage);
          this.transport.unbind('closed', this.onClosed);
      };
      Handshake.prototype.finish = function (action, params) {
          this.callback(extend({ transport: this.transport, action: action }, params));
      };
      return Handshake;
  }());
  /* harmony default export */ var connection_handshake = (handshake_Handshake);
  
  // CONCATENATED MODULE: ./src/core/auth/pusher_authorizer.ts
  
  var pusher_authorizer_PusherAuthorizer = (function () {
      function PusherAuthorizer(channel, options) {
          this.channel = channel;
          var authTransport = options.authTransport;
          if (typeof node_runtime.getAuthorizers()[authTransport] === 'undefined') {
              throw "'" + authTransport + "' is not a recognized auth transport";
          }
          this.type = authTransport;
          this.options = options;
          this.authOptions = options.auth || {};
      }
      PusherAuthorizer.prototype.composeQuery = function (socketId) {
          var query = 'socket_id=' +
              encodeURIComponent(socketId) +
              '&channel_name=' +
              encodeURIComponent(this.channel.name);
          for (var i in this.authOptions.params) {
              query +=
                  '&' +
                      encodeURIComponent(i) +
                      '=' +
                      encodeURIComponent(this.authOptions.params[i]);
          }
          return query;
      };
      PusherAuthorizer.prototype.authorize = function (socketId, callback) {
          PusherAuthorizer.authorizers =
              PusherAuthorizer.authorizers || node_runtime.getAuthorizers();
          PusherAuthorizer.authorizers[this.type].call(this, node_runtime, socketId, callback);
      };
      return PusherAuthorizer;
  }());
  /* harmony default export */ var pusher_authorizer = (pusher_authorizer_PusherAuthorizer);
  
  // CONCATENATED MODULE: ./src/core/timeline/timeline_sender.ts
  
  var timeline_sender_TimelineSender = (function () {
      function TimelineSender(timeline, options) {
          this.timeline = timeline;
          this.options = options || {};
      }
      TimelineSender.prototype.send = function (useTLS, callback) {
          if (this.timeline.isEmpty()) {
              return;
          }
          this.timeline.send(node_runtime.TimelineTransport.getAgent(this, useTLS), callback);
      };
      return TimelineSender;
  }());
  /* harmony default export */ var timeline_sender = (timeline_sender_TimelineSender);
  
  // CONCATENATED MODULE: ./src/core/errors.ts
  var errors_extends = (undefined && undefined.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  var BadEventName = (function (_super) {
      errors_extends(BadEventName, _super);
      function BadEventName(msg) {
          var _newTarget = this.constructor;
          var _this = _super.call(this, msg) || this;
          Object.setPrototypeOf(_this, _newTarget.prototype);
          return _this;
      }
      return BadEventName;
  }(Error));
  
  var RequestTimedOut = (function (_super) {
      errors_extends(RequestTimedOut, _super);
      function RequestTimedOut(msg) {
          var _newTarget = this.constructor;
          var _this = _super.call(this, msg) || this;
          Object.setPrototypeOf(_this, _newTarget.prototype);
          return _this;
      }
      return RequestTimedOut;
  }(Error));
  
  var TransportPriorityTooLow = (function (_super) {
      errors_extends(TransportPriorityTooLow, _super);
      function TransportPriorityTooLow(msg) {
          var _newTarget = this.constructor;
          var _this = _super.call(this, msg) || this;
          Object.setPrototypeOf(_this, _newTarget.prototype);
          return _this;
      }
      return TransportPriorityTooLow;
  }(Error));
  
  var TransportClosed = (function (_super) {
      errors_extends(TransportClosed, _super);
      function TransportClosed(msg) {
          var _newTarget = this.constructor;
          var _this = _super.call(this, msg) || this;
          Object.setPrototypeOf(_this, _newTarget.prototype);
          return _this;
      }
      return TransportClosed;
  }(Error));
  
  var UnsupportedFeature = (function (_super) {
      errors_extends(UnsupportedFeature, _super);
      function UnsupportedFeature(msg) {
          var _newTarget = this.constructor;
          var _this = _super.call(this, msg) || this;
          Object.setPrototypeOf(_this, _newTarget.prototype);
          return _this;
      }
      return UnsupportedFeature;
  }(Error));
  
  var UnsupportedTransport = (function (_super) {
      errors_extends(UnsupportedTransport, _super);
      function UnsupportedTransport(msg) {
          var _newTarget = this.constructor;
          var _this = _super.call(this, msg) || this;
          Object.setPrototypeOf(_this, _newTarget.prototype);
          return _this;
      }
      return UnsupportedTransport;
  }(Error));
  
  var UnsupportedStrategy = (function (_super) {
      errors_extends(UnsupportedStrategy, _super);
      function UnsupportedStrategy(msg) {
          var _newTarget = this.constructor;
          var _this = _super.call(this, msg) || this;
          Object.setPrototypeOf(_this, _newTarget.prototype);
          return _this;
      }
      return UnsupportedStrategy;
  }(Error));
  
  var HTTPAuthError = (function (_super) {
      errors_extends(HTTPAuthError, _super);
      function HTTPAuthError(status, msg) {
          var _newTarget = this.constructor;
          var _this = _super.call(this, msg) || this;
          _this.status = status;
          Object.setPrototypeOf(_this, _newTarget.prototype);
          return _this;
      }
      return HTTPAuthError;
  }(Error));
  
  
  // CONCATENATED MODULE: ./src/core/utils/url_store.ts
  var urlStore = {
      baseUrl: 'https://pusher.com',
      urls: {
          authenticationEndpoint: {
              path: '/docs/authenticating_users'
          },
          javascriptQuickStart: {
              path: '/docs/javascript_quick_start'
          },
          triggeringClientEvents: {
              path: '/docs/client_api_guide/client_events#trigger-events'
          },
          encryptedChannelSupport: {
              fullUrl: 'https://github.com/pusher/pusher-js/tree/cc491015371a4bde5743d1c87a0fbac0feb53195#encrypted-channel-support'
          }
      }
  };
  var buildLogSuffix = function (key) {
      var urlPrefix = 'See:';
      var urlObj = urlStore.urls[key];
      if (!urlObj)
          return '';
      var url;
      if (urlObj.fullUrl) {
          url = urlObj.fullUrl;
      }
      else if (urlObj.path) {
          url = urlStore.baseUrl + urlObj.path;
      }
      if (!url)
          return '';
      return urlPrefix + " " + url;
  };
  /* harmony default export */ var url_store = ({ buildLogSuffix: buildLogSuffix });
  
  // CONCATENATED MODULE: ./src/core/channels/channel.ts
  var channel_extends = (undefined && undefined.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  
  
  
  
  
  var channel_Channel = (function (_super) {
      channel_extends(Channel, _super);
      function Channel(name, pusher) {
          var _this = _super.call(this, function (event, data) {
              logger.debug('No callbacks on ' + name + ' for ' + event);
          }) || this;
          _this.name = name;
          _this.pusher = pusher;
          _this.subscribed = false;
          _this.subscriptionPending = false;
          _this.subscriptionCancelled = false;
          return _this;
      }
      Channel.prototype.authorize = function (socketId, callback) {
          return callback(null, { auth: '' });
      };
      Channel.prototype.trigger = function (event, data) {
          if (event.indexOf('client-') !== 0) {
              throw new BadEventName("Event '" + event + "' does not start with 'client-'");
          }
          if (!this.subscribed) {
              var suffix = url_store.buildLogSuffix('triggeringClientEvents');
              logger.warn("Client event triggered before channel 'subscription_succeeded' event . " + suffix);
          }
          return this.pusher.send_event(event, data, this.name);
      };
      Channel.prototype.disconnect = function () {
          this.subscribed = false;
          this.subscriptionPending = false;
      };
      Channel.prototype.handleEvent = function (event) {
          var eventName = event.event;
          var data = event.data;
          if (eventName === 'pusher_internal:subscription_succeeded') {
              this.handleSubscriptionSucceededEvent(event);
          }
          else if (eventName.indexOf('pusher_internal:') !== 0) {
              var metadata = {};
              this.emit(eventName, data, metadata);
          }
      };
      Channel.prototype.handleSubscriptionSucceededEvent = function (event) {
          this.subscriptionPending = false;
          this.subscribed = true;
          if (this.subscriptionCancelled) {
              this.pusher.unsubscribe(this.name);
          }
          else {
              this.emit('pusher:subscription_succeeded', event.data);
          }
      };
      Channel.prototype.subscribe = function () {
          var _this = this;
          if (this.subscribed) {
              return;
          }
          this.subscriptionPending = true;
          this.subscriptionCancelled = false;
          this.authorize(this.pusher.connection.socket_id, function (error, data) {
              if (error) {
                  _this.subscriptionPending = false;
                  logger.error(error.toString());
                  _this.emit('pusher:subscription_error', Object.assign({}, {
                      type: 'AuthError',
                      error: error.message
                  }, error instanceof HTTPAuthError ? { status: error.status } : {}));
              }
              else {
                  _this.pusher.send_event('pusher:subscribe', {
                      auth: data.auth,
                      channel_data: data.channel_data,
                      channel: _this.name
                  });
              }
          });
      };
      Channel.prototype.unsubscribe = function () {
          this.subscribed = false;
          this.pusher.send_event('pusher:unsubscribe', {
              channel: this.name
          });
      };
      Channel.prototype.cancelSubscription = function () {
          this.subscriptionCancelled = true;
      };
      Channel.prototype.reinstateSubscription = function () {
          this.subscriptionCancelled = false;
      };
      return Channel;
  }(dispatcher));
  /* harmony default export */ var channels_channel = (channel_Channel);
  
  // CONCATENATED MODULE: ./src/core/channels/private_channel.ts
  var private_channel_extends = (undefined && undefined.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  
  
  var private_channel_PrivateChannel = (function (_super) {
      private_channel_extends(PrivateChannel, _super);
      function PrivateChannel() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      PrivateChannel.prototype.authorize = function (socketId, callback) {
          var authorizer = factory.createAuthorizer(this, this.pusher.config);
          return authorizer.authorize(socketId, callback);
      };
      return PrivateChannel;
  }(channels_channel));
  /* harmony default export */ var private_channel = (private_channel_PrivateChannel);
  
  // CONCATENATED MODULE: ./src/core/channels/members.ts
  
  var members_Members = (function () {
      function Members() {
          this.reset();
      }
      Members.prototype.get = function (id) {
          if (Object.prototype.hasOwnProperty.call(this.members, id)) {
              return {
                  id: id,
                  info: this.members[id]
              };
          }
          else {
              return null;
          }
      };
      Members.prototype.each = function (callback) {
          var _this = this;
          objectApply(this.members, function (member, id) {
              callback(_this.get(id));
          });
      };
      Members.prototype.setMyID = function (id) {
          this.myID = id;
      };
      Members.prototype.onSubscription = function (subscriptionData) {
          this.members = subscriptionData.presence.hash;
          this.count = subscriptionData.presence.count;
          this.me = this.get(this.myID);
      };
      Members.prototype.addMember = function (memberData) {
          if (this.get(memberData.user_id) === null) {
              this.count++;
          }
          this.members[memberData.user_id] = memberData.user_info;
          return this.get(memberData.user_id);
      };
      Members.prototype.removeMember = function (memberData) {
          var member = this.get(memberData.user_id);
          if (member) {
              delete this.members[memberData.user_id];
              this.count--;
          }
          return member;
      };
      Members.prototype.reset = function () {
          this.members = {};
          this.count = 0;
          this.myID = null;
          this.me = null;
      };
      return Members;
  }());
  /* harmony default export */ var members = (members_Members);
  
  // CONCATENATED MODULE: ./src/core/channels/presence_channel.ts
  var presence_channel_extends = (undefined && undefined.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  
  
  
  
  var presence_channel_PresenceChannel = (function (_super) {
      presence_channel_extends(PresenceChannel, _super);
      function PresenceChannel(name, pusher) {
          var _this = _super.call(this, name, pusher) || this;
          _this.members = new members();
          return _this;
      }
      PresenceChannel.prototype.authorize = function (socketId, callback) {
          var _this = this;
          _super.prototype.authorize.call(this, socketId, function (error, authData) {
              if (!error) {
                  authData = authData;
                  if (authData.channel_data === undefined) {
                      var suffix = url_store.buildLogSuffix('authenticationEndpoint');
                      logger.error("Invalid auth response for channel '" + _this.name + "'," +
                          ("expected 'channel_data' field. " + suffix));
                      callback('Invalid auth response');
                      return;
                  }
                  var channelData = JSON.parse(authData.channel_data);
                  _this.members.setMyID(channelData.user_id);
              }
              callback(error, authData);
          });
      };
      PresenceChannel.prototype.handleEvent = function (event) {
          var eventName = event.event;
          if (eventName.indexOf('pusher_internal:') === 0) {
              this.handleInternalEvent(event);
          }
          else {
              var data = event.data;
              var metadata = {};
              if (event.user_id) {
                  metadata.user_id = event.user_id;
              }
              this.emit(eventName, data, metadata);
          }
      };
      PresenceChannel.prototype.handleInternalEvent = function (event) {
          var eventName = event.event;
          var data = event.data;
          switch (eventName) {
              case 'pusher_internal:subscription_succeeded':
                  this.handleSubscriptionSucceededEvent(event);
                  break;
              case 'pusher_internal:member_added':
                  var addedMember = this.members.addMember(data);
                  this.emit('pusher:member_added', addedMember);
                  break;
              case 'pusher_internal:member_removed':
                  var removedMember = this.members.removeMember(data);
                  if (removedMember) {
                      this.emit('pusher:member_removed', removedMember);
                  }
                  break;
          }
      };
      PresenceChannel.prototype.handleSubscriptionSucceededEvent = function (event) {
          this.subscriptionPending = false;
          this.subscribed = true;
          if (this.subscriptionCancelled) {
              this.pusher.unsubscribe(this.name);
          }
          else {
              this.members.onSubscription(event.data);
              this.emit('pusher:subscription_succeeded', this.members);
          }
      };
      PresenceChannel.prototype.disconnect = function () {
          this.members.reset();
          _super.prototype.disconnect.call(this);
      };
      return PresenceChannel;
  }(private_channel));
  /* harmony default export */ var presence_channel = (presence_channel_PresenceChannel);
  
  // EXTERNAL MODULE: ./node_modules/@stablelib/utf8/lib/utf8.js
  var utf8 = __webpack_require__(17);
  
  // EXTERNAL MODULE: ./node_modules/@stablelib/base64/lib/base64.js
  var base64 = __webpack_require__(8);
  
  // CONCATENATED MODULE: ./src/core/channels/encrypted_channel.ts
  var encrypted_channel_extends = (undefined && undefined.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  
  
  
  
  
  var encrypted_channel_EncryptedChannel = (function (_super) {
      encrypted_channel_extends(EncryptedChannel, _super);
      function EncryptedChannel(name, pusher, nacl) {
          var _this = _super.call(this, name, pusher) || this;
          _this.key = null;
          _this.nacl = nacl;
          return _this;
      }
      EncryptedChannel.prototype.authorize = function (socketId, callback) {
          var _this = this;
          _super.prototype.authorize.call(this, socketId, function (error, authData) {
              if (error) {
                  callback(error, authData);
                  return;
              }
              var sharedSecret = authData['shared_secret'];
              if (!sharedSecret) {
                  callback(new Error("No shared_secret key in auth payload for encrypted channel: " + _this.name), null);
                  return;
              }
              _this.key = Object(base64["decode"])(sharedSecret);
              delete authData['shared_secret'];
              callback(null, authData);
          });
      };
      EncryptedChannel.prototype.trigger = function (event, data) {
          throw new UnsupportedFeature('Client events are not currently supported for encrypted channels');
      };
      EncryptedChannel.prototype.handleEvent = function (event) {
          var eventName = event.event;
          var data = event.data;
          if (eventName.indexOf('pusher_internal:') === 0 ||
              eventName.indexOf('pusher:') === 0) {
              _super.prototype.handleEvent.call(this, event);
              return;
          }
          this.handleEncryptedEvent(eventName, data);
      };
      EncryptedChannel.prototype.handleEncryptedEvent = function (event, data) {
          var _this = this;
          if (!this.key) {
              logger.debug('Received encrypted event before key has been retrieved from the authEndpoint');
              return;
          }
          if (!data.ciphertext || !data.nonce) {
              logger.error('Unexpected format for encrypted event, expected object with `ciphertext` and `nonce` fields, got: ' +
                  data);
              return;
          }
          var cipherText = Object(base64["decode"])(data.ciphertext);
          if (cipherText.length < this.nacl.secretbox.overheadLength) {
              logger.error("Expected encrypted event ciphertext length to be " + this.nacl.secretbox.overheadLength + ", got: " + cipherText.length);
              return;
          }
          var nonce = Object(base64["decode"])(data.nonce);
          if (nonce.length < this.nacl.secretbox.nonceLength) {
              logger.error("Expected encrypted event nonce length to be " + this.nacl.secretbox.nonceLength + ", got: " + nonce.length);
              return;
          }
          var bytes = this.nacl.secretbox.open(cipherText, nonce, this.key);
          if (bytes === null) {
              logger.debug('Failed to decrypt an event, probably because it was encrypted with a different key. Fetching a new key from the authEndpoint...');
              this.authorize(this.pusher.connection.socket_id, function (error, authData) {
                  if (error) {
                      logger.error("Failed to make a request to the authEndpoint: " + authData + ". Unable to fetch new key, so dropping encrypted event");
                      return;
                  }
                  bytes = _this.nacl.secretbox.open(cipherText, nonce, _this.key);
                  if (bytes === null) {
                      logger.error("Failed to decrypt event with new key. Dropping encrypted event");
                      return;
                  }
                  _this.emit(event, _this.getDataToEmit(bytes));
                  return;
              });
              return;
          }
          this.emit(event, this.getDataToEmit(bytes));
      };
      EncryptedChannel.prototype.getDataToEmit = function (bytes) {
          var raw = Object(utf8["decode"])(bytes);
          try {
              return JSON.parse(raw);
          }
          catch (_a) {
              return raw;
          }
      };
      return EncryptedChannel;
  }(private_channel));
  /* harmony default export */ var encrypted_channel = (encrypted_channel_EncryptedChannel);
  
  // CONCATENATED MODULE: ./src/core/connection/connection_manager.ts
  var connection_manager_extends = (undefined && undefined.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  
  
  
  
  
  var connection_manager_ConnectionManager = (function (_super) {
      connection_manager_extends(ConnectionManager, _super);
      function ConnectionManager(key, options) {
          var _this = _super.call(this) || this;
          _this.state = 'initialized';
          _this.connection = null;
          _this.key = key;
          _this.options = options;
          _this.timeline = _this.options.timeline;
          _this.usingTLS = _this.options.useTLS;
          _this.errorCallbacks = _this.buildErrorCallbacks();
          _this.connectionCallbacks = _this.buildConnectionCallbacks(_this.errorCallbacks);
          _this.handshakeCallbacks = _this.buildHandshakeCallbacks(_this.errorCallbacks);
          var Network = node_runtime.getNetwork();
          Network.bind('online', function () {
              _this.timeline.info({ netinfo: 'online' });
              if (_this.state === 'connecting' || _this.state === 'unavailable') {
                  _this.retryIn(0);
              }
          });
          Network.bind('offline', function () {
              _this.timeline.info({ netinfo: 'offline' });
              if (_this.connection) {
                  _this.sendActivityCheck();
              }
          });
          _this.updateStrategy();
          return _this;
      }
      ConnectionManager.prototype.connect = function () {
          if (this.connection || this.runner) {
              return;
          }
          if (!this.strategy.isSupported()) {
              this.updateState('failed');
              return;
          }
          this.updateState('connecting');
          this.startConnecting();
          this.setUnavailableTimer();
      };
      ConnectionManager.prototype.send = function (data) {
          if (this.connection) {
              return this.connection.send(data);
          }
          else {
              return false;
          }
      };
      ConnectionManager.prototype.send_event = function (name, data, channel) {
          if (this.connection) {
              return this.connection.send_event(name, data, channel);
          }
          else {
              return false;
          }
      };
      ConnectionManager.prototype.disconnect = function () {
          this.disconnectInternally();
          this.updateState('disconnected');
      };
      ConnectionManager.prototype.isUsingTLS = function () {
          return this.usingTLS;
      };
      ConnectionManager.prototype.startConnecting = function () {
          var _this = this;
          var callback = function (error, handshake) {
              if (error) {
                  _this.runner = _this.strategy.connect(0, callback);
              }
              else {
                  if (handshake.action === 'error') {
                      _this.emit('error', {
                          type: 'HandshakeError',
                          error: handshake.error
                      });
                      _this.timeline.error({ handshakeError: handshake.error });
                  }
                  else {
                      _this.abortConnecting();
                      _this.handshakeCallbacks[handshake.action](handshake);
                  }
              }
          };
          this.runner = this.strategy.connect(0, callback);
      };
      ConnectionManager.prototype.abortConnecting = function () {
          if (this.runner) {
              this.runner.abort();
              this.runner = null;
          }
      };
      ConnectionManager.prototype.disconnectInternally = function () {
          this.abortConnecting();
          this.clearRetryTimer();
          this.clearUnavailableTimer();
          if (this.connection) {
              var connection = this.abandonConnection();
              connection.close();
          }
      };
      ConnectionManager.prototype.updateStrategy = function () {
          this.strategy = this.options.getStrategy({
              key: this.key,
              timeline: this.timeline,
              useTLS: this.usingTLS
          });
      };
      ConnectionManager.prototype.retryIn = function (delay) {
          var _this = this;
          this.timeline.info({ action: 'retry', delay: delay });
          if (delay > 0) {
              this.emit('connecting_in', Math.round(delay / 1000));
          }
          this.retryTimer = new OneOffTimer(delay || 0, function () {
              _this.disconnectInternally();
              _this.connect();
          });
      };
      ConnectionManager.prototype.clearRetryTimer = function () {
          if (this.retryTimer) {
              this.retryTimer.ensureAborted();
              this.retryTimer = null;
          }
      };
      ConnectionManager.prototype.setUnavailableTimer = function () {
          var _this = this;
          this.unavailableTimer = new OneOffTimer(this.options.unavailableTimeout, function () {
              _this.updateState('unavailable');
          });
      };
      ConnectionManager.prototype.clearUnavailableTimer = function () {
          if (this.unavailableTimer) {
              this.unavailableTimer.ensureAborted();
          }
      };
      ConnectionManager.prototype.sendActivityCheck = function () {
          var _this = this;
          this.stopActivityCheck();
          this.connection.ping();
          this.activityTimer = new OneOffTimer(this.options.pongTimeout, function () {
              _this.timeline.error({ pong_timed_out: _this.options.pongTimeout });
              _this.retryIn(0);
          });
      };
      ConnectionManager.prototype.resetActivityCheck = function () {
          var _this = this;
          this.stopActivityCheck();
          if (this.connection && !this.connection.handlesActivityChecks()) {
              this.activityTimer = new OneOffTimer(this.activityTimeout, function () {
                  _this.sendActivityCheck();
              });
          }
      };
      ConnectionManager.prototype.stopActivityCheck = function () {
          if (this.activityTimer) {
              this.activityTimer.ensureAborted();
          }
      };
      ConnectionManager.prototype.buildConnectionCallbacks = function (errorCallbacks) {
          var _this = this;
          return extend({}, errorCallbacks, {
              message: function (message) {
                  _this.resetActivityCheck();
                  _this.emit('message', message);
              },
              ping: function () {
                  _this.send_event('pusher:pong', {});
              },
              activity: function () {
                  _this.resetActivityCheck();
              },
              error: function (error) {
                  _this.emit('error', error);
              },
              closed: function () {
                  _this.abandonConnection();
                  if (_this.shouldRetry()) {
                      _this.retryIn(1000);
                  }
              }
          });
      };
      ConnectionManager.prototype.buildHandshakeCallbacks = function (errorCallbacks) {
          var _this = this;
          return extend({}, errorCallbacks, {
              connected: function (handshake) {
                  _this.activityTimeout = Math.min(_this.options.activityTimeout, handshake.activityTimeout, handshake.connection.activityTimeout || Infinity);
                  _this.clearUnavailableTimer();
                  _this.setConnection(handshake.connection);
                  _this.socket_id = _this.connection.id;
                  _this.updateState('connected', { socket_id: _this.socket_id });
              }
          });
      };
      ConnectionManager.prototype.buildErrorCallbacks = function () {
          var _this = this;
          var withErrorEmitted = function (callback) {
              return function (result) {
                  if (result.error) {
                      _this.emit('error', { type: 'WebSocketError', error: result.error });
                  }
                  callback(result);
              };
          };
          return {
              tls_only: withErrorEmitted(function () {
                  _this.usingTLS = true;
                  _this.updateStrategy();
                  _this.retryIn(0);
              }),
              refused: withErrorEmitted(function () {
                  _this.disconnect();
              }),
              backoff: withErrorEmitted(function () {
                  _this.retryIn(1000);
              }),
              retry: withErrorEmitted(function () {
                  _this.retryIn(0);
              })
          };
      };
      ConnectionManager.prototype.setConnection = function (connection) {
          this.connection = connection;
          for (var event in this.connectionCallbacks) {
              this.connection.bind(event, this.connectionCallbacks[event]);
          }
          this.resetActivityCheck();
      };
      ConnectionManager.prototype.abandonConnection = function () {
          if (!this.connection) {
              return;
          }
          this.stopActivityCheck();
          for (var event in this.connectionCallbacks) {
              this.connection.unbind(event, this.connectionCallbacks[event]);
          }
          var connection = this.connection;
          this.connection = null;
          return connection;
      };
      ConnectionManager.prototype.updateState = function (newState, data) {
          var previousState = this.state;
          this.state = newState;
          if (previousState !== newState) {
              var newStateDescription = newState;
              if (newStateDescription === 'connected') {
                  newStateDescription += ' with new socket ID ' + data.socket_id;
              }
              logger.debug('State changed', previousState + ' -> ' + newStateDescription);
              this.timeline.info({ state: newState, params: data });
              this.emit('state_change', { previous: previousState, current: newState });
              this.emit(newState, data);
          }
      };
      ConnectionManager.prototype.shouldRetry = function () {
          return this.state === 'connecting' || this.state === 'connected';
      };
      return ConnectionManager;
  }(dispatcher));
  /* harmony default export */ var connection_manager = (connection_manager_ConnectionManager);
  
  // CONCATENATED MODULE: ./src/core/channels/channels.ts
  
  
  
  
  var channels_Channels = (function () {
      function Channels() {
          this.channels = {};
      }
      Channels.prototype.add = function (name, pusher) {
          if (!this.channels[name]) {
              this.channels[name] = createChannel(name, pusher);
          }
          return this.channels[name];
      };
      Channels.prototype.all = function () {
          return values(this.channels);
      };
      Channels.prototype.find = function (name) {
          return this.channels[name];
      };
      Channels.prototype.remove = function (name) {
          var channel = this.channels[name];
          delete this.channels[name];
          return channel;
      };
      Channels.prototype.disconnect = function () {
          objectApply(this.channels, function (channel) {
              channel.disconnect();
          });
      };
      return Channels;
  }());
  /* harmony default export */ var channels = (channels_Channels);
  function createChannel(name, pusher) {
      if (name.indexOf('private-encrypted-') === 0) {
          if (pusher.config.nacl) {
              return factory.createEncryptedChannel(name, pusher, pusher.config.nacl);
          }
          var errMsg = 'Tried to subscribe to a private-encrypted- channel but no nacl implementation available';
          var suffix = url_store.buildLogSuffix('encryptedChannelSupport');
          throw new UnsupportedFeature(errMsg + ". " + suffix);
      }
      else if (name.indexOf('private-') === 0) {
          return factory.createPrivateChannel(name, pusher);
      }
      else if (name.indexOf('presence-') === 0) {
          return factory.createPresenceChannel(name, pusher);
      }
      else {
          return factory.createChannel(name, pusher);
      }
  }
  
  // CONCATENATED MODULE: ./src/core/utils/factory.ts
  
  
  
  
  
  
  
  
  
  
  var Factory = {
      createChannels: function () {
          return new channels();
      },
      createConnectionManager: function (key, options) {
          return new connection_manager(key, options);
      },
      createChannel: function (name, pusher) {
          return new channels_channel(name, pusher);
      },
      createPrivateChannel: function (name, pusher) {
          return new private_channel(name, pusher);
      },
      createPresenceChannel: function (name, pusher) {
          return new presence_channel(name, pusher);
      },
      createEncryptedChannel: function (name, pusher, nacl) {
          return new encrypted_channel(name, pusher, nacl);
      },
      createTimelineSender: function (timeline, options) {
          return new timeline_sender(timeline, options);
      },
      createAuthorizer: function (channel, options) {
          if (options.authorizer) {
              return options.authorizer(channel, options);
          }
          return new pusher_authorizer(channel, options);
      },
      createHandshake: function (transport, callback) {
          return new connection_handshake(transport, callback);
      },
      createAssistantToTheTransportManager: function (manager, transport, options) {
          return new assistant_to_the_transport_manager(manager, transport, options);
      }
  };
  /* harmony default export */ var factory = (Factory);
  
  // CONCATENATED MODULE: ./src/core/transports/transport_manager.ts
  
  var transport_manager_TransportManager = (function () {
      function TransportManager(options) {
          this.options = options || {};
          this.livesLeft = this.options.lives || Infinity;
      }
      TransportManager.prototype.getAssistant = function (transport) {
          return factory.createAssistantToTheTransportManager(this, transport, {
              minPingDelay: this.options.minPingDelay,
              maxPingDelay: this.options.maxPingDelay
          });
      };
      TransportManager.prototype.isAlive = function () {
          return this.livesLeft > 0;
      };
      TransportManager.prototype.reportDeath = function () {
          this.livesLeft -= 1;
      };
      return TransportManager;
  }());
  /* harmony default export */ var transport_manager = (transport_manager_TransportManager);
  
  // CONCATENATED MODULE: ./src/core/strategies/sequential_strategy.ts
  
  
  
  var sequential_strategy_SequentialStrategy = (function () {
      function SequentialStrategy(strategies, options) {
          this.strategies = strategies;
          this.loop = Boolean(options.loop);
          this.failFast = Boolean(options.failFast);
          this.timeout = options.timeout;
          this.timeoutLimit = options.timeoutLimit;
      }
      SequentialStrategy.prototype.isSupported = function () {
          return any(this.strategies, util.method('isSupported'));
      };
      SequentialStrategy.prototype.connect = function (minPriority, callback) {
          var _this = this;
          var strategies = this.strategies;
          var current = 0;
          var timeout = this.timeout;
          var runner = null;
          var tryNextStrategy = function (error, handshake) {
              if (handshake) {
                  callback(null, handshake);
              }
              else {
                  current = current + 1;
                  if (_this.loop) {
                      current = current % strategies.length;
                  }
                  if (current < strategies.length) {
                      if (timeout) {
                          timeout = timeout * 2;
                          if (_this.timeoutLimit) {
                              timeout = Math.min(timeout, _this.timeoutLimit);
                          }
                      }
                      runner = _this.tryStrategy(strategies[current], minPriority, { timeout: timeout, failFast: _this.failFast }, tryNextStrategy);
                  }
                  else {
                      callback(true);
                  }
              }
          };
          runner = this.tryStrategy(strategies[current], minPriority, { timeout: timeout, failFast: this.failFast }, tryNextStrategy);
          return {
              abort: function () {
                  runner.abort();
              },
              forceMinPriority: function (p) {
                  minPriority = p;
                  if (runner) {
                      runner.forceMinPriority(p);
                  }
              }
          };
      };
      SequentialStrategy.prototype.tryStrategy = function (strategy, minPriority, options, callback) {
          var timer = null;
          var runner = null;
          if (options.timeout > 0) {
              timer = new OneOffTimer(options.timeout, function () {
                  runner.abort();
                  callback(true);
              });
          }
          runner = strategy.connect(minPriority, function (error, handshake) {
              if (error && timer && timer.isRunning() && !options.failFast) {
                  return;
              }
              if (timer) {
                  timer.ensureAborted();
              }
              callback(error, handshake);
          });
          return {
              abort: function () {
                  if (timer) {
                      timer.ensureAborted();
                  }
                  runner.abort();
              },
              forceMinPriority: function (p) {
                  runner.forceMinPriority(p);
              }
          };
      };
      return SequentialStrategy;
  }());
  /* harmony default export */ var sequential_strategy = (sequential_strategy_SequentialStrategy);
  
  // CONCATENATED MODULE: ./src/core/strategies/best_connected_ever_strategy.ts
  
  
  var best_connected_ever_strategy_BestConnectedEverStrategy = (function () {
      function BestConnectedEverStrategy(strategies) {
          this.strategies = strategies;
      }
      BestConnectedEverStrategy.prototype.isSupported = function () {
          return any(this.strategies, util.method('isSupported'));
      };
      BestConnectedEverStrategy.prototype.connect = function (minPriority, callback) {
          return connect(this.strategies, minPriority, function (i, runners) {
              return function (error, handshake) {
                  runners[i].error = error;
                  if (error) {
                      if (allRunnersFailed(runners)) {
                          callback(true);
                      }
                      return;
                  }
                  apply(runners, function (runner) {
                      runner.forceMinPriority(handshake.transport.priority);
                  });
                  callback(null, handshake);
              };
          });
      };
      return BestConnectedEverStrategy;
  }());
  /* harmony default export */ var best_connected_ever_strategy = (best_connected_ever_strategy_BestConnectedEverStrategy);
  function connect(strategies, minPriority, callbackBuilder) {
      var runners = map(strategies, function (strategy, i, _, rs) {
          return strategy.connect(minPriority, callbackBuilder(i, rs));
      });
      return {
          abort: function () {
              apply(runners, abortRunner);
          },
          forceMinPriority: function (p) {
              apply(runners, function (runner) {
                  runner.forceMinPriority(p);
              });
          }
      };
  }
  function allRunnersFailed(runners) {
      return collections_all(runners, function (runner) {
          return Boolean(runner.error);
      });
  }
  function abortRunner(runner) {
      if (!runner.error && !runner.aborted) {
          runner.abort();
          runner.aborted = true;
      }
  }
  
  // CONCATENATED MODULE: ./src/core/strategies/cached_strategy.ts
  
  
  
  
  var cached_strategy_CachedStrategy = (function () {
      function CachedStrategy(strategy, transports, options) {
          this.strategy = strategy;
          this.transports = transports;
          this.ttl = options.ttl || 1800 * 1000;
          this.usingTLS = options.useTLS;
          this.timeline = options.timeline;
      }
      CachedStrategy.prototype.isSupported = function () {
          return this.strategy.isSupported();
      };
      CachedStrategy.prototype.connect = function (minPriority, callback) {
          var usingTLS = this.usingTLS;
          var info = fetchTransportCache(usingTLS);
          var strategies = [this.strategy];
          if (info && info.timestamp + this.ttl >= util.now()) {
              var transport = this.transports[info.transport];
              if (transport) {
                  this.timeline.info({
                      cached: true,
                      transport: info.transport,
                      latency: info.latency
                  });
                  strategies.push(new sequential_strategy([transport], {
                      timeout: info.latency * 2 + 1000,
                      failFast: true
                  }));
              }
          }
          var startTimestamp = util.now();
          var runner = strategies
              .pop()
              .connect(minPriority, function cb(error, handshake) {
              if (error) {
                  flushTransportCache(usingTLS);
                  if (strategies.length > 0) {
                      startTimestamp = util.now();
                      runner = strategies.pop().connect(minPriority, cb);
                  }
                  else {
                      callback(error);
                  }
              }
              else {
                  storeTransportCache(usingTLS, handshake.transport.name, util.now() - startTimestamp);
                  callback(null, handshake);
              }
          });
          return {
              abort: function () {
                  runner.abort();
              },
              forceMinPriority: function (p) {
                  minPriority = p;
                  if (runner) {
                      runner.forceMinPriority(p);
                  }
              }
          };
      };
      return CachedStrategy;
  }());
  /* harmony default export */ var cached_strategy = (cached_strategy_CachedStrategy);
  function getTransportCacheKey(usingTLS) {
      return 'pusherTransport' + (usingTLS ? 'TLS' : 'NonTLS');
  }
  function fetchTransportCache(usingTLS) {
      var storage = node_runtime.getLocalStorage();
      if (storage) {
          try {
              var serializedCache = storage[getTransportCacheKey(usingTLS)];
              if (serializedCache) {
                  return JSON.parse(serializedCache);
              }
          }
          catch (e) {
              flushTransportCache(usingTLS);
          }
      }
      return null;
  }
  function storeTransportCache(usingTLS, transport, latency) {
      var storage = node_runtime.getLocalStorage();
      if (storage) {
          try {
              storage[getTransportCacheKey(usingTLS)] = safeJSONStringify({
                  timestamp: util.now(),
                  transport: transport,
                  latency: latency
              });
          }
          catch (e) {
          }
      }
  }
  function flushTransportCache(usingTLS) {
      var storage = node_runtime.getLocalStorage();
      if (storage) {
          try {
              delete storage[getTransportCacheKey(usingTLS)];
          }
          catch (e) {
          }
      }
  }
  
  // CONCATENATED MODULE: ./src/core/strategies/delayed_strategy.ts
  
  var delayed_strategy_DelayedStrategy = (function () {
      function DelayedStrategy(strategy, _a) {
          var number = _a.delay;
          this.strategy = strategy;
          this.options = { delay: number };
      }
      DelayedStrategy.prototype.isSupported = function () {
          return this.strategy.isSupported();
      };
      DelayedStrategy.prototype.connect = function (minPriority, callback) {
          var strategy = this.strategy;
          var runner;
          var timer = new OneOffTimer(this.options.delay, function () {
              runner = strategy.connect(minPriority, callback);
          });
          return {
              abort: function () {
                  timer.ensureAborted();
                  if (runner) {
                      runner.abort();
                  }
              },
              forceMinPriority: function (p) {
                  minPriority = p;
                  if (runner) {
                      runner.forceMinPriority(p);
                  }
              }
          };
      };
      return DelayedStrategy;
  }());
  /* harmony default export */ var delayed_strategy = (delayed_strategy_DelayedStrategy);
  
  // CONCATENATED MODULE: ./src/core/strategies/if_strategy.ts
  var IfStrategy = (function () {
      function IfStrategy(test, trueBranch, falseBranch) {
          this.test = test;
          this.trueBranch = trueBranch;
          this.falseBranch = falseBranch;
      }
      IfStrategy.prototype.isSupported = function () {
          var branch = this.test() ? this.trueBranch : this.falseBranch;
          return branch.isSupported();
      };
      IfStrategy.prototype.connect = function (minPriority, callback) {
          var branch = this.test() ? this.trueBranch : this.falseBranch;
          return branch.connect(minPriority, callback);
      };
      return IfStrategy;
  }());
  /* harmony default export */ var if_strategy = (IfStrategy);
  
  // CONCATENATED MODULE: ./src/core/strategies/first_connected_strategy.ts
  var FirstConnectedStrategy = (function () {
      function FirstConnectedStrategy(strategy) {
          this.strategy = strategy;
      }
      FirstConnectedStrategy.prototype.isSupported = function () {
          return this.strategy.isSupported();
      };
      FirstConnectedStrategy.prototype.connect = function (minPriority, callback) {
          var runner = this.strategy.connect(minPriority, function (error, handshake) {
              if (handshake) {
                  runner.abort();
              }
              callback(error, handshake);
          });
          return runner;
      };
      return FirstConnectedStrategy;
  }());
  /* harmony default export */ var first_connected_strategy = (FirstConnectedStrategy);
  
  // CONCATENATED MODULE: ./src/runtimes/isomorphic/default_strategy.ts
  
  
  
  
  
  
  
  
  function testSupportsStrategy(strategy) {
      return function () {
          return strategy.isSupported();
      };
  }
  var getDefaultStrategy = function (config, baseOptions, defineTransport) {
      var definedTransports = {};
      function defineTransportStrategy(name, type, priority, options, manager) {
          var transport = defineTransport(config, name, type, priority, options, manager);
          definedTransports[name] = transport;
          return transport;
      }
      var ws_options = Object.assign({}, baseOptions, {
          hostNonTLS: config.wsHost + ':' + config.wsPort,
          hostTLS: config.wsHost + ':' + config.wssPort,
          httpPath: config.wsPath
      });
      var wss_options = extend({}, ws_options, {
          useTLS: true
      });
      var http_options = Object.assign({}, baseOptions, {
          hostNonTLS: config.httpHost + ':' + config.httpPort,
          hostTLS: config.httpHost + ':' + config.httpsPort,
          httpPath: config.httpPath
      });
      var timeouts = {
          loop: true,
          timeout: 15000,
          timeoutLimit: 60000
      };
      var ws_manager = new transport_manager({
          lives: 2,
          minPingDelay: 10000,
          maxPingDelay: config.activityTimeout
      });
      var streaming_manager = new transport_manager({
          lives: 2,
          minPingDelay: 10000,
          maxPingDelay: config.activityTimeout
      });
      var ws_transport = defineTransportStrategy('ws', 'ws', 3, ws_options, ws_manager);
      var wss_transport = defineTransportStrategy('wss', 'ws', 3, wss_options, ws_manager);
      var xhr_streaming_transport = defineTransportStrategy('xhr_streaming', 'xhr_streaming', 1, http_options, streaming_manager);
      var xhr_polling_transport = defineTransportStrategy('xhr_polling', 'xhr_polling', 1, http_options);
      var ws_loop = new sequential_strategy([ws_transport], timeouts);
      var wss_loop = new sequential_strategy([wss_transport], timeouts);
      var streaming_loop = new sequential_strategy([xhr_streaming_transport], timeouts);
      var polling_loop = new sequential_strategy([xhr_polling_transport], timeouts);
      var http_loop = new sequential_strategy([
          new if_strategy(testSupportsStrategy(streaming_loop), new best_connected_ever_strategy([
              streaming_loop,
              new delayed_strategy(polling_loop, { delay: 4000 })
          ]), polling_loop)
      ], timeouts);
      var wsStrategy;
      if (baseOptions.useTLS) {
          wsStrategy = new best_connected_ever_strategy([
              ws_loop,
              new delayed_strategy(http_loop, { delay: 2000 })
          ]);
      }
      else {
          wsStrategy = new best_connected_ever_strategy([
              ws_loop,
              new delayed_strategy(wss_loop, { delay: 2000 }),
              new delayed_strategy(http_loop, { delay: 5000 })
          ]);
      }
      return new cached_strategy(new first_connected_strategy(new if_strategy(testSupportsStrategy(ws_transport), wsStrategy, http_loop)), definedTransports, {
          ttl: 1800000,
          timeline: baseOptions.timeline,
          useTLS: baseOptions.useTLS
      });
  };
  /* harmony default export */ var default_strategy = (getDefaultStrategy);
  
  // CONCATENATED MODULE: ./src/runtimes/isomorphic/transports/transport_connection_initializer.ts
  /* harmony default export */ var transport_connection_initializer = (function () {
      var self = this;
      self.timeline.info(self.buildTimelineMessage({
          transport: self.name + (self.options.useTLS ? 's' : '')
      }));
      if (self.hooks.isInitialized()) {
          self.changeState('initialized');
      }
      else {
          self.onClose();
      }
  });
  
  // CONCATENATED MODULE: ./src/core/http/http_request.ts
  var http_request_extends = (undefined && undefined.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  
  
  var MAX_BUFFER_LENGTH = 256 * 1024;
  var http_request_HTTPRequest = (function (_super) {
      http_request_extends(HTTPRequest, _super);
      function HTTPRequest(hooks, method, url) {
          var _this = _super.call(this) || this;
          _this.hooks = hooks;
          _this.method = method;
          _this.url = url;
          return _this;
      }
      HTTPRequest.prototype.start = function (payload) {
          var _this = this;
          this.position = 0;
          this.xhr = this.hooks.getRequest(this);
          this.unloader = function () {
              _this.close();
          };
          node_runtime.addUnloadListener(this.unloader);
          this.xhr.open(this.method, this.url, true);
          if (this.xhr.setRequestHeader) {
              this.xhr.setRequestHeader('Content-Type', 'application/json');
          }
          this.xhr.send(payload);
      };
      HTTPRequest.prototype.close = function () {
          if (this.unloader) {
              node_runtime.removeUnloadListener(this.unloader);
              this.unloader = null;
          }
          if (this.xhr) {
              this.hooks.abortRequest(this.xhr);
              this.xhr = null;
          }
      };
      HTTPRequest.prototype.onChunk = function (status, data) {
          while (true) {
              var chunk = this.advanceBuffer(data);
              if (chunk) {
                  this.emit('chunk', { status: status, data: chunk });
              }
              else {
                  break;
              }
          }
          if (this.isBufferTooLong(data)) {
              this.emit('buffer_too_long');
          }
      };
      HTTPRequest.prototype.advanceBuffer = function (buffer) {
          var unreadData = buffer.slice(this.position);
          var endOfLinePosition = unreadData.indexOf('\n');
          if (endOfLinePosition !== -1) {
              this.position += endOfLinePosition + 1;
              return unreadData.slice(0, endOfLinePosition);
          }
          else {
              return null;
          }
      };
      HTTPRequest.prototype.isBufferTooLong = function (buffer) {
          return this.position === buffer.length && buffer.length > MAX_BUFFER_LENGTH;
      };
      return HTTPRequest;
  }(dispatcher));
  /* harmony default export */ var http_request = (http_request_HTTPRequest);
  
  // CONCATENATED MODULE: ./src/core/http/state.ts
  var State;
  (function (State) {
      State[State["CONNECTING"] = 0] = "CONNECTING";
      State[State["OPEN"] = 1] = "OPEN";
      State[State["CLOSED"] = 3] = "CLOSED";
  })(State || (State = {}));
  /* harmony default export */ var state = (State);
  
  // CONCATENATED MODULE: ./src/core/http/http_socket.ts
  
  
  
  var autoIncrement = 1;
  var http_socket_HTTPSocket = (function () {
      function HTTPSocket(hooks, url) {
          this.hooks = hooks;
          this.session = randomNumber(1000) + '/' + randomString(8);
          this.location = getLocation(url);
          this.readyState = state.CONNECTING;
          this.openStream();
      }
      HTTPSocket.prototype.send = function (payload) {
          return this.sendRaw(JSON.stringify([payload]));
      };
      HTTPSocket.prototype.ping = function () {
          this.hooks.sendHeartbeat(this);
      };
      HTTPSocket.prototype.close = function (code, reason) {
          this.onClose(code, reason, true);
      };
      HTTPSocket.prototype.sendRaw = function (payload) {
          if (this.readyState === state.OPEN) {
              try {
                  node_runtime.createSocketRequest('POST', getUniqueURL(getSendURL(this.location, this.session))).start(payload);
                  return true;
              }
              catch (e) {
                  return false;
              }
          }
          else {
              return false;
          }
      };
      HTTPSocket.prototype.reconnect = function () {
          this.closeStream();
          this.openStream();
      };
      HTTPSocket.prototype.onClose = function (code, reason, wasClean) {
          this.closeStream();
          this.readyState = state.CLOSED;
          if (this.onclose) {
              this.onclose({
                  code: code,
                  reason: reason,
                  wasClean: wasClean
              });
          }
      };
      HTTPSocket.prototype.onChunk = function (chunk) {
          if (chunk.status !== 200) {
              return;
          }
          if (this.readyState === state.OPEN) {
              this.onActivity();
          }
          var payload;
          var type = chunk.data.slice(0, 1);
          switch (type) {
              case 'o':
                  payload = JSON.parse(chunk.data.slice(1) || '{}');
                  this.onOpen(payload);
                  break;
              case 'a':
                  payload = JSON.parse(chunk.data.slice(1) || '[]');
                  for (var i = 0; i < payload.length; i++) {
                      this.onEvent(payload[i]);
                  }
                  break;
              case 'm':
                  payload = JSON.parse(chunk.data.slice(1) || 'null');
                  this.onEvent(payload);
                  break;
              case 'h':
                  this.hooks.onHeartbeat(this);
                  break;
              case 'c':
                  payload = JSON.parse(chunk.data.slice(1) || '[]');
                  this.onClose(payload[0], payload[1], true);
                  break;
          }
      };
      HTTPSocket.prototype.onOpen = function (options) {
          if (this.readyState === state.CONNECTING) {
              if (options && options.hostname) {
                  this.location.base = replaceHost(this.location.base, options.hostname);
              }
              this.readyState = state.OPEN;
              if (this.onopen) {
                  this.onopen();
              }
          }
          else {
              this.onClose(1006, 'Server lost session', true);
          }
      };
      HTTPSocket.prototype.onEvent = function (event) {
          if (this.readyState === state.OPEN && this.onmessage) {
              this.onmessage({ data: event });
          }
      };
      HTTPSocket.prototype.onActivity = function () {
          if (this.onactivity) {
              this.onactivity();
          }
      };
      HTTPSocket.prototype.onError = function (error) {
          if (this.onerror) {
              this.onerror(error);
          }
      };
      HTTPSocket.prototype.openStream = function () {
          var _this = this;
          this.stream = node_runtime.createSocketRequest('POST', getUniqueURL(this.hooks.getReceiveURL(this.location, this.session)));
          this.stream.bind('chunk', function (chunk) {
              _this.onChunk(chunk);
          });
          this.stream.bind('finished', function (status) {
              _this.hooks.onFinished(_this, status);
          });
          this.stream.bind('buffer_too_long', function () {
              _this.reconnect();
          });
          try {
              this.stream.start();
          }
          catch (error) {
              util.defer(function () {
                  _this.onError(error);
                  _this.onClose(1006, 'Could not start streaming', false);
              });
          }
      };
      HTTPSocket.prototype.closeStream = function () {
          if (this.stream) {
              this.stream.unbind_all();
              this.stream.close();
              this.stream = null;
          }
      };
      return HTTPSocket;
  }());
  function getLocation(url) {
      var parts = /([^\?]*)\/*(\??.*)/.exec(url);
      return {
          base: parts[1],
          queryString: parts[2]
      };
  }
  function getSendURL(url, session) {
      return url.base + '/' + session + '/xhr_send';
  }
  function getUniqueURL(url) {
      var separator = url.indexOf('?') === -1 ? '?' : '&';
      return url + separator + 't=' + +new Date() + '&n=' + autoIncrement++;
  }
  function replaceHost(url, hostname) {
      var urlParts = /(https?:\/\/)([^\/:]+)((\/|:)?.*)/.exec(url);
      return urlParts[1] + hostname + urlParts[3];
  }
  function randomNumber(max) {
      return Math.floor(Math.random() * max);
  }
  function randomString(length) {
      var result = [];
      for (var i = 0; i < length; i++) {
          result.push(randomNumber(32).toString(32));
      }
      return result.join('');
  }
  /* harmony default export */ var http_socket = (http_socket_HTTPSocket);
  
  // CONCATENATED MODULE: ./src/core/http/http_streaming_socket.ts
  var http_streaming_socket_hooks = {
      getReceiveURL: function (url, session) {
          return url.base + '/' + session + '/xhr_streaming' + url.queryString;
      },
      onHeartbeat: function (socket) {
          socket.sendRaw('[]');
      },
      sendHeartbeat: function (socket) {
          socket.sendRaw('[]');
      },
      onFinished: function (socket, status) {
          socket.onClose(1006, 'Connection interrupted (' + status + ')', false);
      }
  };
  /* harmony default export */ var http_streaming_socket = (http_streaming_socket_hooks);
  
  // CONCATENATED MODULE: ./src/core/http/http_polling_socket.ts
  var http_polling_socket_hooks = {
      getReceiveURL: function (url, session) {
          return url.base + '/' + session + '/xhr' + url.queryString;
      },
      onHeartbeat: function () {
      },
      sendHeartbeat: function (socket) {
          socket.sendRaw('[]');
      },
      onFinished: function (socket, status) {
          if (status === 200) {
              socket.reconnect();
          }
          else {
              socket.onClose(1006, 'Connection interrupted (' + status + ')', false);
          }
      }
  };
  /* harmony default export */ var http_polling_socket = (http_polling_socket_hooks);
  
  // CONCATENATED MODULE: ./src/runtimes/isomorphic/http/http_xhr_request.ts
  
  var http_xhr_request_hooks = {
      getRequest: function (socket) {
          var Constructor = node_runtime.getXHRAPI();
          var xhr = new Constructor();
          xhr.onreadystatechange = xhr.onprogress = function () {
              switch (xhr.readyState) {
                  case 3:
                      if (xhr.responseText && xhr.responseText.length > 0) {
                          socket.onChunk(xhr.status, xhr.responseText);
                      }
                      break;
                  case 4:
                      if (xhr.responseText && xhr.responseText.length > 0) {
                          socket.onChunk(xhr.status, xhr.responseText);
                      }
                      socket.emit('finished', xhr.status);
                      socket.close();
                      break;
              }
          };
          return xhr;
      },
      abortRequest: function (xhr) {
          xhr.onreadystatechange = null;
          xhr.abort();
      }
  };
  /* harmony default export */ var http_xhr_request = (http_xhr_request_hooks);
  
  // CONCATENATED MODULE: ./src/runtimes/isomorphic/http/http.ts
  
  
  
  
  
  var HTTP = {
      createStreamingSocket: function (url) {
          return this.createSocket(http_streaming_socket, url);
      },
      createPollingSocket: function (url) {
          return this.createSocket(http_polling_socket, url);
      },
      createSocket: function (hooks, url) {
          return new http_socket(hooks, url);
      },
      createXHR: function (method, url) {
          return this.createRequest(http_xhr_request, method, url);
      },
      createRequest: function (hooks, method, url) {
          return new http_request(hooks, method, url);
      }
  };
  /* harmony default export */ var http_http = (HTTP);
  
  // CONCATENATED MODULE: ./src/runtimes/isomorphic/runtime.ts
  
  
  
  
  
  var Isomorphic = {
      getDefaultStrategy: default_strategy,
      Transports: transports,
      transportConnectionInitializer: transport_connection_initializer,
      HTTPFactory: http_http,
      setup: function (PusherClass) {
          PusherClass.ready();
      },
      getLocalStorage: function () {
          return undefined;
      },
      getClientFeatures: function () {
          return keys(filterObject({ ws: transports.ws }, function (t) {
              return t.isSupported({});
          }));
      },
      getProtocol: function () {
          return 'http:';
      },
      isXHRSupported: function () {
          return true;
      },
      createSocketRequest: function (method, url) {
          if (this.isXHRSupported()) {
              return this.HTTPFactory.createXHR(method, url);
          }
          else {
              throw 'Cross-origin HTTP requests are not supported';
          }
      },
      createXHR: function () {
          var Constructor = this.getXHRAPI();
          return new Constructor();
      },
      createWebSocket: function (url) {
          var Constructor = this.getWebSocketAPI();
          return new Constructor(url);
      },
      addUnloadListener: function (listener) { },
      removeUnloadListener: function (listener) { }
  };
  /* harmony default export */ var runtime = (Isomorphic);
  
  // EXTERNAL MODULE: ./node_modules/faye-websocket/lib/faye/websocket.js
  var websocket = __webpack_require__(18);
  
  // EXTERNAL MODULE: ./node_modules/xmlhttprequest/lib/XMLHttpRequest.js
  var XMLHttpRequest = __webpack_require__(19);
  
  // CONCATENATED MODULE: ./src/runtimes/node/net_info.ts
  var net_info_extends = (undefined && undefined.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  
  var NetInfo = (function (_super) {
      net_info_extends(NetInfo, _super);
      function NetInfo() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      NetInfo.prototype.isOnline = function () {
          return true;
      };
      return NetInfo;
  }(dispatcher));
  
  var net_info_Network = new NetInfo();
  
  // CONCATENATED MODULE: ./src/runtimes/isomorphic/auth/xhr_auth.ts
  
  
  
  var ajax = function (context, socketId, callback) {
      var self = this, xhr;
      xhr = node_runtime.createXHR();
      xhr.open('POST', self.options.authEndpoint, true);
      xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
      for (var headerName in this.authOptions.headers) {
          xhr.setRequestHeader(headerName, this.authOptions.headers[headerName]);
      }
      xhr.onreadystatechange = function () {
          if (xhr.readyState === 4) {
              if (xhr.status === 200) {
                  var data = void 0;
                  var parsed = false;
                  try {
                      data = JSON.parse(xhr.responseText);
                      parsed = true;
                  }
                  catch (e) {
                      callback(new HTTPAuthError(200, 'JSON returned from auth endpoint was invalid, yet status code was 200. Data was: ' +
                          xhr.responseText), { auth: '' });
                  }
                  if (parsed) {
                      callback(null, data);
                  }
              }
              else {
                  var suffix = url_store.buildLogSuffix('authenticationEndpoint');
                  callback(new HTTPAuthError(xhr.status, 'Unable to retrieve auth string from auth endpoint - ' +
                      ("received status: " + xhr.status + " from " + self.options.authEndpoint + ". ") +
                      ("Clients must be authenticated to join private or presence channels. " + suffix)), { auth: '' });
              }
          }
      };
      xhr.send(this.composeQuery(socketId));
      return xhr;
  };
  /* harmony default export */ var xhr_auth = (ajax);
  
  // CONCATENATED MODULE: ./src/runtimes/isomorphic/timeline/xhr_timeline.ts
  
  
  
  var getAgent = function (sender, useTLS) {
      return function (data, callback) {
          var scheme = 'http' + (useTLS ? 's' : '') + '://';
          var url = scheme + (sender.host || sender.options.host) + sender.options.path;
          var query = buildQueryString(data);
          url += '/' + 2 + '?' + query;
          var xhr = node_runtime.createXHR();
          xhr.open('GET', url, true);
          xhr.onreadystatechange = function () {
              if (xhr.readyState === 4) {
                  var status_1 = xhr.status, responseText = xhr.responseText;
                  if (status_1 !== 200) {
                      logger.debug("TimelineSender Error: received " + status_1 + " from stats.pusher.com");
                      return;
                  }
                  try {
                      var host = JSON.parse(responseText).host;
                  }
                  catch (e) {
                      logger.debug("TimelineSenderError: invalid response " + responseText);
                  }
                  if (host) {
                      sender.host = host;
                  }
              }
          };
          xhr.send();
      };
  };
  var xhr_timeline_xhr = {
      name: 'xhr',
      getAgent: getAgent
  };
  /* harmony default export */ var xhr_timeline = (xhr_timeline_xhr);
  
  // CONCATENATED MODULE: ./src/runtimes/node/runtime.ts
  
  
  
  
  
  
  var runtime_getDefaultStrategy = runtime.getDefaultStrategy, runtime_Transports = runtime.Transports, setup = runtime.setup, getProtocol = runtime.getProtocol, isXHRSupported = runtime.isXHRSupported, getLocalStorage = runtime.getLocalStorage, createXHR = runtime.createXHR, createWebSocket = runtime.createWebSocket, addUnloadListener = runtime.addUnloadListener, removeUnloadListener = runtime.removeUnloadListener, transportConnectionInitializer = runtime.transportConnectionInitializer, createSocketRequest = runtime.createSocketRequest, HTTPFactory = runtime.HTTPFactory;
  var NodeJS = {
      getDefaultStrategy: runtime_getDefaultStrategy,
      Transports: runtime_Transports,
      setup: setup,
      getProtocol: getProtocol,
      isXHRSupported: isXHRSupported,
      createSocketRequest: createSocketRequest,
      getLocalStorage: getLocalStorage,
      createXHR: createXHR,
      createWebSocket: createWebSocket,
      addUnloadListener: addUnloadListener,
      removeUnloadListener: removeUnloadListener,
      transportConnectionInitializer: transportConnectionInitializer,
      HTTPFactory: HTTPFactory,
      TimelineTransport: xhr_timeline,
      getAuthorizers: function () {
          return { ajax: xhr_auth };
      },
      getWebSocketAPI: function () {
          return websocket["Client"];
      },
      getXHRAPI: function () {
          return XMLHttpRequest["XMLHttpRequest"];
      },
      getNetwork: function () {
          return net_info_Network;
      }
  };
  /* harmony default export */ var node_runtime = (NodeJS);
  
  // CONCATENATED MODULE: ./src/core/timeline/level.ts
  var TimelineLevel;
  (function (TimelineLevel) {
      TimelineLevel[TimelineLevel["ERROR"] = 3] = "ERROR";
      TimelineLevel[TimelineLevel["INFO"] = 6] = "INFO";
      TimelineLevel[TimelineLevel["DEBUG"] = 7] = "DEBUG";
  })(TimelineLevel || (TimelineLevel = {}));
  /* harmony default export */ var timeline_level = (TimelineLevel);
  
  // CONCATENATED MODULE: ./src/core/timeline/timeline.ts
  
  
  
  var timeline_Timeline = (function () {
      function Timeline(key, session, options) {
          this.key = key;
          this.session = session;
          this.events = [];
          this.options = options || {};
          this.sent = 0;
          this.uniqueID = 0;
      }
      Timeline.prototype.log = function (level, event) {
          if (level <= this.options.level) {
              this.events.push(extend({}, event, { timestamp: util.now() }));
              if (this.options.limit && this.events.length > this.options.limit) {
                  this.events.shift();
              }
          }
      };
      Timeline.prototype.error = function (event) {
          this.log(timeline_level.ERROR, event);
      };
      Timeline.prototype.info = function (event) {
          this.log(timeline_level.INFO, event);
      };
      Timeline.prototype.debug = function (event) {
          this.log(timeline_level.DEBUG, event);
      };
      Timeline.prototype.isEmpty = function () {
          return this.events.length === 0;
      };
      Timeline.prototype.send = function (sendfn, callback) {
          var _this = this;
          var data = extend({
              session: this.session,
              bundle: this.sent + 1,
              key: this.key,
              lib: 'js',
              version: this.options.version,
              cluster: this.options.cluster,
              features: this.options.features,
              timeline: this.events
          }, this.options.params);
          this.events = [];
          sendfn(data, function (error, result) {
              if (!error) {
                  _this.sent++;
              }
              if (callback) {
                  callback(error, result);
              }
          });
          return true;
      };
      Timeline.prototype.generateUniqueID = function () {
          this.uniqueID++;
          return this.uniqueID;
      };
      return Timeline;
  }());
  /* harmony default export */ var timeline_timeline = (timeline_Timeline);
  
  // CONCATENATED MODULE: ./src/core/strategies/transport_strategy.ts
  
  
  
  
  var transport_strategy_TransportStrategy = (function () {
      function TransportStrategy(name, priority, transport, options) {
          this.name = name;
          this.priority = priority;
          this.transport = transport;
          this.options = options || {};
      }
      TransportStrategy.prototype.isSupported = function () {
          return this.transport.isSupported({
              useTLS: this.options.useTLS
          });
      };
      TransportStrategy.prototype.connect = function (minPriority, callback) {
          var _this = this;
          if (!this.isSupported()) {
              return failAttempt(new UnsupportedStrategy(), callback);
          }
          else if (this.priority < minPriority) {
              return failAttempt(new TransportPriorityTooLow(), callback);
          }
          var connected = false;
          var transport = this.transport.createConnection(this.name, this.priority, this.options.key, this.options);
          var handshake = null;
          var onInitialized = function () {
              transport.unbind('initialized', onInitialized);
              transport.connect();
          };
          var onOpen = function () {
              handshake = factory.createHandshake(transport, function (result) {
                  connected = true;
                  unbindListeners();
                  callback(null, result);
              });
          };
          var onError = function (error) {
              unbindListeners();
              callback(error);
          };
          var onClosed = function () {
              unbindListeners();
              var serializedTransport;
              serializedTransport = safeJSONStringify(transport);
              callback(new TransportClosed(serializedTransport));
          };
          var unbindListeners = function () {
              transport.unbind('initialized', onInitialized);
              transport.unbind('open', onOpen);
              transport.unbind('error', onError);
              transport.unbind('closed', onClosed);
          };
          transport.bind('initialized', onInitialized);
          transport.bind('open', onOpen);
          transport.bind('error', onError);
          transport.bind('closed', onClosed);
          transport.initialize();
          return {
              abort: function () {
                  if (connected) {
                      return;
                  }
                  unbindListeners();
                  if (handshake) {
                      handshake.close();
                  }
                  else {
                      transport.close();
                  }
              },
              forceMinPriority: function (p) {
                  if (connected) {
                      return;
                  }
                  if (_this.priority < p) {
                      if (handshake) {
                          handshake.close();
                      }
                      else {
                          transport.close();
                      }
                  }
              }
          };
      };
      return TransportStrategy;
  }());
  /* harmony default export */ var transport_strategy = (transport_strategy_TransportStrategy);
  function failAttempt(error, callback) {
      util.defer(function () {
          callback(error);
      });
      return {
          abort: function () { },
          forceMinPriority: function () { }
      };
  }
  
  // CONCATENATED MODULE: ./src/core/strategies/strategy_builder.ts
  
  
  
  
  
  var strategy_builder_Transports = node_runtime.Transports;
  var strategy_builder_defineTransport = function (config, name, type, priority, options, manager) {
      var transportClass = strategy_builder_Transports[type];
      if (!transportClass) {
          throw new UnsupportedTransport(type);
      }
      var enabled = (!config.enabledTransports ||
          arrayIndexOf(config.enabledTransports, name) !== -1) &&
          (!config.disabledTransports ||
              arrayIndexOf(config.disabledTransports, name) === -1);
      var transport;
      if (enabled) {
          options = Object.assign({ ignoreNullOrigin: config.ignoreNullOrigin }, options);
          transport = new transport_strategy(name, priority, manager ? manager.getAssistant(transportClass) : transportClass, options);
      }
      else {
          transport = strategy_builder_UnsupportedStrategy;
      }
      return transport;
  };
  var strategy_builder_UnsupportedStrategy = {
      isSupported: function () {
          return false;
      },
      connect: function (_, callback) {
          var deferred = util.defer(function () {
              callback(new UnsupportedStrategy());
          });
          return {
              abort: function () {
                  deferred.ensureAborted();
              },
              forceMinPriority: function () { }
          };
      }
  };
  
  // CONCATENATED MODULE: ./src/core/config.ts
  
  
  function getConfig(opts) {
      var config = {
          activityTimeout: opts.activityTimeout || defaults.activityTimeout,
          authEndpoint: opts.authEndpoint || defaults.authEndpoint,
          authTransport: opts.authTransport || defaults.authTransport,
          cluster: opts.cluster || defaults.cluster,
          httpPath: opts.httpPath || defaults.httpPath,
          httpPort: opts.httpPort || defaults.httpPort,
          httpsPort: opts.httpsPort || defaults.httpsPort,
          pongTimeout: opts.pongTimeout || defaults.pongTimeout,
          statsHost: opts.statsHost || defaults.stats_host,
          unavailableTimeout: opts.unavailableTimeout || defaults.unavailableTimeout,
          wsPath: opts.wsPath || defaults.wsPath,
          wsPort: opts.wsPort || defaults.wsPort,
          wssPort: opts.wssPort || defaults.wssPort,
          enableStats: getEnableStatsConfig(opts),
          httpHost: getHttpHost(opts),
          useTLS: shouldUseTLS(opts),
          wsHost: getWebsocketHost(opts)
      };
      if ('auth' in opts)
          config.auth = opts.auth;
      if ('authorizer' in opts)
          config.authorizer = opts.authorizer;
      if ('disabledTransports' in opts)
          config.disabledTransports = opts.disabledTransports;
      if ('enabledTransports' in opts)
          config.enabledTransports = opts.enabledTransports;
      if ('ignoreNullOrigin' in opts)
          config.ignoreNullOrigin = opts.ignoreNullOrigin;
      if ('timelineParams' in opts)
          config.timelineParams = opts.timelineParams;
      if ('nacl' in opts) {
          config.nacl = opts.nacl;
      }
      return config;
  }
  function getHttpHost(opts) {
      if (opts.httpHost) {
          return opts.httpHost;
      }
      if (opts.cluster) {
          return "sockjs-" + opts.cluster + ".pusher.com";
      }
      return defaults.httpHost;
  }
  function getWebsocketHost(opts) {
      if (opts.wsHost) {
          return opts.wsHost;
      }
      if (opts.cluster) {
          return getWebsocketHostFromCluster(opts.cluster);
      }
      return getWebsocketHostFromCluster(defaults.cluster);
  }
  function getWebsocketHostFromCluster(cluster) {
      return "ws-" + cluster + ".pusher.com";
  }
  function shouldUseTLS(opts) {
      if (node_runtime.getProtocol() === 'https:') {
          return true;
      }
      else if (opts.forceTLS === false) {
          return false;
      }
      return true;
  }
  function getEnableStatsConfig(opts) {
      if ('enableStats' in opts) {
          return opts.enableStats;
      }
      if ('disableStats' in opts) {
          return !opts.disableStats;
      }
      return false;
  }
  
  // CONCATENATED MODULE: ./src/core/pusher.ts
  
  
  
  
  
  
  
  
  
  
  
  
  var pusher_Pusher = (function () {
      function Pusher(app_key, options) {
          var _this = this;
          checkAppKey(app_key);
          options = options || {};
          if (!options.cluster && !(options.wsHost || options.httpHost)) {
              var suffix = url_store.buildLogSuffix('javascriptQuickStart');
              logger.warn("You should always specify a cluster when connecting. " + suffix);
          }
          if ('disableStats' in options) {
              logger.warn('The disableStats option is deprecated in favor of enableStats');
          }
          this.key = app_key;
          this.config = getConfig(options);
          this.channels = factory.createChannels();
          this.global_emitter = new dispatcher();
          this.sessionID = Math.floor(Math.random() * 1000000000);
          this.timeline = new timeline_timeline(this.key, this.sessionID, {
              cluster: this.config.cluster,
              features: Pusher.getClientFeatures(),
              params: this.config.timelineParams || {},
              limit: 50,
              level: timeline_level.INFO,
              version: defaults.VERSION
          });
          if (this.config.enableStats) {
              this.timelineSender = factory.createTimelineSender(this.timeline, {
                  host: this.config.statsHost,
                  path: '/timeline/v2/' + node_runtime.TimelineTransport.name
              });
          }
          var getStrategy = function (options) {
              return node_runtime.getDefaultStrategy(_this.config, options, strategy_builder_defineTransport);
          };
          this.connection = factory.createConnectionManager(this.key, {
              getStrategy: getStrategy,
              timeline: this.timeline,
              activityTimeout: this.config.activityTimeout,
              pongTimeout: this.config.pongTimeout,
              unavailableTimeout: this.config.unavailableTimeout,
              useTLS: Boolean(this.config.useTLS)
          });
          this.connection.bind('connected', function () {
              _this.subscribeAll();
              if (_this.timelineSender) {
                  _this.timelineSender.send(_this.connection.isUsingTLS());
              }
          });
          this.connection.bind('message', function (event) {
              var eventName = event.event;
              var internal = eventName.indexOf('pusher_internal:') === 0;
              if (event.channel) {
                  var channel = _this.channel(event.channel);
                  if (channel) {
                      channel.handleEvent(event);
                  }
              }
              if (!internal) {
                  _this.global_emitter.emit(event.event, event.data);
              }
          });
          this.connection.bind('connecting', function () {
              _this.channels.disconnect();
          });
          this.connection.bind('disconnected', function () {
              _this.channels.disconnect();
          });
          this.connection.bind('error', function (err) {
              logger.warn(err);
          });
          Pusher.instances.push(this);
          this.timeline.info({ instances: Pusher.instances.length });
          if (Pusher.isReady) {
              this.connect();
          }
      }
      Pusher.ready = function () {
          Pusher.isReady = true;
          for (var i = 0, l = Pusher.instances.length; i < l; i++) {
              Pusher.instances[i].connect();
          }
      };
      Pusher.getClientFeatures = function () {
          return keys(filterObject({ ws: node_runtime.Transports.ws }, function (t) {
              return t.isSupported({});
          }));
      };
      Pusher.prototype.channel = function (name) {
          return this.channels.find(name);
      };
      Pusher.prototype.allChannels = function () {
          return this.channels.all();
      };
      Pusher.prototype.connect = function () {
          this.connection.connect();
          if (this.timelineSender) {
              if (!this.timelineSenderTimer) {
                  var usingTLS = this.connection.isUsingTLS();
                  var timelineSender = this.timelineSender;
                  this.timelineSenderTimer = new PeriodicTimer(60000, function () {
                      timelineSender.send(usingTLS);
                  });
              }
          }
      };
      Pusher.prototype.disconnect = function () {
          this.connection.disconnect();
          if (this.timelineSenderTimer) {
              this.timelineSenderTimer.ensureAborted();
              this.timelineSenderTimer = null;
          }
      };
      Pusher.prototype.bind = function (event_name, callback, context) {
          this.global_emitter.bind(event_name, callback, context);
          return this;
      };
      Pusher.prototype.unbind = function (event_name, callback, context) {
          this.global_emitter.unbind(event_name, callback, context);
          return this;
      };
      Pusher.prototype.bind_global = function (callback) {
          this.global_emitter.bind_global(callback);
          return this;
      };
      Pusher.prototype.unbind_global = function (callback) {
          this.global_emitter.unbind_global(callback);
          return this;
      };
      Pusher.prototype.unbind_all = function (callback) {
          this.global_emitter.unbind_all();
          return this;
      };
      Pusher.prototype.subscribeAll = function () {
          var channelName;
          for (channelName in this.channels.channels) {
              if (this.channels.channels.hasOwnProperty(channelName)) {
                  this.subscribe(channelName);
              }
          }
      };
      Pusher.prototype.subscribe = function (channel_name) {
          var channel = this.channels.add(channel_name, this);
          if (channel.subscriptionPending && channel.subscriptionCancelled) {
              channel.reinstateSubscription();
          }
          else if (!channel.subscriptionPending &&
              this.connection.state === 'connected') {
              channel.subscribe();
          }
          return channel;
      };
      Pusher.prototype.unsubscribe = function (channel_name) {
          var channel = this.channels.find(channel_name);
          if (channel && channel.subscriptionPending) {
              channel.cancelSubscription();
          }
          else {
              channel = this.channels.remove(channel_name);
              if (channel && channel.subscribed) {
                  channel.unsubscribe();
              }
          }
      };
      Pusher.prototype.send_event = function (event_name, data, channel) {
          return this.connection.send_event(event_name, data, channel);
      };
      Pusher.prototype.shouldUseTLS = function () {
          return this.config.useTLS;
      };
      Pusher.instances = [];
      Pusher.isReady = false;
      Pusher.logToConsole = false;
      Pusher.Runtime = node_runtime;
      Pusher.ScriptReceivers = node_runtime.ScriptReceivers;
      Pusher.DependenciesReceivers = node_runtime.DependenciesReceivers;
      Pusher.auth_callbacks = node_runtime.auth_callbacks;
      return Pusher;
  }());
  /* harmony default export */ var core_pusher = (pusher_Pusher);
  function checkAppKey(key) {
      if (key === null || key === undefined) {
          throw 'You must pass your app key when you instantiate Pusher.';
      }
  }
  node_runtime.setup(pusher_Pusher);
  
  // EXTERNAL MODULE: ./node_modules/tweetnacl/nacl-fast.js
  var nacl_fast = __webpack_require__(20);
  
  // CONCATENATED MODULE: ./src/core/pusher-with-encryption.ts
  var pusher_with_encryption_extends = (undefined && undefined.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  
  
  var pusher_with_encryption_PusherWithEncryption = (function (_super) {
      pusher_with_encryption_extends(PusherWithEncryption, _super);
      function PusherWithEncryption(app_key, options) {
          var _this = this;
          core_pusher.logToConsole = PusherWithEncryption.logToConsole;
          core_pusher.log = PusherWithEncryption.log;
          options = options || {};
          options.nacl = nacl_fast;
          _this = _super.call(this, app_key, options) || this;
          return _this;
      }
      return PusherWithEncryption;
  }(core_pusher));
  /* harmony default export */ var pusher_with_encryption = __webpack_exports__["default"] = (pusher_with_encryption_PusherWithEncryption);
  
  
  /***/ })
  /******/ ]);