text: /*!
   * Pusher JavaScript Library v7.0.3
   * https://pusher.com/
   *
   * Copyright 2020, Pusher
   * Released under the MIT licence.
   */
  
  (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory();
  	else if(typeof define === 'function' && define.amd)
  		define([], factory);
  	else if(typeof exports === 'object')
  		exports["Pusher"] = factory();
  	else
  		root["Pusher"] = factory();
  })(window, function() {
  return /******/ (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 = 3);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ (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
  
  /***/ }),
  /* 1 */
  /***/ (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
  
  /***/ }),
  /* 2 */
  /***/ (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__(4);
      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 || {}));
  
  
  /***/ }),
  /* 3 */
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = __webpack_require__(5).default;
  
  
  /***/ }),
  /* 4 */
  /***/ (function(module, exports) {
  
  /* (ignored) */
  
  /***/ }),
  /* 5 */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  
  // CONCATENATED MODULE: ./src/runtimes/web/dom/script_receiver_factory.ts
  var ScriptReceiverFactory = (function () {
      function ScriptReceiverFactory(prefix, name) {
          this.lastId = 0;
          this.prefix = prefix;
          this.name = name;
      }
      ScriptReceiverFactory.prototype.create = function (callback) {
          this.lastId++;
          var number = this.lastId;
          var id = this.prefix + number;
          var name = this.name + '[' + number + ']';
          var called = false;
          var callbackWrapper = function () {
              if (!called) {
                  callback.apply(null, arguments);
                  called = true;
              }
          };
          this[number] = callbackWrapper;
          return { number: number, id: id, name: name, callback: callbackWrapper };
      };
      ScriptReceiverFactory.prototype.remove = function (receiver) {
          delete this[receiver.number];
      };
      return ScriptReceiverFactory;
  }());
  
  var ScriptReceivers = new ScriptReceiverFactory('_pusher_script_', 'Pusher.ScriptReceivers');
  
  // CONCATENATED MODULE: ./src/core/defaults.ts
  var Defaults = {
      VERSION: "7.0.3",
      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/runtimes/web/dom/dependency_loader.ts
  
  
  var dependency_loader_DependencyLoader = (function () {
      function DependencyLoader(options) {
          this.options = options;
          this.receivers = options.receivers || ScriptReceivers;
          this.loading = {};
      }
      DependencyLoader.prototype.load = function (name, options, callback) {
          var self = this;
          if (self.loading[name] && self.loading[name].length > 0) {
              self.loading[name].push(callback);
          }
          else {
              self.loading[name] = [callback];
              var request = runtime.createScriptRequest(self.getPath(name, options));
              var receiver = self.receivers.create(function (error) {
                  self.receivers.remove(receiver);
                  if (self.loading[name]) {
                      var callbacks = self.loading[name];
                      delete self.loading[name];
                      var successCallback = function (wasSuccessful) {
                          if (!wasSuccessful) {
                              request.cleanup();
                          }
                      };
                      for (var i = 0; i < callbacks.length; i++) {
                          callbacks[i](error, successCallback);
                      }
                  }
              });
              request.send(receiver);
          }
      };
      DependencyLoader.prototype.getRoot = function (options) {
          var cdn;
          var protocol = runtime.getDocument().location.protocol;
          if ((options && options.useTLS) || protocol === 'https:') {
              cdn = this.options.cdn_https;
          }
          else {
              cdn = this.options.cdn_http;
          }
          return cdn.replace(/\/*$/, '') + '/' + this.options.version;
      };
      DependencyLoader.prototype.getPath = function (name, options) {
          return this.getRoot(options) + '/' + name + this.options.suffix + '.js';
      };
      return DependencyLoader;
  }());
  /* harmony default export */ var dependency_loader = (dependency_loader_DependencyLoader);
  
  // CONCATENATED MODULE: ./src/runtimes/web/dom/dependencies.ts
  
  
  
  var DependenciesReceivers = new ScriptReceiverFactory('_pusher_dependencies', 'Pusher.DependenciesReceivers');
  var Dependencies = new dependency_loader({
      cdn_http: defaults.cdn_http,
      cdn_https: defaults.cdn_https,
      version: defaults.VERSION,
      suffix: defaults.dependency_suffix,
      receivers: DependenciesReceivers
  });
  
  // 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/errors.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 __());
      };
  })();
  var BadEventName = (function (_super) {
      __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) {
      __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) {
      __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) {
      __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) {
      __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) {
      __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) {
      __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) {
      __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/runtimes/isomorphic/auth/xhr_auth.ts
  
  
  
  var ajax = function (context, socketId, callback) {
      var self = this, xhr;
      xhr = 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/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 = window.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 timers_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) {
      window.clearTimeout(timer);
  }
  function timers_clearInterval(timer) {
      window.clearInterval(timer);
  }
  var OneOffTimer = (function (_super) {
      timers_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) {
      timers_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 || window, 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/logger.ts
  
  
  var logger_Logger = (function () {
      function Logger() {
          this.globalLog = function (message) {
              if (window.console && window.console.log) {
                  window.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 (window.console && window.console.warn) {
              window.console.warn(message);
          }
          else {
              this.globalLog(message);
          }
      };
      Logger.prototype.globalLogError = function (message) {
          if (window.console && window.console.error) {
              window.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/runtimes/web/auth/jsonp_auth.ts
  
  var jsonp = function (context, socketId, callback) {
      if (this.authOptions.headers !== undefined) {
          logger.warn('To send headers with the auth request, you must use AJAX, rather than JSONP.');
      }
      var callbackName = context.nextAuthCallbackID.toString();
      context.nextAuthCallbackID++;
      var document = context.getDocument();
      var script = document.createElement('script');
      context.auth_callbacks[callbackName] = function (data) {
          callback(null, data);
      };
      var callback_name = "Pusher.auth_callbacks['" + callbackName + "']";
      script.src =
          this.options.authEndpoint +
              '?callback=' +
              encodeURIComponent(callback_name) +
              '&' +
              this.composeQuery(socketId);
      var head = document.getElementsByTagName('head')[0] || document.documentElement;
      head.insertBefore(script, head.firstChild);
  };
  /* harmony default export */ var jsonp_auth = (jsonp);
  
  // CONCATENATED MODULE: ./src/runtimes/web/dom/script_request.ts
  var ScriptRequest = (function () {
      function ScriptRequest(src) {
          this.src = src;
      }
      ScriptRequest.prototype.send = function (receiver) {
          var self = this;
          var errorString = 'Error loading ' + self.src;
          self.script = document.createElement('script');
          self.script.id = receiver.id;
          self.script.src = self.src;
          self.script.type = 'text/javascript';
          self.script.charset = 'UTF-8';
          if (self.script.addEventListener) {
              self.script.onerror = function () {
                  receiver.callback(errorString);
              };
              self.script.onload = function () {
                  receiver.callback(null);
              };
          }
          else {
              self.script.onreadystatechange = function () {
                  if (self.script.readyState === 'loaded' ||
                      self.script.readyState === 'complete') {
                      receiver.callback(null);
                  }
              };
          }
          if (self.script.async === undefined &&
              document.attachEvent &&
              /opera/i.test(navigator.userAgent)) {
              self.errorScript = document.createElement('script');
              self.errorScript.id = receiver.id + '_error';
              self.errorScript.text = receiver.name + "('" + errorString + "');";
              self.script.async = self.errorScript.async = false;
          }
          else {
              self.script.async = true;
          }
          var head = document.getElementsByTagName('head')[0];
          head.insertBefore(self.script, head.firstChild);
          if (self.errorScript) {
              head.insertBefore(self.errorScript, self.script.nextSibling);
          }
      };
      ScriptRequest.prototype.cleanup = function () {
          if (this.script) {
              this.script.onload = this.script.onerror = null;
              this.script.onreadystatechange = null;
          }
          if (this.script && this.script.parentNode) {
              this.script.parentNode.removeChild(this.script);
          }
          if (this.errorScript && this.errorScript.parentNode) {
              this.errorScript.parentNode.removeChild(this.errorScript);
          }
          this.script = null;
          this.errorScript = null;
      };
      return ScriptRequest;
  }());
  /* harmony default export */ var script_request = (ScriptRequest);
  
  // CONCATENATED MODULE: ./src/runtimes/web/dom/jsonp_request.ts
  
  
  var jsonp_request_JSONPRequest = (function () {
      function JSONPRequest(url, data) {
          this.url = url;
          this.data = data;
      }
      JSONPRequest.prototype.send = function (receiver) {
          if (this.request) {
              return;
          }
          var query = buildQueryString(this.data);
          var url = this.url + '/' + receiver.number + '?' + query;
          this.request = runtime.createScriptRequest(url);
          this.request.send(receiver);
      };
      JSONPRequest.prototype.cleanup = function () {
          if (this.request) {
              this.request.cleanup();
          }
      };
      return JSONPRequest;
  }());
  /* harmony default export */ var jsonp_request = (jsonp_request_JSONPRequest);
  
  // CONCATENATED MODULE: ./src/runtimes/web/timeline/jsonp_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 request = runtime.createJSONPRequest(url, data);
          var receiver = runtime.ScriptReceivers.create(function (error, result) {
              ScriptReceivers.remove(receiver);
              request.cleanup();
              if (result && result.host) {
                  sender.host = result.host;
              }
              if (callback) {
                  callback(error, result);
              }
          });
          request.send(receiver);
      };
  };
  var jsonp_timeline_jsonp = {
      name: 'jsonp',
      getAgent: getAgent
  };
  /* harmony default export */ var jsonp_timeline = (jsonp_timeline_jsonp);
  
  // 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 || window, args);
              }
          }
          else if (this.failThrough) {
              this.failThrough(eventName, data);
          }
          return this;
      };
      return Dispatcher;
  }());
  /* harmony default export */ var dispatcher = (dispatcher_Dispatcher);
  
  // 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 = 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(runtime.getWebSocketAPI());
      },
      isSupported: function () {
          return Boolean(runtime.getWebSocketAPI());
      },
      getSocket: function (url) {
          return runtime.createWebSocket(url);
      }
  });
  var httpConfiguration = {
      urls: http,
      handlesActivityChecks: false,
      supportsPing: true,
      isInitialized: function () {
          return true;
      }
  };
  var streamingConfiguration = extend({
      getSocket: function (url) {
          return runtime.HTTPFactory.createStreamingSocket(url);
      }
  }, httpConfiguration);
  var pollingConfiguration = extend({
      getSocket: function (url) {
          return runtime.HTTPFactory.createPollingSocket(url);
      }
  }, httpConfiguration);
  var xhrConfiguration = {
      isSupported: function () {
          return 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/runtimes/web/transports/transports.ts
  
  
  
  
  
  
  var SockJSTransport = new transports_transport({
      file: 'sockjs',
      urls: sockjs,
      handlesActivityChecks: true,
      supportsPing: false,
      isSupported: function () {
          return true;
      },
      isInitialized: function () {
          return window.SockJS !== undefined;
      },
      getSocket: function (url, options) {
          return new window.SockJS(url, null, {
              js_path: Dependencies.getPath('sockjs', {
                  useTLS: options.useTLS
              }),
              ignore_null_origin: options.ignoreNullOrigin
          });
      },
      beforeOpen: function (socket, path) {
          socket.send(JSON.stringify({
              path: path
          }));
      }
  });
  var xdrConfiguration = {
      isSupported: function (environment) {
          var yes = runtime.isXDRSupported(environment.useTLS);
          return yes;
      }
  };
  var XDRStreamingTransport = new transports_transport((extend({}, streamingConfiguration, xdrConfiguration)));
  var XDRPollingTransport = new transports_transport(extend({}, pollingConfiguration, xdrConfiguration));
  transports.xdr_streaming = XDRStreamingTransport;
  transports.xdr_polling = XDRPollingTransport;
  transports.sockjs = SockJSTransport;
  /* harmony default export */ var transports_transports = (transports);
  
  // CONCATENATED MODULE: ./src/runtimes/web/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() {
          var _this = _super.call(this) || this;
          var self = _this;
          if (window.addEventListener !== undefined) {
              window.addEventListener('online', function () {
                  self.emit('online');
              }, false);
              window.addEventListener('offline', function () {
                  self.emit('offline');
              }, false);
          }
          return _this;
      }
      NetInfo.prototype.isOnline = function () {
          if (window.navigator.onLine === undefined) {
              return true;
          }
          else {
              return window.navigator.onLine;
          }
      };
      return NetInfo;
  }(dispatcher));
  
  var net_info_Network = new NetInfo();
  
  // 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 = (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_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_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_protocol.getCloseAction(closeEvent);
          var error = protocol_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_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_protocol.getCloseAction(closeEvent) || 'backoff';
              var error = protocol_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 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 || runtime.getAuthorizers();
          PusherAuthorizer.authorizers[this.type].call(this, 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(runtime.TimelineTransport.getAgent(this, useTLS), callback);
      };
      return TimelineSender;
  }());
  /* harmony default export */ var timeline_sender = (timeline_sender_TimelineSender);
  
  // 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__(1);
  
  // EXTERNAL MODULE: ./node_modules/@stablelib/base64/lib/base64.js
  var base64 = __webpack_require__(0);
  
  // 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 = 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 = 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 = runtime.getLocalStorage();
      if (storage) {
          try {
              storage[getTransportCacheKey(usingTLS)] = safeJSONStringify({
                  timestamp: util.now(),
                  transport: transport,
                  latency: latency
              });
          }
          catch (e) {
          }
      }
  }
  function flushTransportCache(usingTLS) {
      var storage = 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/web/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 = Object.assign({}, ws_options, {
          useTLS: true
      });
      var sockjs_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 sockjs_transport = defineTransportStrategy('sockjs', 'sockjs', 1, sockjs_options);
      var xhr_streaming_transport = defineTransportStrategy('xhr_streaming', 'xhr_streaming', 1, sockjs_options, streaming_manager);
      var xdr_streaming_transport = defineTransportStrategy('xdr_streaming', 'xdr_streaming', 1, sockjs_options, streaming_manager);
      var xhr_polling_transport = defineTransportStrategy('xhr_polling', 'xhr_polling', 1, sockjs_options);
      var xdr_polling_transport = defineTransportStrategy('xdr_polling', 'xdr_polling', 1, sockjs_options);
      var ws_loop = new sequential_strategy([ws_transport], timeouts);
      var wss_loop = new sequential_strategy([wss_transport], timeouts);
      var sockjs_loop = new sequential_strategy([sockjs_transport], timeouts);
      var streaming_loop = new sequential_strategy([
          new if_strategy(testSupportsStrategy(xhr_streaming_transport), xhr_streaming_transport, xdr_streaming_transport)
      ], timeouts);
      var polling_loop = new sequential_strategy([
          new if_strategy(testSupportsStrategy(xhr_polling_transport), xhr_polling_transport, xdr_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 http_fallback_loop = new if_strategy(testSupportsStrategy(http_loop), http_loop, sockjs_loop);
      var wsStrategy;
      if (baseOptions.useTLS) {
          wsStrategy = new best_connected_ever_strategy([
              ws_loop,
              new delayed_strategy(http_fallback_loop, { delay: 2000 })
          ]);
      }
      else {
          wsStrategy = new best_connected_ever_strategy([
              ws_loop,
              new delayed_strategy(wss_loop, { delay: 2000 }),
              new delayed_strategy(http_fallback_loop, { delay: 5000 })
          ]);
      }
      return new cached_strategy(new first_connected_strategy(new if_strategy(testSupportsStrategy(ws_transport), wsStrategy, http_fallback_loop)), definedTransports, {
          ttl: 1800000,
          timeline: baseOptions.timeline,
          useTLS: baseOptions.useTLS
      });
  };
  /* harmony default export */ var default_strategy = (getDefaultStrategy);
  
  // CONCATENATED MODULE: ./src/runtimes/web/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 if (self.hooks.file) {
          self.changeState('initializing');
          Dependencies.load(self.hooks.file, { useTLS: self.options.useTLS }, function (error, callback) {
              if (self.hooks.isInitialized()) {
                  self.changeState('initialized');
                  callback(true);
              }
              else {
                  if (error) {
                      self.onError(error);
                  }
                  self.onClose();
                  callback(false);
              }
          });
      }
      else {
          self.onClose();
      }
  });
  
  // CONCATENATED MODULE: ./src/runtimes/web/http/http_xdomain_request.ts
  
  var http_xdomain_request_hooks = {
      getRequest: function (socket) {
          var xdr = new window.XDomainRequest();
          xdr.ontimeout = function () {
              socket.emit('error', new RequestTimedOut());
              socket.close();
          };
          xdr.onerror = function (e) {
              socket.emit('error', e);
              socket.close();
          };
          xdr.onprogress = function () {
              if (xdr.responseText && xdr.responseText.length > 0) {
                  socket.onChunk(200, xdr.responseText);
              }
          };
          xdr.onload = function () {
              if (xdr.responseText && xdr.responseText.length > 0) {
                  socket.onChunk(200, xdr.responseText);
              }
              socket.emit('finished', 200);
              socket.close();
          };
          return xdr;
      },
      abortRequest: function (xdr) {
          xdr.ontimeout = xdr.onerror = xdr.onprogress = xdr.onload = null;
          xdr.abort();
      }
  };
  /* harmony default export */ var http_xdomain_request = (http_xdomain_request_hooks);
  
  // 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();
          };
          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) {
              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 {
                  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 = 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 = 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/web/http/http.ts
  
  
  http_http.createXDR = function (method, url) {
      return this.createRequest(http_xdomain_request, method, url);
  };
  /* harmony default export */ var web_http_http = (http_http);
  
  // CONCATENATED MODULE: ./src/runtimes/web/runtime.ts
  
  
  
  
  
  
  
  
  
  
  
  
  var Runtime = {
      nextAuthCallbackID: 1,
      auth_callbacks: {},
      ScriptReceivers: ScriptReceivers,
      DependenciesReceivers: DependenciesReceivers,
      getDefaultStrategy: default_strategy,
      Transports: transports_transports,
      transportConnectionInitializer: transport_connection_initializer,
      HTTPFactory: web_http_http,
      TimelineTransport: jsonp_timeline,
      getXHRAPI: function () {
          return window.XMLHttpRequest;
      },
      getWebSocketAPI: function () {
          return window.WebSocket || window.MozWebSocket;
      },
      setup: function (PusherClass) {
          var _this = this;
          window.Pusher = PusherClass;
          var initializeOnDocumentBody = function () {
              _this.onDocumentBody(PusherClass.ready);
          };
          if (!window.JSON) {
              Dependencies.load('json2', {}, initializeOnDocumentBody);
          }
          else {
              initializeOnDocumentBody();
          }
      },
      getDocument: function () {
          return document;
      },
      getProtocol: function () {
          return this.getDocument().location.protocol;
      },
      getAuthorizers: function () {
          return { ajax: xhr_auth, jsonp: jsonp_auth };
      },
      onDocumentBody: function (callback) {
          var _this = this;
          if (document.body) {
              callback();
          }
          else {
              setTimeout(function () {
                  _this.onDocumentBody(callback);
              }, 0);
          }
      },
      createJSONPRequest: function (url, data) {
          return new jsonp_request(url, data);
      },
      createScriptRequest: function (src) {
          return new script_request(src);
      },
      getLocalStorage: function () {
          try {
              return window.localStorage;
          }
          catch (e) {
              return undefined;
          }
      },
      createXHR: function () {
          if (this.getXHRAPI()) {
              return this.createXMLHttpRequest();
          }
          else {
              return this.createMicrosoftXHR();
          }
      },
      createXMLHttpRequest: function () {
          var Constructor = this.getXHRAPI();
          return new Constructor();
      },
      createMicrosoftXHR: function () {
          return new ActiveXObject('Microsoft.XMLHTTP');
      },
      getNetwork: function () {
          return net_info_Network;
      },
      createWebSocket: function (url) {
          var Constructor = this.getWebSocketAPI();
          return new Constructor(url);
      },
      createSocketRequest: function (method, url) {
          if (this.isXHRSupported()) {
              return this.HTTPFactory.createXHR(method, url);
          }
          else if (this.isXDRSupported(url.indexOf('https:') === 0)) {
              return this.HTTPFactory.createXDR(method, url);
          }
          else {
              throw 'Cross-origin HTTP requests are not supported';
          }
      },
      isXHRSupported: function () {
          var Constructor = this.getXHRAPI();
          return (Boolean(Constructor) && new Constructor().withCredentials !== undefined);
      },
      isXDRSupported: function (useTLS) {
          var protocol = useTLS ? 'https:' : 'http:';
          var documentProtocol = this.getProtocol();
          return (Boolean(window['XDomainRequest']) && documentProtocol === protocol);
      },
      addUnloadListener: function (listener) {
          if (window.addEventListener !== undefined) {
              window.addEventListener('unload', listener, false);
          }
          else if (window.attachEvent !== undefined) {
              window.attachEvent('onunload', listener);
          }
      },
      removeUnloadListener: function (listener) {
          if (window.addEventListener !== undefined) {
              window.removeEventListener('unload', listener, false);
          }
          else if (window.detachEvent !== undefined) {
              window.detachEvent('onunload', listener);
          }
      }
  };
  /* harmony default export */ var runtime = (Runtime);
  
  // 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 = 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 (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/' + runtime.TimelineTransport.name
              });
          }
          var getStrategy = function (options) {
              return 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: 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 = runtime;
      Pusher.ScriptReceivers = runtime.ScriptReceivers;
      Pusher.DependenciesReceivers = runtime.DependenciesReceivers;
      Pusher.auth_callbacks = 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.';
      }
  }
  runtime.setup(pusher_Pusher);
  
  // EXTERNAL MODULE: ./node_modules/tweetnacl/nacl-fast.js
  var nacl_fast = __webpack_require__(2);
  
  // 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);
  
  
  /***/ })
  /******/ ]);
  });