(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
    typeof define === 'function' && define.amd ? define(factory) :
    (global.Muxy = factory());
}(this, (function () { 'use strict';

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation. All rights reserved.
    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
    this file except in compliance with the License. You may obtain a copy of the
    License at http://www.apache.org/licenses/LICENSE-2.0

    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
    MERCHANTABLITY OR NON-INFRINGEMENT.

    See the Apache Version 2.0 License for specific language governing permissions
    and limitations under the License.
    ***************************************************************************** */
    /* global Reflect, Promise */

    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);
    };

    function __extends(d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    }

    var __assign = function() {
        __assign = Object.assign || function __assign(t) {
            for (var s, i = 1, n = arguments.length; i < n; i++) {
                s = arguments[i];
                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
            }
            return t;
        };
        return __assign.apply(this, arguments);
    };

    var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

    function unwrapExports (x) {
    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x.default : x;
    }

    function createCommonjsModule(fn, module) {
    	return module = { exports: {} }, fn(module, module.exports), module.exports;
    }

    var gumshoe = createCommonjsModule(function (module) {
    /* eslint-disable */

    // polyfill for String.prototype.trim for IE8
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim
    if (!String.prototype.trim) {
      (function() {
        // Make sure we trim BOM and NBSP
        var rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
        String.prototype.trim = function() {
          return this.replace(rtrim, '');
        };
      })();
    }

    // Production steps of ECMA-262, Edition 5, 15.4.4.21
    // Reference: http://es5.github.io/#x15.4.4.21
    if (!Array.prototype.reduce) {
      Array.prototype.reduce = function(callback /*, initialValue*/) {
        if (this == null) {
          throw new TypeError('Array.prototype.reduce called on null or undefined');
        }
        if (typeof callback !== 'function') {
          throw new TypeError(callback + ' is not a function');
        }
        var t = Object(this), len = t.length >>> 0, k = 0, value;
        if (arguments.length == 2) {
          value = arguments[1];
        } else {
          while (k < len && ! k in t) {
            k++;
          }
          if (k >= len) {
            throw new TypeError('Reduce of empty array with no initial value');
          }
          value = t[k++];
        }
        for (; k < len; k++) {
          if (k in t) {
            value = callback(value, t[k], k, t);
          }
        }
        return value;
      };
    }

    /**
     * @file perfnow is a 0.14 kb window.performance.now high resolution timer polyfill with Date fallback
     * @author Daniel Lamb <dlamb.open.source@gmail.com>
     */
    function perfnow() {
      var perf = window.performance || {};
      perf.now = perf.now ||
        perf.mozNow ||
        perf.msNow ||
        perf.oNow ||
        perf.webkitNow ||
        // fallback to Date
        Date.now || function () {
          return new Date().getTime();
        };

      return perf;
    }
    function gumshoeFactory() {

      // we need reqwest and store2 (and any other future deps)
      // to be solely within our context, so as they don't leak and conflict
      // with other versions of the same libs sites may be loading.
      // so we'll provide our own context.
      // root._gumshoe is only available in specs
      var context = {},
        queryString,
        store,
        /*jshint -W024 */
        undefined;

      // call contextSetup with 'context' as 'this' so all libs attach
      // to our context variable.
      (function contextSetup() {
        /*!
    	    query-string
    	    Parse and stringify URL query strings
    	    https://github.com/sindresorhus/query-string
    	    by Sindre Sorhus
    	    MIT License
        */
        (function (c) {
          var queryString = {};

          queryString.parse = function (str) {
            if (typeof str !== 'string') {
              return {};
            }

            str = str.trim().replace(/^(\?|#)/, '');

            if (!str) {
              return {};
            }

            return str.trim().split('&').reduce(function (ret, param) {
              var parts = param.replace(/\+/g, ' ').split('=');
              var key = parts[0];
              var val = parts[1];

              key = decodeURIComponent(key);
              // missing `=` should be `null`:
              // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
              val = val === undefined ? null : decodeURIComponent(val);

              if (!ret.hasOwnProperty(key)) {
                ret[key] = val;
              } else if (Array.isArray(ret[key])) {
                ret[key].push(val);
              } else {
                ret[key] = [ret[key], val];
              }

              return ret;
            }, {});
          };

          queryString.stringify = function (obj) {
            return obj ? Object.keys(obj).map(function (key) {
              var val = obj[key];

              if (Array.isArray(val)) {
                return val.map(function (val2) {
                  return encodeURIComponent(key) + '=' + encodeURIComponent(val2);
                }).join('&');
              }

              return encodeURIComponent(key) + '=' + encodeURIComponent(val);
            }).join('&') : '';
          };

          c.queryString = queryString;
        })(this);


        /*!
         * Reqwest! A general purpose XHR connection manager
         * license MIT (c) Dustin Diaz 2014
         * https://github.com/ded/reqwest
         */

        !function (name, context, definition) {
          context[name] = definition();
        }('reqwest', this, function () {

          var win = window
            , doc = document
            , httpsRe = /^http/
            , protocolRe = /(^\w+):\/\//
            , twoHundo = /^(20\d|1223)$/ //http://stackoverflow.com/questions/10046972/msie-returns-status-code-of-1223-for-ajax-request
            , byTag = 'getElementsByTagName'
            , readyState = 'readyState'
            , contentType = 'Content-Type'
            , requestedWith = 'X-Requested-With'
            , head = doc[byTag]('head')[0]
            , uniqid = 0
            , callbackPrefix = 'reqwest_' + (+new Date())
            , lastValue // data stored by the most recent JSONP callback
            , xmlHttpRequest = 'XMLHttpRequest'
            , xDomainRequest = 'XDomainRequest'
            , noop = function () {}

            , isArray = typeof Array.isArray == 'function'
                ? Array.isArray
                : function (a) {
                    return a instanceof Array
                  }

            , defaultHeaders = {
                  'contentType': 'application/x-www-form-urlencoded'
                , 'requestedWith': xmlHttpRequest
                , 'accept': {
                      '*':  'text/javascript, text/html, application/xml, text/xml, */*'
                    , 'xml':  'application/xml, text/xml'
                    , 'html': 'text/html'
                    , 'text': 'text/plain'
                    , 'json': 'application/json, text/javascript'
                    , 'js':   'application/javascript, text/javascript'
                  }
              }

            , xhr = function(o) {
                // is it x-domain
                if (o['crossOrigin'] === true) {
                  var xhr = win[xmlHttpRequest] ? new XMLHttpRequest() : null;
                  if (xhr && 'withCredentials' in xhr) {
                    return xhr
                  } else if (win[xDomainRequest]) {
                    return new XDomainRequest()
                  } else {
                    throw new Error('Browser does not support cross-origin requests')
                  }
                } else if (win[xmlHttpRequest]) {
                  return new XMLHttpRequest()
                } else {
                  return new ActiveXObject('Microsoft.XMLHTTP')
                }
              }
            , globalSetupOptions = {
                dataFilter: function (data) {
                  return data
                }
              };

          function succeed(r) {
            var protocol = protocolRe.exec(r.url);
            protocol = (protocol && protocol[1]) || window.location.protocol;
            return httpsRe.test(protocol) ? twoHundo.test(r.request.status) : !!r.request.responseText;
          }

          function handleReadyState(r, success, error) {
            return function () {
              // use _aborted to mitigate against IE err c00c023f
              // (can't read props on aborted request objects)
              if (r._aborted) return error(r.request)
              if (r._timedOut) return error(r.request, 'Request is aborted: timeout')
              if (r.request && r.request[readyState] == 4) {
                r.request.onreadystatechange = noop;
                if (succeed(r)) success(r.request);
                else
                  error(r.request);
              }
            }
          }

          function setHeaders(http, o) {
            var headers = o['headers'] || {}
              , h;

            headers['Accept'] = headers['Accept']
              || defaultHeaders['accept'][o['type']]
              || defaultHeaders['accept']['*'];

            var isAFormData = typeof FormData === 'function' && (o['data'] instanceof FormData);
            // breaks cross-origin requests with legacy browsers
            if (!o['crossOrigin'] && !headers[requestedWith]) headers[requestedWith] = defaultHeaders['requestedWith'];
            if (!headers[contentType] && !isAFormData) headers[contentType] = o['contentType'] || defaultHeaders['contentType'];
            for (h in headers)
              headers.hasOwnProperty(h) && 'setRequestHeader' in http && http.setRequestHeader(h, headers[h]);
          }

          function setCredentials(http, o) {
            if (typeof o['withCredentials'] !== 'undefined' && typeof http.withCredentials !== 'undefined') {
              http.withCredentials = !!o['withCredentials'];
            }
          }

          function generalCallback(data) {
            lastValue = data;
          }

          function urlappend (url, s) {
            return url + (/\?/.test(url) ? '&' : '?') + s
          }

          function handleJsonp(o, fn, err, url) {
            var reqId = uniqid++
              , cbkey = o['jsonpCallback'] || 'callback' // the 'callback' key
              , cbval = o['jsonpCallbackName'] || reqwest.getcallbackPrefix(reqId)
              , cbreg = new RegExp('((^|\\?|&)' + cbkey + ')=([^&]+)')
              , match = url.match(cbreg)
              , script = doc.createElement('script')
              , loaded = 0
              , isIE10 = navigator.userAgent.indexOf('MSIE 10.0') !== -1;

            if (match) {
              if (match[3] === '?') {
                url = url.replace(cbreg, '$1=' + cbval); // wildcard callback func name
              } else {
                cbval = match[3]; // provided callback func name
              }
            } else {
              url = urlappend(url, cbkey + '=' + cbval); // no callback details, add 'em
            }

            win[cbval] = generalCallback;

            script.type = 'text/javascript';
            script.src = url;
            script.async = true;
            if (typeof script.onreadystatechange !== 'undefined' && !isIE10) {
              // need this for IE due to out-of-order onreadystatechange(), binding script
              // execution to an event listener gives us control over when the script
              // is executed. See http://jaubourg.net/2010/07/loading-script-as-onclick-handler-of.html
              script.htmlFor = script.id = '_reqwest_' + reqId;
            }

            script.onload = script.onreadystatechange = function () {
              if ((script[readyState] && script[readyState] !== 'complete' && script[readyState] !== 'loaded') || loaded) {
                return false
              }
              script.onload = script.onreadystatechange = null;
              script.onclick && script.onclick();
              // Call the user callback with the last value stored and clean up values and scripts.
              fn(lastValue);
              lastValue = undefined;
              head.removeChild(script);
              loaded = 1;
            };

            // Add the script to the DOM head
            head.appendChild(script);

            // Enable JSONP timeout
            return {
              abort: function () {
                script.onload = script.onreadystatechange = null;
                err({}, 'Request is aborted: timeout', {});
                lastValue = undefined;
                head.removeChild(script);
                loaded = 1;
              }
            }
          }

          function getRequest(fn, err) {
            var o = this.o
              , method = (o['method'] || 'GET').toUpperCase()
              , url = typeof o === 'string' ? o : o['url']
              // convert non-string objects to query-string form unless o['processData'] is false
              , data = (o['processData'] !== false && o['data'] && typeof o['data'] !== 'string')
                ? reqwest.toQueryString(o['data'])
                : (o['data'] || null)
              , http
              , sendWait = false;

            // if we're working on a GET request and we have data then we should append
            // query string to end of URL and not post data
            if ((o['type'] == 'jsonp' || method == 'GET') && data) {
              url = urlappend(url, data);
              data = null;
            }

            if (o['type'] == 'jsonp') return handleJsonp(o, fn, err, url)

            // get the xhr from the factory if passed
            // if the factory returns null, fall-back to ours
            http = (o.xhr && o.xhr(o)) || xhr(o);

            http.open(method, url, o['async'] === false ? false : true);
            setHeaders(http, o);
            setCredentials(http, o);
            if (win[xDomainRequest] && http instanceof win[xDomainRequest]) {
                http.onload = fn;
                http.onerror = err;
                // NOTE: see
                // http://social.msdn.microsoft.com/Forums/en-US/iewebdevelopment/thread/30ef3add-767c-4436-b8a9-f1ca19b4812e
                http.onprogress = function() {};
                sendWait = true;
            } else {
              http.onreadystatechange = handleReadyState(this, fn, err);
            }
            o['before'] && o['before'](http);
            if (sendWait) {
              setTimeout(function () {
                http.send(data);
              }, 200);
            } else {
              http.send(data);
            }
            return http
          }

          function Reqwest(o, fn) {
            this.o = o;
            this.fn = fn;

            init.apply(this, arguments);
          }

          function setType(header) {
            // json, javascript, text/plain, text/html, xml
            if (header.match('json')) return 'json'
            if (header.match('javascript')) return 'js'
            if (header.match('text')) return 'html'
            if (header.match('xml')) return 'xml'
          }

          function init(o, fn) {

            this.url = typeof o == 'string' ? o : o['url'];
            this.timeout = null;

            // whether request has been fulfilled for purpose
            // of tracking the Promises
            this._fulfilled = false;
            // success handlers
            this._successHandler = function(){};
            this._fulfillmentHandlers = [];
            // error handlers
            this._errorHandlers = [];
            // complete (both success and fail) handlers
            this._completeHandlers = [];
            this._erred = false;
            this._responseArgs = {};

            var self = this;

            fn = fn || function () {};

            if (o['timeout']) {
              this.timeout = setTimeout(function () {
                timedOut();
              }, o['timeout']);
            }

            if (o['success']) {
              this._successHandler = function () {
                o['success'].apply(o, arguments);
              };
            }

            if (o['error']) {
              this._errorHandlers.push(function () {
                o['error'].apply(o, arguments);
              });
            }

            if (o['complete']) {
              this._completeHandlers.push(function () {
                o['complete'].apply(o, arguments);
              });
            }

            function complete (resp) {
              o['timeout'] && clearTimeout(self.timeout);
              self.timeout = null;
              while (self._completeHandlers.length > 0) {
                self._completeHandlers.shift()(resp);
              }
            }

            function success (resp) {
              var type = o['type'] || resp && setType(resp.getResponseHeader('Content-Type')); // resp can be undefined in IE
              resp = (type !== 'jsonp') ? self.request : resp;
              // use global data filter on response text
              var filteredResponse = globalSetupOptions.dataFilter(resp.responseText, type)
                , r = filteredResponse;
              try {
                resp.responseText = r;
              } catch (e) {
                // can't assign this in IE<=8, just ignore
              }
              if (r) {
                switch (type) {
                case 'json':
                  try {
                    resp = win.JSON.parse(r);
                  } catch (err) {
                    return error(resp, 'Could not parse JSON in response', err)
                  }
                  break;
                }
              }

              self._responseArgs.resp = resp;
              self._fulfilled = true;
              fn(resp);
              self._successHandler(resp);
              while (self._fulfillmentHandlers.length > 0) {
                resp = self._fulfillmentHandlers.shift()(resp);
              }

              complete(resp);
            }

            function timedOut() {
              self._timedOut = true;
              if(typeof self.request !== 'undefined' && typeof self.request.abort === 'function') {
                self.request.abort();
              }
            }

            function error(resp, msg, t) {
              resp = self.request;
              self._responseArgs.resp = resp;
              self._responseArgs.msg = msg;
              self._responseArgs.t = t;
              self._erred = true;
              while (self._errorHandlers.length > 0) {
                self._errorHandlers.shift()(resp, msg, t);
              }
              complete(resp);
            }

            this.request = getRequest.call(this, success, error);
          }

          Reqwest.prototype = {
            abort: function () {
              this._aborted = true;
              if(typeof this.request !== 'undefined' && typeof this.request.abort === 'function') {
                this.request.abort();
              }
            }

          , retry: function () {
              this._aborted=false;
              this._timedOut=false;
              init.call(this, this.o, this.fn);
            }

            /**
             * Small deviation from the Promises A CommonJs specification
             * http://wiki.commonjs.org/wiki/Promises/A
             */

            /**
             * `then` will execute upon successful requests
             */
          , then: function (success, fail) {
              success = success || function () {};
              fail = fail || function () {};
              if (this._fulfilled) {
                this._responseArgs.resp = success(this._responseArgs.resp);
              } else if (this._erred) {
                fail(this._responseArgs.resp, this._responseArgs.msg, this._responseArgs.t);
              } else {
                this._fulfillmentHandlers.push(success);
                this._errorHandlers.push(fail);
              }
              return this
            }

            /**
             * `always` will execute whether the request succeeds or fails
             */
          , always: function (fn) {
              if (this._fulfilled || this._erred) {
                fn(this._responseArgs.resp);
              } else {
                this._completeHandlers.push(fn);
              }
              return this
            }

            /**
             * `fail` will execute when the request fails
             */
          , fail: function (fn) {
              if (this._erred) {
                fn(this._responseArgs.resp, this._responseArgs.msg, this._responseArgs.t);
              } else {
                this._errorHandlers.push(fn);
              }
              return this
            }
          , 'catch': function (fn) {
              return this.fail(fn)
            }
          };

          function reqwest(o, fn) {
            return new Reqwest(o, fn)
          }

          // normalize newline variants according to spec -> CRLF
          function normalize(s) {
            return s ? s.replace(/\r?\n/g, '\r\n') : ''
          }

          function serial(el, cb) {
            var n = el.name
              , t = el.tagName.toLowerCase()
              , optCb = function (o) {
                  // IE gives value="" even where there is no value attribute
                  // 'specified' ref: http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-862529273
                  if (o && !o['disabled'])
                    cb(n, normalize(o['attributes']['value'] && o['attributes']['value']['specified'] ? o['value'] : o['text']));
                }
              , ch, ra, val, i;

            // don't serialize elements that are disabled or without a name
            if (el.disabled || !n) return

            switch (t) {
            case 'input':
              if (!/reset|button|image|file/i.test(el.type)) {
                ch = /checkbox/i.test(el.type);
                ra = /radio/i.test(el.type);
                val = el.value
                // WebKit gives us "" instead of "on" if a checkbox has no value, so correct it here
                ;(!(ch || ra) || el.checked) && cb(n, normalize(ch && val === '' ? 'on' : val));
              }
              break
            case 'textarea':
              cb(n, normalize(el.value));
              break
            case 'select':
              if (el.type.toLowerCase() === 'select-one') {
                optCb(el.selectedIndex >= 0 ? el.options[el.selectedIndex] : null);
              } else {
                for (i = 0; el.length && i < el.length; i++) {
                  el.options[i].selected && optCb(el.options[i]);
                }
              }
              break
            }
          }

          // collect up all form elements found from the passed argument elements all
          // the way down to child elements; pass a '<form>' or form fields.
          // called with 'this'=callback to use for serial() on each element
          function eachFormElement() {
            var cb = this
              , e, i
              , serializeSubtags = function (e, tags) {
                  var i, j, fa;
                  for (i = 0; i < tags.length; i++) {
                    fa = e[byTag](tags[i]);
                    for (j = 0; j < fa.length; j++) serial(fa[j], cb);
                  }
                };

            for (i = 0; i < arguments.length; i++) {
              e = arguments[i];
              if (/input|select|textarea/i.test(e.tagName)) serial(e, cb);
              serializeSubtags(e, [ 'input', 'select', 'textarea' ]);
            }
          }

          // standard query string style serialization
          function serializeQueryString() {
            return reqwest.toQueryString(reqwest.serializeArray.apply(null, arguments))
          }

          // { 'name': 'value', ... } style serialization
          function serializeHash() {
            var hash = {};
            eachFormElement.apply(function (name, value) {
              if (name in hash) {
                hash[name] && !isArray(hash[name]) && (hash[name] = [hash[name]]);
                hash[name].push(value);
              } else hash[name] = value;
            }, arguments);
            return hash
          }

          // [ { name: 'name', value: 'value' }, ... ] style serialization
          reqwest.serializeArray = function () {
            var arr = [];
            eachFormElement.apply(function (name, value) {
              arr.push({name: name, value: value});
            }, arguments);
            return arr
          };

          reqwest.serialize = function () {
            if (arguments.length === 0) return ''
            var opt, fn
              , args = Array.prototype.slice.call(arguments, 0);

            opt = args.pop();
            opt && opt.nodeType && args.push(opt) && (opt = null);
            opt && (opt = opt.type);

            if (opt == 'map') fn = serializeHash;
            else if (opt == 'array') fn = reqwest.serializeArray;
            else fn = serializeQueryString;

            return fn.apply(null, args)
          };

          reqwest.toQueryString = function (o, trad) {
            var prefix, i
              , traditional = trad || false
              , s = []
              , enc = encodeURIComponent
              , add = function (key, value) {
                  // If value is a function, invoke it and return its value
                  value = ('function' === typeof value) ? value() : (value == null ? '' : value);
                  s[s.length] = enc(key) + '=' + enc(value);
                };
            // If an array was passed in, assume that it is an array of form elements.
            if (isArray(o)) {
              for (i = 0; o && i < o.length; i++) add(o[i]['name'], o[i]['value']);
            } else {
              // If traditional, encode the "old" way (the way 1.3.2 or older
              // did it), otherwise encode params recursively.
              for (prefix in o) {
                if (o.hasOwnProperty(prefix)) buildParams(prefix, o[prefix], traditional, add);
              }
            }

            // spaces should be + according to spec
            return s.join('&').replace(/%20/g, '+')
          };

          function buildParams(prefix, obj, traditional, add) {
            var name, i, v
              , rbracket = /\[\]$/;

            if (isArray(obj)) {
              // Serialize array item.
              for (i = 0; obj && i < obj.length; i++) {
                v = obj[i];
                if (traditional || rbracket.test(prefix)) {
                  // Treat each array item as a scalar.
                  add(prefix, v);
                } else {
                  buildParams(prefix + '[' + (typeof v === 'object' ? i : '') + ']', v, traditional, add);
                }
              }
            } else if (obj && obj.toString() === '[object Object]') {
              // Serialize object item.
              for (name in obj) {
                buildParams(prefix + '[' + name + ']', obj[name], traditional, add);
              }

            } else {
              // Serialize scalar item.
              add(prefix, obj);
            }
          }

          reqwest.getcallbackPrefix = function () {
            return callbackPrefix
          };

          // jQuery and Zepto compatibility, differences can be remapped here so you can call
          // .ajax.compat(options, callback)
          reqwest.compat = function (o, fn) {
            if (o) {
              o['type'] && (o['method'] = o['type']) && delete o['type'];
              o['dataType'] && (o['type'] = o['dataType']);
              o['jsonpCallback'] && (o['jsonpCallbackName'] = o['jsonpCallback']) && delete o['jsonpCallback'];
              o['jsonp'] && (o['jsonpCallback'] = o['jsonp']);
            }
            return new Reqwest(o, fn)
          };

          reqwest.ajaxSetup = function (options) {
            options = options || {};
            for (var k in options) {
              globalSetupOptions[k] = options[k];
            }
          };

          return reqwest
        });
    (function(window, define) {
            var _ = {
                version: "2.3.0",
                areas: {},
                apis: {},

                // utilities
                inherit: function(api, o) {
                    for (var p in api) {
                        if (!o.hasOwnProperty(p)) {
                            o[p] = api[p];
                        }
                    }
                    return o;
                },
                stringify: function(d) {
                    return d === undefined || typeof d === "function" ? d+'' : JSON.stringify(d);
                },
                parse: function(s) {
                    // if it doesn't parse, return as is
                    try{ return JSON.parse(s); }catch(e){ return s; }
                },

                // extension hooks
                fn: function(name, fn) {
                    _.storeAPI[name] = fn;
                    for (var api in _.apis) {
                        _.apis[api][name] = fn;
                    }
                },
                get: function(area, key){ return area.getItem(key); },
                set: function(area, key, string){ area.setItem(key, string); },
                remove: function(area, key){ area.removeItem(key); },
                key: function(area, i){ return area.key(i); },
                length: function(area){ return area.length; },
                clear: function(area){ area.clear(); },

                // core functions
                Store: function(id, area, namespace) {
                    var store = _.inherit(_.storeAPI, function(key, data, overwrite) {
                        if (arguments.length === 0){ return store.getAll(); }
                        if (data !== undefined){ return store.set(key, data, overwrite); }
                        if (typeof key === "string"){ return store.get(key); }
                        if (!key){ return store.clear(); }
                        return store.setAll(key, data);// overwrite=data, data=key
                    });
                    store._id = id;
                    try {
                        var testKey = '_safariPrivate_';
                        area.setItem(testKey, 'sucks');
                        store._area = area;
                        area.removeItem(testKey);
                    } catch (e) {}
                    if (!store._area) {
                        store._area = _.inherit(_.storageAPI, { items: {}, name: 'fake' });
                    }
                    store._ns = namespace || '';
                    if (!_.areas[id]) {
                        _.areas[id] = store._area;
                    }
                    if (!_.apis[store._ns+store._id]) {
                        _.apis[store._ns+store._id] = store;
                    }
                    return store;
                },
                storeAPI: {
                    // admin functions
                    area: function(id, area) {
                        var store = this[id];
                        if (!store || !store.area) {
                            store = _.Store(id, area, this._ns);//new area-specific api in this namespace
                            if (!this[id]){ this[id] = store; }
                        }
                        return store;
                    },
                    namespace: function(namespace, noSession) {
                        if (!namespace){
                            return this._ns ? this._ns.substring(0,this._ns.length-1) : '';
                        }
                        var ns = namespace, store = this[ns];
                        if (!store || !store.namespace) {
                            store = _.Store(this._id, this._area, this._ns+ns+'.');//new namespaced api
                            if (!this[ns]){ this[ns] = store; }
                            if (!noSession){ store.area('session', _.areas.session); }
                        }
                        return store;
                    },
                    isFake: function(){ return this._area.name === 'fake'; },
                    toString: function() {
                        return 'store'+(this._ns?'.'+this.namespace():'')+'['+this._id+']';
                    },

                    // storage functions
                    has: function(key) {
                        if (this._area.has) {
                            return this._area.has(this._in(key));//extension hook
                        }
                        return !!(this._in(key) in this._area);
                    },
                    size: function(){ return this.keys().length; },
                    each: function(fn, and) {
                        for (var i=0, m=_.length(this._area); i<m; i++) {
                            var key = this._out(_.key(this._area, i));
                            if (key !== undefined) {
                                if (fn.call(this, key, and || this.get(key)) === false) {
                                    break;
                                }
                            }
                            if (m > _.length(this._area)) { m--; i--; }// in case of removeItem
                        }
                        return and || this;
                    },
                    keys: function() {
                        return this.each(function(k, list){ list.push(k); }, []);
                    },
                    get: function(key, alt) {
                        var s = _.get(this._area, this._in(key));
                        return s !== null ? _.parse(s) : alt || s;// support alt for easy default mgmt
                    },
                    getAll: function() {
                        return this.each(function(k, all){ all[k] = this.get(k); }, {});
                    },
                    set: function(key, data, overwrite) {
                        var d = this.get(key);
                        if (d != null && overwrite === false) {
                            return data;
                        }
                        return _.set(this._area, this._in(key), _.stringify(data), overwrite) || d;
                    },
                    setAll: function(data, overwrite) {
                        var changed, val;
                        for (var key in data) {
                            val = data[key];
                            if (this.set(key, val, overwrite) !== val) {
                                changed = true;
                            }
                        }
                        return changed;
                    },
                    remove: function(key) {
                        var d = this.get(key);
                        _.remove(this._area, this._in(key));
                        return d;
                    },
                    clear: function() {
                        if (!this._ns) {
                            _.clear(this._area);
                        } else {
                            this.each(function(k){ _.remove(this._area, this._in(k)); }, 1);
                        }
                        return this;
                    },
                    clearAll: function() {
                        var area = this._area;
                        for (var id in _.areas) {
                            if (_.areas.hasOwnProperty(id)) {
                                this._area = _.areas[id];
                                this.clear();
                            }
                        }
                        this._area = area;
                        return this;
                    },

                    // internal use functions
                    _in: function(k) {
                        if (typeof k !== "string"){ k = _.stringify(k); }
                        return this._ns ? this._ns + k : k;
                    },
                    _out: function(k) {
                        return this._ns ?
                            k && k.indexOf(this._ns) === 0 ?
                                k.substring(this._ns.length) :
                                undefined : // so each() knows to skip it
                            k;
                    }
                },// end _.storeAPI
                storageAPI: {
                    length: 0,
                    has: function(k){ return this.items.hasOwnProperty(k); },
                    key: function(i) {
                        var c = 0;
                        for (var k in this.items){
                            if (this.has(k) && i === c++) {
                                return k;
                            }
                        }
                    },
                    setItem: function(k, v) {
                        if (!this.has(k)) {
                            this.length++;
                        }
                        this.items[k] = v;
                    },
                    removeItem: function(k) {
                        if (this.has(k)) {
                            delete this.items[k];
                            this.length--;
                        }
                    },
                    getItem: function(k){ return this.has(k) ? this.items[k] : null; },
                    clear: function(){ for (var k in this.list){ this.removeItem(k); } },
                    toString: function(){ return this.length+' items in '+this.name+'Storage'; }
                }// end _.storageAPI
            };

            // setup the primary store fn
            if (window.store){ _.conflict = window.store; }
            var store =
                // safely set this up (throws error in IE10/32bit mode for local files)
                _.Store("local");
            store.local = store;// for completeness
            store._ = _;// for extenders and debuggers...
            // safely setup store.session (throws exception in FF for file:/// urls)
            store.area("session");

            //Expose store to the global object
            window.store = store;

            if (typeof define === 'function' && define.amd !== undefined) {
                define(function () {
                    return store;
                });
            } else if (module.exports) {
                module.exports = store;
            }

        })(this, this.define);
      }).call(context);

      queryString = context.queryString;
      store = context.store;

      function extend (obj) {
        if (!isObject(obj)) {
          return obj;
        }
        var source, prop;
        for (var i = 1, length = arguments.length; i < length; i++) {
          source = arguments[i];
          for (prop in source) {
            obj[prop] = source[prop];
          }
        }
        return obj;
      }

      function isArray (obj) {
        return '[object Array]' === Object.prototype.toString.call(obj);
      }

      function isObject (obj) {
        var type = typeof obj;
        return type === 'function' || type === 'object' && !!obj;
      }

      function isString (value) {
        return typeof value == 'string' || (value && typeof value == 'object' &&
          Object.prototype.toString.call(value) == '[object String]') || false;
      }

      function uuidv4 (){
        var d = perfnow().now();
        var uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
          var r = (d + Math.random()*16)%16 | 0;
          d = Math.floor(d/16);
          return (c=='x' ? r : (r&0x3|0x8)).toString(16);
        });
        return uuid;
      }

      var defaults = {
          transport: '',
          queueTimeout: 100
        },
        localStore = store.namespace('gumshoe'),
        storage = store.namespace('gumshoe').session,
        queue = storage('queue') || [],
        transports = {};

      if (!isArray(queue)) {
        queue = [];
      }

      function gumshoe (options) {
        var clientUuid = localStore('clientUuid');

        options = extend({}, defaults, options);

        // always ensure options.transport is an array.
        if (isString(options.transport)) {
          options.transport = [options.transport];
        }
        else if (!isArray(options.transport)) {
          throw 'Gumeshoe: Transport property must be a [String] or [Array].';
        }

        // store a client id to identify a client long-term. Google Analytics uses
        // the value, combined with other factors, to determine unique users. we
        // duplicate the same kind of value to assist GA.
        if (!clientUuid) {
          clientUuid = uuidv4();
          localStore({ clientUuid: clientUuid });
        }

        options.clientUuid = clientUuid;

        session(options.sessionFn);

        gumshoe.options = options;
      }

      function each (obj, iterator, context) {
        if (obj === null) {
          return;
        }

        if (Array.prototype.forEach && obj.forEach === Array.prototype.forEach) {
          obj.forEach(iterator, context);
        }
        else if (obj.length === +obj.length) {
          for (var i = 0, l = obj.length; i < l; i++) {
            if (iterator.call(context, obj[i], i, obj) === {}) {
              return;
            }
          }
        }
        else {
          for (var key in obj) {
            if (obj.hasOwnProperty(key)) {
              if (iterator.call(context, obj[key], key, obj) === {}) {
                return;
              }
            }
          }
        }
      }

      function map (obj, iterator, context) {
        var results = [];

        if (!obj) {
          return results;
        }

        if (Array.prototype.map && obj.map === Array.prototype.map) {
          return obj.map(iterator, context);
        }

        each(obj, function(value, index, list) {
          results[results.length] = iterator.call(context, value, index, list);
        });

        return results;
      }

      function collectPlugins () {
        var result,
          plugins = navigator.plugins || [];

        result = map(plugins, function (plugin) {
          var mimeTypes = map(plugin, function (mimeType) {
            var type = mimeType.type;

            if (mimeType.suffixes) {
              type += '~' + mimeType.suffixes;
            }

            return type;
          });

          return {
            description: plugin.description,
            filename: plugin.filename,
            mimeTypes: mimeTypes,
            name: plugin.name
          };
        });

        return result;
      }

      function collect () {

        function getViewport() {
          var e = window, a = 'inner';
          if (!('innerWidth' in window )) {
            a = 'client';
            e = document.documentElement || document.body;
          }
          return { width : e[ a+'Width' ] , height : e[ a+'Height' ] };
        }

        var viewport = getViewport(),
          query = queryString.parse(location.search),
          result = {
            // utmcs Character set (e.g. ISO-8859-1)
            characterSet: document.characterSet || document.charset || document.inputEncoding || 'Unknown',

            // utmsc Screen colour depth (e.g. 24-bit)
            colorDepth: screen.colorDepth + '',

            // gclid Gclid is a globally unique tracking parameter (Google Click Identifier)
            googleClickId: query.gclid || '',

            hash: window.location.hash,
            host: window.location.host,

            // utmhn Hostname
            hostName: window.location.hostname,

            // utmip IP address
            ipAddress: '',

            // utmje Java enabled?
            javaEnabled: navigator.javaEnabled ? navigator.javaEnabled() : false,

            // utmul Language code (e.g. en-us)
            language: window.navigator.userLanguage || window.navigator.language || 'Unknown',

            // login key: ?lk=
            loginKey: query.lk || '',

            // IE9 doesn't support this
            origin: window.location.origin || '',

            // utmp  Page path
            path: window.location.pathname,
            platform: window.navigator.platform,
            plugins: collectPlugins(),
            port: window.location.port || 80,
            // promotional key: pkey
            promotionKey: query.pkey || '',
            protocol: window.location.protocol,

            queryString: window.location.search,

            // utmr  Full referral URL
            referer: document.referrer,

            screenAvailHeight: screen.availHeight,
            screenAvailWidth: screen.availWidth,
            screenHeight: screen.height,
            screenOrientationAngle: '',
            screenOrientationType: '',
            screenPixelDepth: screen.pixelDepth + '',
            // utmsr Screen resolution
            screenResolution: screen.width + 'x' + screen.height,
            screenWidth: screen.width,

            // utmdt Page title
            title: document.title,

            url: window.location.href,
            userAgent: window.navigator.userAgent,
            utmCampaign: query.utm_campaign || '',
            utmContent: query.utm_content || '',
            utmMedium: query.utm_medium || '',
            utmSource: query.utm_source || '',
            utmTerm: query.utm_term || '',

            // utmvp Viewport resolution
            viewportHeight: viewport.height,
            viewportResolution: viewport.width + 'x' + viewport.height,
            viewportWidth: viewport.width
          },

          intFields = [
            'port', 'screenAvailHeight', 'screenAvailWidth', 'screenHeight',
            'screenOrientationAngle', 'screenWidth', 'viewportHeight', 'viewportWidth'
          ],
          prop,
          value;

        // some browsers don't support navigator.javaEnabled(), it's always undefined.
        if (result.javaEnabled === undefined) {
          result.javaEnabled = false;
        }

        // IE 8, 9 don't support this. Yay.
        if (screen.orientation) {
          result.screenOrientationAngle = parseInt(screen.orientation.angle ? screen.orientation.angle : '0');
          result.screenOrientationType = screen.orientation.type ? screen.orientation.type : '';

          if (isNaN(result.screenOrientationAngle)) {
            result.screenOrientationAngle = 0;
          }
        }

        // assert that these values are ints
        for (var i = 0; i < intFields.length; i++) {
          prop = intFields[i];
          value = parseInt(result[prop]);

          if (isNaN(value)) {
            value = 0;
          }

          result[prop] = value;
        }

        return result;
      }

      /**
       * @private
       * @method session
       *
       * @note
       * Gumshoe Session Rules
       *
       *  Generate a new Session ID if any of the following criteria are met:
       *
       *  1. User opens new tab or window (browser default behavior)
       *  2. User has been inactive longer than 30 minutes
       *  3. User has visited withinin the same session, but a UTM
       *     query string parameter has changed.
       */
      function session (fn) {

        // returns a simple object containing utm parameters
        function getUtm () {
          return {
            campaign: query.utm_campaign || '',
            medium: query.utm_medium || '',
            source: query.utm_source || '',
            utmTerm: query.utm_term || ''
          };
        }

        var now = (new Date()).getTime(),
          query = queryString.parse(location.search),
          lastUtm = storage('utm') || getUtm(),
          utm = getUtm(),
          timestamp,
          difference;

        // save the current state of the utm parameters
        storage('utm', utm);

        // set a session based uuid
        if (!storage('uuid')) {
          storage('uuid', uuidv4());
          storage('timestamp', now);
        }
        else {
          timestamp = storage('timestamp');
          difference = now - timestamp;

          if (fn) {
            /* jshint validthis: true */
            if (fn.call(this, timestamp, difference, query)) {
              storage('uuid', uuidv4());
            }
          }
          else if (JSON.stringify(lastUtm) !== JSON.stringify(utm) || difference > (1000 * 60 * 30)) {
            storage('uuid', uuidv4());
          }
        }
      }

      function send(eventName, eventData) {
        var pageData = collect(),
          baseData = {
            clientUuid: gumshoe.options.clientUuid,
            eventName: eventName,
            eventData: eventData || {},
            gumshoe: '0.8.1',
            pageData: pageData,
            sessionUuid: storage('uuid'),
            timestamp: (new Date()).getTime(),
            timezoneOffset: (new Date()).getTimezoneOffset(),
            uuid: uuidv4()
          };

        // since we're dealing with timeouts now, we need to reassert the
        // session ID for each event sent.
        session(gumshoe.options.sessionFn);

        if (gumshoe.options.transport) {
          for (var i = 0; i < gumshoe.options.transport.length; i++) {
            var transportName = gumshoe.options.transport[i],
              transport,
              data;

            if (transportName && transports[transportName]) {
              transport = transports[transportName];

              // allow each transport to extend the data with more information
              // or transform it how they'd like. transports cannot however,
              // modify eventData sent from the client.
              data = transport.map ? transport.map(baseData) : baseData;

              // extend our data with whatever came back from the transport
              data = extend(baseData, data);

              // TODO: remove this. gumshoe shouldn't care what format this is in
              if (!isString(data.eventData)) {
                data.eventData = JSON.stringify(data.eventData);
              }

              // TODO: remove this. gumshoe shouldn't care what format this is in
              if (!isString(data.pageData.plugins)) {
                data.pageData.plugins = JSON.stringify(data.pageData.plugins);
              }

              // TODO: remove this. temporary bugfix for apps
              if (!data.pageData.ipAddress) {
                data.pageData.ipAddress = '<unknown>';
              }

              pushEvent(eventName, transportName, data);
            }
            else {
              throw 'Gumshoe: The transport name: ' + transportName + ', doesn\'t map to a valid transport.';
            }
          }
        }

        /*if (!transportFound) {
          throw 'Gumshoe: No valid transports were found.';
        }*/
      }

      function nextEvent () {

        if (!queue.length) {
          return;
        }

        // granb the next event from the queue and remove it.
        var nevent = queue.shift(),
          transport = transports[nevent.transportName];

        storage('queue', queue);
        transport.send(nevent.data, function (err, result) {
          // we care if an error was thrown, created, or captured
          // if there is an error, add the item back into the queue
          if (err) {
            console.warn('Gumshoe: Retrying. Error received from transport: ' + nevent.transportName + ', for event: ' + nevent.eventName);
            queue.push(nevent);
          }
        });

        setTimeout(nextEvent, gumshoe.options.queueTimeout);
      }

      function pushEvent (eventName, transportName, data) {
        var transport;

        // if we're dealing with a fake storage object
        // (eg. sessionStorage isn't available) then don't
        // even bother queueing the data.
        if (storage.isFake()) {
          transport = transports[transportName];
          transport.send(data);

          return;
        }

        // add the event data to the queue
        queue.push({
          eventName: eventName,
          transportName: transportName,
          data: data
        });

        // put our newly modified queue in session storage
        storage('queue', queue);

        setTimeout(nextEvent, gumshoe.options.queueTimeout);
      }

      function transport (tp) {
        if (!tp.name) {
          throw 'Gumshoe: Transport [Object] must have a name defined.';
        }

        transports[tp.name] = tp;
      }

      // setup some static properties
      gumshoe.version = '0.8.1';
      gumshoe.options = {};

      // setup some static methods
      gumshoe.extend = extend;
      gumshoe.reqwest = context.reqwest;
      gumshoe.send = send;
      gumshoe.transport = transport;
      gumshoe.uuid = uuidv4;

      // setup some internal stuff for access
      gumshoe._ = {
        collect: collect,
        localStorage: localStore,
        queryString: queryString,
        queue: queue,
        storage: storage,
        transports: transports
      };

      return gumshoe;

      /*
      if (root.gumshoe) {
        if (root.gumshoe.ready) {
          root.gumshoe.ready = gumshoe.ready = root.gumshoe.ready;
          root.gumshoe = gumshoe;

          if (!isFunction(root.gumshoe.ready.resolve)) {
            throw 'Gumshoe: gumshoe.ready was predefined, but is not a Promise/A deferred.';
          }

          root.gumshoe.ready.resolve();
        }
      }
      else {
        root.gumshoe = gumshoe;
      }
      */

    }

    module.exports = gumshoeFactory;
    });

    /**
     * @module SDK
     */
    /**
     * The analytics collection endpoint.
     * @ignore
     */
    var ANALYTICS_ENDPOINT = 'https://info.muxy.io';
    /**
     * The Analytics class allows for sending events and metrics to Google Analytics
     * with a given UA_STRING.
     */
    var Analytics = /** @class */ (function () {
        function Analytics(uaString, loadPromise) {
            var _this = this;
            this.ready = false;
            this.uaString = uaString;
            this.loadPromise = loadPromise;
            this.user = null;
            this.gumshoe = gumshoe();
            this.gumshoe.transport({
                map: this.mapData.bind(this),
                name: 'muxy-extension-sdk',
                send: function (data, fn) {
                    var d = data;
                    // Remove stuff that we don't want to send up
                    delete d.pageData;
                    delete d.clientUuid;
                    delete d.uuid;
                    delete d.sessionUuid;
                    _this.gumshoe.reqwest({
                        contentType: 'application/x-www-form-urlencoded',
                        crossOrigin: true,
                        data: d,
                        method: 'POST',
                        url: ANALYTICS_ENDPOINT
                    }, function () {
                        if (fn) {
                            fn(null);
                        }
                    });
                }
            });
            this.gumshoe({ transport: 'muxy-extension-sdk' });
            this.loadPromise.then(function () {
                _this.ready = true;
            });
        }
        /**
         * Internal function to map event data to GA format.
         * @private
         */
        Analytics.prototype.mapData = function (data) {
            var appName = 'Muxy';
            var ip = '<unknown ip>';
            var channelID = null;
            var opaqueID = null;
            var userID = null;
            var role = null;
            var game = null;
            var videoMode = null;
            var latency = null;
            var bitrate = null;
            if (this.user) {
                ip = this.user.ip;
                channelID = this.user.channelID;
                opaqueID = this.user.twitchOpaqueID;
                userID = !opaqueID || opaqueID[0] !== 'U' ? null : opaqueID;
                role = this.user.role;
                game = this.user.game;
                videoMode = this.user.videoMode;
                latency = this.user.latency;
                bitrate = this.user.bitrate;
            }
            var pd = data.pageData;
            pd.ipAddress = ip;
            var result = {
                aid: appName,
                an: appName,
                cd1: channelID,
                cd2: role,
                cd3: game,
                cd4: videoMode,
                cid: opaqueID || data.clientUuid || data.sessionUuid || '00000000-0000-0000-0000-000000000000',
                cm2: latency,
                cm3: bitrate,
                dh: pd.hostName,
                dl: pd.url,
                dp: pd.path,
                dr: pd.referer,
                dt: pd.title,
                ea: undefined,
                ec: undefined,
                el: undefined,
                ev: undefined,
                je: pd.javaEnabled,
                sr: pd.screenResolution,
                t: 'event',
                tid: this.uaString,
                ua: pd.userAgent,
                uid: userID,
                uip: ip,
                ul: pd.language,
                v: 1,
                vp: pd.viewportHeight + "x" + pd.viewportWidth
            };
            if (data.eventName === 'page.view') {
                result.t = 'pageview';
            }
            else {
                result.ec = data.eventName;
                result.ea = data.eventData.name;
                result.el = data.eventData.label;
                result.ev = data.eventData.value;
            }
            return result;
        };
        /**
         * Sends an arbitrary even to Google Analytics.
         *
         * @param {string} category - The high-level category to collect this event under.
         * @param {string} name - A unique identifier for this event.
         * @param {*} value - (optional) A value to associate with this event (defaults to 1).
         * @param {string} label - (optional) A human-readable label for this event.
         */
        Analytics.prototype.sendEvent = function (category, name, value, label) {
            if (value === void 0) { value = 1; }
            if (label === void 0) { label = ''; }
            if (!this.ready) {
                throw new Error('muxy.Analytics used before ready');
            }
            var data = { name: name, value: value, label: label };
            this.gumshoe.send(category, data);
        };
        /**
         * Sends a simple page view event to Google Analytics.
         */
        Analytics.prototype.pageView = function () {
            if (!this.ready) {
                throw new Error('muxy.Analytics used before ready');
            }
            this.gumshoe.send('page.view', {});
        };
        return Analytics;
    }());

    var DebuggingOptions = /** @class */ (function () {
        function DebuggingOptions() {
            var noop = function () {
                var args = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    args[_i] = arguments[_i];
                }
                /* Default to doing nothing on callback */
            };
            this.options = {
                onPubsubListen: noop,
                onPubsubReceive: noop,
                onPubsubSend: noop
            };
            if (window.location && window.location.search) {
                var qp = new URLSearchParams(window.location.search);
                this.options.url = this.readFromQuery(qp, 'url');
                this.options.url = this.readFromQuery(qp, 'channelID');
                this.options.url = this.readFromQuery(qp, 'userID');
                this.options.url = this.readFromQuery(qp, 'role');
                this.options.url = this.readFromQuery(qp, 'environment');
            }
        }
        DebuggingOptions.prototype.url = function (url) {
            this.options.url = /^https?:\/\//.test(url) ? url : "https://" + url;
            return this;
        };
        DebuggingOptions.prototype.channelID = function (cid) {
            this.options.channelID = cid;
            return this;
        };
        DebuggingOptions.prototype.userID = function (uid) {
            this.options.userID = uid;
            return this;
        };
        DebuggingOptions.prototype.role = function (r) {
            this.options.role = r;
            return this;
        };
        DebuggingOptions.prototype.jwt = function (j) {
            this.options.jwt = j;
            return this;
        };
        DebuggingOptions.prototype.environment = function (e) {
            this.options.environment = e;
            return this;
        };
        DebuggingOptions.prototype.onPubsubSend = function (cb) {
            this.options.onPubsubSend = cb;
            return this;
        };
        DebuggingOptions.prototype.onPubsubReceive = function (cb) {
            this.options.onPubsubReceive = cb;
            return this;
        };
        DebuggingOptions.prototype.onPubsubListen = function (cb) {
            this.options.onPubsubListen = cb;
            return this;
        };
        DebuggingOptions.prototype.readFromQuery = function (params, key) {
            return params.get("muxy_debug_" + key);
        };
        return DebuggingOptions;
    }());

    var pusher = createCommonjsModule(function (module, exports) {
    /*!
     * Pusher JavaScript Library v4.3.1
     * https://pusher.com/
     *
     * Copyright 2017, Pusher
     * Released under the MIT licence.
     */

    (function webpackUniversalModuleDefinition(root, factory) {
    	module.exports = factory();
    })(commonjsGlobal, 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] = {
    /******/ 			exports: {},
    /******/ 			id: moduleId,
    /******/ 			loaded: false
    /******/ 		};

    /******/ 		// Execute the module function
    /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

    /******/ 		// Flag the module as loaded
    /******/ 		module.loaded = 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;

    /******/ 	// __webpack_public_path__
    /******/ 	__webpack_require__.p = "";

    /******/ 	// Load entry module and return exports
    /******/ 	return __webpack_require__(0);
    /******/ })
    /************************************************************************/
    /******/ ([
    /* 0 */
    /***/ (function(module, exports, __webpack_require__) {
    	var pusher_1 = __webpack_require__(1);
    	module.exports = pusher_1["default"];


    /***/ }),
    /* 1 */
    /***/ (function(module, exports, __webpack_require__) {
    	var runtime_1 = __webpack_require__(2);
    	var Collections = __webpack_require__(9);
    	var dispatcher_1 = __webpack_require__(24);
    	var timeline_1 = __webpack_require__(39);
    	var level_1 = __webpack_require__(40);
    	var StrategyBuilder = __webpack_require__(41);
    	var timers_1 = __webpack_require__(12);
    	var defaults_1 = __webpack_require__(5);
    	var DefaultConfig = __webpack_require__(71);
    	var logger_1 = __webpack_require__(8);
    	var factory_1 = __webpack_require__(43);
    	var url_store_1 = __webpack_require__(14);
    	var 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_1["default"].buildLogSuffix("javascriptQuickStart");
    	            logger_1["default"].warn("You should always specify a cluster when connecting. " + suffix);
    	        }
    	        this.key = app_key;
    	        this.config = Collections.extend(DefaultConfig.getGlobalConfig(), options.cluster ? DefaultConfig.getClusterConfig(options.cluster) : {}, options);
    	        this.channels = factory_1["default"].createChannels();
    	        this.global_emitter = new dispatcher_1["default"]();
    	        this.sessionID = Math.floor(Math.random() * 1000000000);
    	        this.timeline = new timeline_1["default"](this.key, this.sessionID, {
    	            cluster: this.config.cluster,
    	            features: Pusher.getClientFeatures(),
    	            params: this.config.timelineParams || {},
    	            limit: 50,
    	            level: level_1["default"].INFO,
    	            version: defaults_1["default"].VERSION
    	        });
    	        if (!this.config.disableStats) {
    	            this.timelineSender = factory_1["default"].createTimelineSender(this.timeline, {
    	                host: this.config.statsHost,
    	                path: "/timeline/v2/" + runtime_1["default"].TimelineTransport.name
    	            });
    	        }
    	        var getStrategy = function (options) {
    	            var config = Collections.extend({}, _this.config, options);
    	            return StrategyBuilder.build(runtime_1["default"].getDefaultStrategy(config), config);
    	        };
    	        this.connection = factory_1["default"].createConnectionManager(this.key, Collections.extend({ getStrategy: getStrategy,
    	            timeline: this.timeline,
    	            activityTimeout: this.config.activity_timeout,
    	            pongTimeout: this.config.pong_timeout,
    	            unavailableTimeout: this.config.unavailable_timeout
    	        }, this.config, { useTLS: this.shouldUseTLS() }));
    	        this.connection.bind('connected', function () {
    	            _this.subscribeAll();
    	            if (_this.timelineSender) {
    	                _this.timelineSender.send(_this.connection.isUsingTLS());
    	            }
    	        });
    	        this.connection.bind('message', function (params) {
    	            var internal = (params.event.indexOf('pusher_internal:') === 0);
    	            if (params.channel) {
    	                var channel = _this.channel(params.channel);
    	                if (channel) {
    	                    channel.handleEvent(params.event, params.data);
    	                }
    	            }
    	            if (!internal) {
    	                _this.global_emitter.emit(params.event, params.data);
    	            }
    	        });
    	        this.connection.bind('connecting', function () {
    	            _this.channels.disconnect();
    	        });
    	        this.connection.bind('disconnected', function () {
    	            _this.channels.disconnect();
    	        });
    	        this.connection.bind('error', function (err) {
    	            logger_1["default"].warn('Error', 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.log = function (message) {
    	        if (Pusher.logToConsole && (window).console && (window).console.log) {
    	            (window).console.log(message);
    	        }
    	    };
    	    Pusher.getClientFeatures = function () {
    	        return Collections.keys(Collections.filterObject({ "ws": runtime_1["default"].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 timers_1.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 && this.connection.state === "connected") {
    	                channel.unsubscribe();
    	            }
    	        }
    	    };
    	    Pusher.prototype.send_event = function (event_name, data, channel) {
    	        return this.connection.send_event(event_name, data, channel);
    	    };
    	    Pusher.prototype.shouldUseTLS = function () {
    	        if (runtime_1["default"].getProtocol() === "https:") {
    	            return true;
    	        }
    	        else if (this.config.forceTLS === true) {
    	            return true;
    	        }
    	        else {
    	            return Boolean(this.config.encrypted);
    	        }
    	    };
    	    Pusher.instances = [];
    	    Pusher.isReady = false;
    	    Pusher.logToConsole = false;
    	    Pusher.Runtime = runtime_1["default"];
    	    Pusher.ScriptReceivers = runtime_1["default"].ScriptReceivers;
    	    Pusher.DependenciesReceivers = runtime_1["default"].DependenciesReceivers;
    	    Pusher.auth_callbacks = runtime_1["default"].auth_callbacks;
    	    return Pusher;
    	}());
    	exports.__esModule = true;
    	exports["default"] = Pusher;
    	function checkAppKey(key) {
    	    if (key === null || key === undefined) {
    	        throw "You must pass your app key when you instantiate Pusher.";
    	    }
    	}
    	runtime_1["default"].setup(Pusher);


    /***/ }),
    /* 2 */
    /***/ (function(module, exports, __webpack_require__) {
    	var dependencies_1 = __webpack_require__(3);
    	var xhr_auth_1 = __webpack_require__(7);
    	var jsonp_auth_1 = __webpack_require__(15);
    	var script_request_1 = __webpack_require__(16);
    	var jsonp_request_1 = __webpack_require__(17);
    	var script_receiver_factory_1 = __webpack_require__(4);
    	var jsonp_timeline_1 = __webpack_require__(18);
    	var transports_1 = __webpack_require__(19);
    	var net_info_1 = __webpack_require__(26);
    	var default_strategy_1 = __webpack_require__(27);
    	var transport_connection_initializer_1 = __webpack_require__(28);
    	var http_1 = __webpack_require__(29);
    	var Runtime = {
    	    nextAuthCallbackID: 1,
    	    auth_callbacks: {},
    	    ScriptReceivers: script_receiver_factory_1.ScriptReceivers,
    	    DependenciesReceivers: dependencies_1.DependenciesReceivers,
    	    getDefaultStrategy: default_strategy_1["default"],
    	    Transports: transports_1["default"],
    	    transportConnectionInitializer: transport_connection_initializer_1["default"],
    	    HTTPFactory: http_1["default"],
    	    TimelineTransport: jsonp_timeline_1["default"],
    	    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_1.Dependencies.load("json2", {}, initializeOnDocumentBody);
    	        }
    	        else {
    	            initializeOnDocumentBody();
    	        }
    	    },
    	    getDocument: function () {
    	        return document;
    	    },
    	    getProtocol: function () {
    	        return this.getDocument().location.protocol;
    	    },
    	    getAuthorizers: function () {
    	        return { ajax: xhr_auth_1["default"], jsonp: jsonp_auth_1["default"] };
    	    },
    	    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_1["default"](url, data);
    	    },
    	    createScriptRequest: function (src) {
    	        return new script_request_1["default"](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_1.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);
    	        }
    	    }
    	};
    	exports.__esModule = true;
    	exports["default"] = Runtime;


    /***/ }),
    /* 3 */
    /***/ (function(module, exports, __webpack_require__) {
    	var script_receiver_factory_1 = __webpack_require__(4);
    	var defaults_1 = __webpack_require__(5);
    	var dependency_loader_1 = __webpack_require__(6);
    	exports.DependenciesReceivers = new script_receiver_factory_1.ScriptReceiverFactory("_pusher_dependencies", "Pusher.DependenciesReceivers");
    	exports.Dependencies = new dependency_loader_1["default"]({
    	    cdn_http: defaults_1["default"].cdn_http,
    	    cdn_https: defaults_1["default"].cdn_https,
    	    version: defaults_1["default"].VERSION,
    	    suffix: defaults_1["default"].dependency_suffix,
    	    receivers: exports.DependenciesReceivers
    	});


    /***/ }),
    /* 4 */
    /***/ (function(module, exports) {
    	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;
    	}());
    	exports.ScriptReceiverFactory = ScriptReceiverFactory;
    	exports.ScriptReceivers = new ScriptReceiverFactory("_pusher_script_", "Pusher.ScriptReceivers");


    /***/ }),
    /* 5 */
    /***/ (function(module, exports) {
    	var Defaults = {
    	    VERSION: "4.3.1",
    	    PROTOCOL: 7,
    	    host: 'ws.pusherapp.com',
    	    ws_port: 80,
    	    wss_port: 443,
    	    ws_path: '',
    	    sockjs_host: 'sockjs.pusher.com',
    	    sockjs_http_port: 80,
    	    sockjs_https_port: 443,
    	    sockjs_path: "/pusher",
    	    stats_host: 'stats.pusher.com',
    	    channel_auth_endpoint: '/pusher/auth',
    	    channel_auth_transport: 'ajax',
    	    activity_timeout: 120000,
    	    pong_timeout: 30000,
    	    unavailable_timeout: 10000,
    	    cdn_http: 'http://js.pusher.com',
    	    cdn_https: 'https://js.pusher.com',
    	    dependency_suffix: ''
    	};
    	exports.__esModule = true;
    	exports["default"] = Defaults;


    /***/ }),
    /* 6 */
    /***/ (function(module, exports, __webpack_require__) {
    	var script_receiver_factory_1 = __webpack_require__(4);
    	var runtime_1 = __webpack_require__(2);
    	var DependencyLoader = (function () {
    	    function DependencyLoader(options) {
    	        this.options = options;
    	        this.receivers = options.receivers || script_receiver_factory_1.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_1["default"].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_1["default"].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;
    	}());
    	exports.__esModule = true;
    	exports["default"] = DependencyLoader;


    /***/ }),
    /* 7 */
    /***/ (function(module, exports, __webpack_require__) {
    	var logger_1 = __webpack_require__(8);
    	var runtime_1 = __webpack_require__(2);
    	var url_store_1 = __webpack_require__(14);
    	var ajax = function (context, socketId, callback) {
    	    var self = this, xhr;
    	    xhr = runtime_1["default"].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, parsed = false;
    	                try {
    	                    data = JSON.parse(xhr.responseText);
    	                    parsed = true;
    	                }
    	                catch (e) {
    	                    callback(true, 'JSON returned from webapp was invalid, yet status code was 200. Data was: ' + xhr.responseText);
    	                }
    	                if (parsed) {
    	                    callback(false, data);
    	                }
    	            }
    	            else {
    	                var suffix = url_store_1["default"].buildLogSuffix("authenticationEndpoint");
    	                logger_1["default"].warn(("Couldn't retrieve authentication info. " + xhr.status) +
    	                    ("Clients must be authenticated to join private or presence channels. " + suffix));
    	                callback(true, xhr.status);
    	            }
    	        }
    	    };
    	    xhr.send(this.composeQuery(socketId));
    	    return xhr;
    	};
    	exports.__esModule = true;
    	exports["default"] = ajax;


    /***/ }),
    /* 8 */
    /***/ (function(module, exports, __webpack_require__) {
    	var collections_1 = __webpack_require__(9);
    	var pusher_1 = __webpack_require__(1);
    	var Logger = {
    	    debug: function () {
    	        var args = [];
    	        for (var _i = 0; _i < arguments.length; _i++) {
    	            args[_i - 0] = arguments[_i];
    	        }
    	        if (!pusher_1["default"].log) {
    	            return;
    	        }
    	        pusher_1["default"].log(collections_1.stringify.apply(this, arguments));
    	    },
    	    warn: function () {
    	        var args = [];
    	        for (var _i = 0; _i < arguments.length; _i++) {
    	            args[_i - 0] = arguments[_i];
    	        }
    	        var message = collections_1.stringify.apply(this, arguments);
    	        if (pusher_1["default"].log) {
    	            pusher_1["default"].log(message);
    	        }
    	        else if ((window).console) {
    	            if ((window).console.warn) {
    	                (window).console.warn(message);
    	            }
    	            else if ((window).console.log) {
    	                (window).console.log(message);
    	            }
    	        }
    	    }
    	};
    	exports.__esModule = true;
    	exports["default"] = Logger;


    /***/ }),
    /* 9 */
    /***/ (function(module, exports, __webpack_require__) {
    	var base64_1 = __webpack_require__(10);
    	var util_1 = __webpack_require__(11);
    	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;
    	}
    	exports.extend = extend;
    	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(" : ");
    	}
    	exports.stringify = stringify;
    	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;
    	}
    	exports.arrayIndexOf = arrayIndexOf;
    	function objectApply(object, f) {
    	    for (var key in object) {
    	        if (Object.prototype.hasOwnProperty.call(object, key)) {
    	            f(object[key], key, object);
    	        }
    	    }
    	}
    	exports.objectApply = objectApply;
    	function keys(object) {
    	    var keys = [];
    	    objectApply(object, function (_, key) {
    	        keys.push(key);
    	    });
    	    return keys;
    	}
    	exports.keys = keys;
    	function values(object) {
    	    var values = [];
    	    objectApply(object, function (value) {
    	        values.push(value);
    	    });
    	    return values;
    	}
    	exports.values = values;
    	function apply(array, f, context) {
    	    for (var i = 0; i < array.length; i++) {
    	        f.call(context || (window), array[i], i, array);
    	    }
    	}
    	exports.apply = apply;
    	function map(array, f) {
    	    var result = [];
    	    for (var i = 0; i < array.length; i++) {
    	        result.push(f(array[i], i, array, result));
    	    }
    	    return result;
    	}
    	exports.map = map;
    	function mapObject(object, f) {
    	    var result = {};
    	    objectApply(object, function (value, key) {
    	        result[key] = f(value);
    	    });
    	    return result;
    	}
    	exports.mapObject = mapObject;
    	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;
    	}
    	exports.filter = filter;
    	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;
    	}
    	exports.filterObject = filterObject;
    	function flatten(object) {
    	    var result = [];
    	    objectApply(object, function (value, key) {
    	        result.push([key, value]);
    	    });
    	    return result;
    	}
    	exports.flatten = flatten;
    	function any(array, test) {
    	    for (var i = 0; i < array.length; i++) {
    	        if (test(array[i], i, array)) {
    	            return true;
    	        }
    	    }
    	    return false;
    	}
    	exports.any = any;
    	function all(array, test) {
    	    for (var i = 0; i < array.length; i++) {
    	        if (!test(array[i], i, array)) {
    	            return false;
    	        }
    	    }
    	    return true;
    	}
    	exports.all = all;
    	function encodeParamsObject(data) {
    	    return mapObject(data, function (value) {
    	        if (typeof value === "object") {
    	            value = safeJSONStringify(value);
    	        }
    	        return encodeURIComponent(base64_1["default"](value.toString()));
    	    });
    	}
    	exports.encodeParamsObject = encodeParamsObject;
    	function buildQueryString(data) {
    	    var params = filterObject(data, function (value) {
    	        return value !== undefined;
    	    });
    	    var query = map(flatten(encodeParamsObject(params)), util_1["default"].method("join", "=")).join("&");
    	    return query;
    	}
    	exports.buildQueryString = buildQueryString;
    	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, '$'));
    	}
    	exports.decycleObject = decycleObject;
    	function safeJSONStringify(source) {
    	    try {
    	        return JSON.stringify(source);
    	    }
    	    catch (e) {
    	        return JSON.stringify(decycleObject(source));
    	    }
    	}
    	exports.safeJSONStringify = safeJSONStringify;


    /***/ }),
    /* 10 */
    /***/ (function(module, exports, __webpack_require__) {
    	function encode(s) {
    	    return btoa(utob(s));
    	}
    	exports.__esModule = true;
    	exports["default"] = encode;
    	var fromCharCode = String.fromCharCode;
    	var b64chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
    	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);
    	};


    /***/ }),
    /* 11 */
    /***/ (function(module, exports, __webpack_require__) {
    	var timers_1 = __webpack_require__(12);
    	var Util = {
    	    now: function () {
    	        if (Date.now) {
    	            return Date.now();
    	        }
    	        else {
    	            return new Date().valueOf();
    	        }
    	    },
    	    defer: function (callback) {
    	        return new timers_1.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));
    	        };
    	    }
    	};
    	exports.__esModule = true;
    	exports["default"] = Util;


    /***/ }),
    /* 12 */
    /***/ (function(module, exports, __webpack_require__) {
    	var __extends = (this && this.__extends) || function (d, b) {
    	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    	    function __() { this.constructor = d; }
    	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    	};
    	var abstract_timer_1 = __webpack_require__(13);
    	function clearTimeout(timer) {
    	    (window).clearTimeout(timer);
    	}
    	function clearInterval(timer) {
    	    (window).clearInterval(timer);
    	}
    	var OneOffTimer = (function (_super) {
    	    __extends(OneOffTimer, _super);
    	    function OneOffTimer(delay, callback) {
    	        _super.call(this, setTimeout, clearTimeout, delay, function (timer) {
    	            callback();
    	            return null;
    	        });
    	    }
    	    return OneOffTimer;
    	}(abstract_timer_1["default"]));
    	exports.OneOffTimer = OneOffTimer;
    	var PeriodicTimer = (function (_super) {
    	    __extends(PeriodicTimer, _super);
    	    function PeriodicTimer(delay, callback) {
    	        _super.call(this, setInterval, clearInterval, delay, function (timer) {
    	            callback();
    	            return timer;
    	        });
    	    }
    	    return PeriodicTimer;
    	}(abstract_timer_1["default"]));
    	exports.PeriodicTimer = PeriodicTimer;


    /***/ }),
    /* 13 */
    /***/ (function(module, exports) {
    	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;
    	}());
    	exports.__esModule = true;
    	exports["default"] = Timer;


    /***/ }),
    /* 14 */
    /***/ (function(module, exports) {
    	var urlStore = {
    	    baseUrl: "https://pusher.com",
    	    urls: {
    	        authenticationEndpoint: {
    	            path: "/docs/authenticating_users"
    	        },
    	        javascriptQuickStart: {
    	            path: "/docs/javascript_quick_start"
    	        }
    	    }
    	};
    	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;
    	};
    	exports.__esModule = true;
    	exports["default"] = { buildLogSuffix: buildLogSuffix };


    /***/ }),
    /* 15 */
    /***/ (function(module, exports, __webpack_require__) {
    	var logger_1 = __webpack_require__(8);
    	var jsonp = function (context, socketId, callback) {
    	    if (this.authOptions.headers !== undefined) {
    	        logger_1["default"].warn("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(false, 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);
    	};
    	exports.__esModule = true;
    	exports["default"] = jsonp;


    /***/ }),
    /* 16 */
    /***/ (function(module, exports) {
    	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;
    	}());
    	exports.__esModule = true;
    	exports["default"] = ScriptRequest;


    /***/ }),
    /* 17 */
    /***/ (function(module, exports, __webpack_require__) {
    	var Collections = __webpack_require__(9);
    	var runtime_1 = __webpack_require__(2);
    	var JSONPRequest = (function () {
    	    function JSONPRequest(url, data) {
    	        this.url = url;
    	        this.data = data;
    	    }
    	    JSONPRequest.prototype.send = function (receiver) {
    	        if (this.request) {
    	            return;
    	        }
    	        var query = Collections.buildQueryString(this.data);
    	        var url = this.url + "/" + receiver.number + "?" + query;
    	        this.request = runtime_1["default"].createScriptRequest(url);
    	        this.request.send(receiver);
    	    };
    	    JSONPRequest.prototype.cleanup = function () {
    	        if (this.request) {
    	            this.request.cleanup();
    	        }
    	    };
    	    return JSONPRequest;
    	}());
    	exports.__esModule = true;
    	exports["default"] = JSONPRequest;


    /***/ }),
    /* 18 */
    /***/ (function(module, exports, __webpack_require__) {
    	var runtime_1 = __webpack_require__(2);
    	var script_receiver_factory_1 = __webpack_require__(4);
    	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_1["default"].createJSONPRequest(url, data);
    	        var receiver = runtime_1["default"].ScriptReceivers.create(function (error, result) {
    	            script_receiver_factory_1.ScriptReceivers.remove(receiver);
    	            request.cleanup();
    	            if (result && result.host) {
    	                sender.host = result.host;
    	            }
    	            if (callback) {
    	                callback(error, result);
    	            }
    	        });
    	        request.send(receiver);
    	    };
    	};
    	var jsonp = {
    	    name: 'jsonp',
    	    getAgent: getAgent
    	};
    	exports.__esModule = true;
    	exports["default"] = jsonp;


    /***/ }),
    /* 19 */
    /***/ (function(module, exports, __webpack_require__) {
    	var transports_1 = __webpack_require__(20);
    	var transport_1 = __webpack_require__(22);
    	var URLSchemes = __webpack_require__(21);
    	var runtime_1 = __webpack_require__(2);
    	var dependencies_1 = __webpack_require__(3);
    	var Collections = __webpack_require__(9);
    	var SockJSTransport = new transport_1["default"]({
    	    file: "sockjs",
    	    urls: URLSchemes.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_1.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_1["default"].isXDRSupported(environment.useTLS);
    	        return yes;
    	    }
    	};
    	var XDRStreamingTransport = new transport_1["default"](Collections.extend({}, transports_1.streamingConfiguration, xdrConfiguration));
    	var XDRPollingTransport = new transport_1["default"](Collections.extend({}, transports_1.pollingConfiguration, xdrConfiguration));
    	transports_1["default"].xdr_streaming = XDRStreamingTransport;
    	transports_1["default"].xdr_polling = XDRPollingTransport;
    	transports_1["default"].sockjs = SockJSTransport;
    	exports.__esModule = true;
    	exports["default"] = transports_1["default"];


    /***/ }),
    /* 20 */
    /***/ (function(module, exports, __webpack_require__) {
    	var URLSchemes = __webpack_require__(21);
    	var transport_1 = __webpack_require__(22);
    	var Collections = __webpack_require__(9);
    	var runtime_1 = __webpack_require__(2);
    	var WSTransport = new transport_1["default"]({
    	    urls: URLSchemes.ws,
    	    handlesActivityChecks: false,
    	    supportsPing: false,
    	    isInitialized: function () {
    	        return Boolean(runtime_1["default"].getWebSocketAPI());
    	    },
    	    isSupported: function () {
    	        return Boolean(runtime_1["default"].getWebSocketAPI());
    	    },
    	    getSocket: function (url) {
    	        return runtime_1["default"].createWebSocket(url);
    	    }
    	});
    	var httpConfiguration = {
    	    urls: URLSchemes.http,
    	    handlesActivityChecks: false,
    	    supportsPing: true,
    	    isInitialized: function () {
    	        return true;
    	    }
    	};
    	exports.streamingConfiguration = Collections.extend({ getSocket: function (url) {
    	        return runtime_1["default"].HTTPFactory.createStreamingSocket(url);
    	    }
    	}, httpConfiguration);
    	exports.pollingConfiguration = Collections.extend({ getSocket: function (url) {
    	        return runtime_1["default"].HTTPFactory.createPollingSocket(url);
    	    }
    	}, httpConfiguration);
    	var xhrConfiguration = {
    	    isSupported: function () {
    	        return runtime_1["default"].isXHRSupported();
    	    }
    	};
    	var XHRStreamingTransport = new transport_1["default"](Collections.extend({}, exports.streamingConfiguration, xhrConfiguration));
    	var XHRPollingTransport = new transport_1["default"](Collections.extend({}, exports.pollingConfiguration, xhrConfiguration));
    	var Transports = {
    	    ws: WSTransport,
    	    xhr_streaming: XHRStreamingTransport,
    	    xhr_polling: XHRPollingTransport
    	};
    	exports.__esModule = true;
    	exports["default"] = Transports;


    /***/ }),
    /* 21 */
    /***/ (function(module, exports, __webpack_require__) {
    	var defaults_1 = __webpack_require__(5);
    	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_1["default"].PROTOCOL +
    	        "&client=js" +
    	        "&version=" + defaults_1["default"].VERSION +
    	        (queryString ? ("&" + queryString) : "");
    	    return path + query;
    	}
    	exports.ws = {
    	    getInitial: function (key, params) {
    	        var path = (params.httpPath || "") + getGenericPath(key, "flash=false");
    	        return getGenericURL("ws", params, path);
    	    }
    	};
    	exports.http = {
    	    getInitial: function (key, params) {
    	        var path = (params.httpPath || "/pusher") + getGenericPath(key);
    	        return getGenericURL("http", params, path);
    	    }
    	};
    	exports.sockjs = {
    	    getInitial: function (key, params) {
    	        return getGenericURL("http", params, params.httpPath || "/pusher");
    	    },
    	    getPath: function (key, params) {
    	        return getGenericPath(key);
    	    }
    	};


    /***/ }),
    /* 22 */
    /***/ (function(module, exports, __webpack_require__) {
    	var transport_connection_1 = __webpack_require__(23);
    	var 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_1["default"](this.hooks, name, priority, key, options);
    	    };
    	    return Transport;
    	}());
    	exports.__esModule = true;
    	exports["default"] = Transport;


    /***/ }),
    /* 23 */
    /***/ (function(module, exports, __webpack_require__) {
    	var __extends = (this && this.__extends) || function (d, b) {
    	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    	    function __() { this.constructor = d; }
    	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    	};
    	var util_1 = __webpack_require__(11);
    	var Collections = __webpack_require__(9);
    	var dispatcher_1 = __webpack_require__(24);
    	var logger_1 = __webpack_require__(8);
    	var runtime_1 = __webpack_require__(2);
    	var TransportConnection = (function (_super) {
    	    __extends(TransportConnection, _super);
    	    function TransportConnection(hooks, name, priority, key, options) {
    	        _super.call(this);
    	        this.initialize = runtime_1["default"].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();
    	    }
    	    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_1["default"].defer(function () {
    	                _this.onError(e);
    	                _this.changeState("closed");
    	            });
    	            return false;
    	        }
    	        this.bindListeners();
    	        logger_1["default"].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_1["default"].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 Collections.extend({ cid: this.id }, message);
    	    };
    	    return TransportConnection;
    	}(dispatcher_1["default"]));
    	exports.__esModule = true;
    	exports["default"] = TransportConnection;


    /***/ }),
    /* 24 */
    /***/ (function(module, exports, __webpack_require__) {
    	var Collections = __webpack_require__(9);
    	var callback_registry_1 = __webpack_require__(25);
    	var Dispatcher = (function () {
    	    function Dispatcher(failThrough) {
    	        this.callbacks = new callback_registry_1["default"]();
    	        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 = Collections.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) {
    	        var i;
    	        for (i = 0; i < this.global_callbacks.length; i++) {
    	            this.global_callbacks[i](eventName, data);
    	        }
    	        var callbacks = this.callbacks.get(eventName);
    	        if (callbacks && callbacks.length > 0) {
    	            for (i = 0; i < callbacks.length; i++) {
    	                callbacks[i].fn.call(callbacks[i].context || (window), data);
    	            }
    	        }
    	        else if (this.failThrough) {
    	            this.failThrough(eventName, data);
    	        }
    	        return this;
    	    };
    	    return Dispatcher;
    	}());
    	exports.__esModule = true;
    	exports["default"] = Dispatcher;


    /***/ }),
    /* 25 */
    /***/ (function(module, exports, __webpack_require__) {
    	var Collections = __webpack_require__(9);
    	var 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)] : Collections.keys(this._callbacks);
    	        if (callback || context) {
    	            this.removeCallback(names, callback, context);
    	        }
    	        else {
    	            this.removeAllCallbacks(names);
    	        }
    	    };
    	    CallbackRegistry.prototype.removeCallback = function (names, callback, context) {
    	        Collections.apply(names, function (name) {
    	            this._callbacks[name] = Collections.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) {
    	        Collections.apply(names, function (name) {
    	            delete this._callbacks[name];
    	        }, this);
    	    };
    	    return CallbackRegistry;
    	}());
    	exports.__esModule = true;
    	exports["default"] = CallbackRegistry;
    	function prefix(name) {
    	    return "_" + name;
    	}


    /***/ }),
    /* 26 */
    /***/ (function(module, exports, __webpack_require__) {
    	var __extends = (this && this.__extends) || function (d, b) {
    	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    	    function __() { this.constructor = d; }
    	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    	};
    	var dispatcher_1 = __webpack_require__(24);
    	var NetInfo = (function (_super) {
    	    __extends(NetInfo, _super);
    	    function NetInfo() {
    	        _super.call(this);
    	        var self = this;
    	        if (window.addEventListener !== undefined) {
    	            window.addEventListener("online", function () {
    	                self.emit('online');
    	            }, false);
    	            window.addEventListener("offline", function () {
    	                self.emit('offline');
    	            }, false);
    	        }
    	    }
    	    NetInfo.prototype.isOnline = function () {
    	        if (window.navigator.onLine === undefined) {
    	            return true;
    	        }
    	        else {
    	            return window.navigator.onLine;
    	        }
    	    };
    	    return NetInfo;
    	}(dispatcher_1["default"]));
    	exports.NetInfo = NetInfo;
    	exports.Network = new NetInfo();


    /***/ }),
    /* 27 */
    /***/ (function(module, exports) {
    	var getDefaultStrategy = function (config) {
    	    var wsStrategy;
    	    if (config.useTLS) {
    	        wsStrategy = [
    	            ":best_connected_ever",
    	            ":ws_loop",
    	            [":delayed", 2000, [":http_fallback_loop"]]
    	        ];
    	    }
    	    else {
    	        wsStrategy = [
    	            ":best_connected_ever",
    	            ":ws_loop",
    	            [":delayed", 2000, [":wss_loop"]],
    	            [":delayed", 5000, [":http_fallback_loop"]]
    	        ];
    	    }
    	    return [
    	        [":def", "ws_options", {
    	                hostNonTLS: config.wsHost + ":" + config.wsPort,
    	                hostTLS: config.wsHost + ":" + config.wssPort,
    	                httpPath: config.wsPath
    	            }],
    	        [":def", "wss_options", [":extend", ":ws_options", {
    	                    useTLS: true
    	                }]],
    	        [":def", "sockjs_options", {
    	                hostNonTLS: config.httpHost + ":" + config.httpPort,
    	                hostTLS: config.httpHost + ":" + config.httpsPort,
    	                httpPath: config.httpPath
    	            }],
    	        [":def", "timeouts", {
    	                loop: true,
    	                timeout: 15000,
    	                timeoutLimit: 60000
    	            }],
    	        [":def", "ws_manager", [":transport_manager", {
    	                    lives: 2,
    	                    minPingDelay: 10000,
    	                    maxPingDelay: config.activity_timeout
    	                }]],
    	        [":def", "streaming_manager", [":transport_manager", {
    	                    lives: 2,
    	                    minPingDelay: 10000,
    	                    maxPingDelay: config.activity_timeout
    	                }]],
    	        [":def_transport", "ws", "ws", 3, ":ws_options", ":ws_manager"],
    	        [":def_transport", "wss", "ws", 3, ":wss_options", ":ws_manager"],
    	        [":def_transport", "sockjs", "sockjs", 1, ":sockjs_options"],
    	        [":def_transport", "xhr_streaming", "xhr_streaming", 1, ":sockjs_options", ":streaming_manager"],
    	        [":def_transport", "xdr_streaming", "xdr_streaming", 1, ":sockjs_options", ":streaming_manager"],
    	        [":def_transport", "xhr_polling", "xhr_polling", 1, ":sockjs_options"],
    	        [":def_transport", "xdr_polling", "xdr_polling", 1, ":sockjs_options"],
    	        [":def", "ws_loop", [":sequential", ":timeouts", ":ws"]],
    	        [":def", "wss_loop", [":sequential", ":timeouts", ":wss"]],
    	        [":def", "sockjs_loop", [":sequential", ":timeouts", ":sockjs"]],
    	        [":def", "streaming_loop", [":sequential", ":timeouts",
    	                [":if", [":is_supported", ":xhr_streaming"],
    	                    ":xhr_streaming",
    	                    ":xdr_streaming"
    	                ]
    	            ]],
    	        [":def", "polling_loop", [":sequential", ":timeouts",
    	                [":if", [":is_supported", ":xhr_polling"],
    	                    ":xhr_polling",
    	                    ":xdr_polling"
    	                ]
    	            ]],
    	        [":def", "http_loop", [":if", [":is_supported", ":streaming_loop"], [
    	                    ":best_connected_ever",
    	                    ":streaming_loop",
    	                    [":delayed", 4000, [":polling_loop"]]
    	                ], [
    	                    ":polling_loop"
    	                ]]],
    	        [":def", "http_fallback_loop",
    	            [":if", [":is_supported", ":http_loop"], [
    	                    ":http_loop"
    	                ], [
    	                    ":sockjs_loop"
    	                ]]
    	        ],
    	        [":def", "strategy",
    	            [":cached", 1800000,
    	                [":first_connected",
    	                    [":if", [":is_supported", ":ws"],
    	                        wsStrategy,
    	                        ":http_fallback_loop"
    	                    ]
    	                ]
    	            ]
    	        ]
    	    ];
    	};
    	exports.__esModule = true;
    	exports["default"] = getDefaultStrategy;


    /***/ }),
    /* 28 */
    /***/ (function(module, exports, __webpack_require__) {
    	var dependencies_1 = __webpack_require__(3);
    	function default_1() {
    	    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_1.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();
    	    }
    	}
    	exports.__esModule = true;
    	exports["default"] = default_1;


    /***/ }),
    /* 29 */
    /***/ (function(module, exports, __webpack_require__) {
    	var http_xdomain_request_1 = __webpack_require__(30);
    	var http_1 = __webpack_require__(32);
    	http_1["default"].createXDR = function (method, url) {
    	    return this.createRequest(http_xdomain_request_1["default"], method, url);
    	};
    	exports.__esModule = true;
    	exports["default"] = http_1["default"];


    /***/ }),
    /* 30 */
    /***/ (function(module, exports, __webpack_require__) {
    	var Errors = __webpack_require__(31);
    	var hooks = {
    	    getRequest: function (socket) {
    	        var xdr = new window.XDomainRequest();
    	        xdr.ontimeout = function () {
    	            socket.emit("error", new Errors.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();
    	    }
    	};
    	exports.__esModule = true;
    	exports["default"] = hooks;


    /***/ }),
    /* 31 */
    /***/ (function(module, exports) {
    	var __extends = (this && this.__extends) || function (d, b) {
    	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    	    function __() { this.constructor = d; }
    	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    	};
    	var BadEventName = (function (_super) {
    	    __extends(BadEventName, _super);
    	    function BadEventName() {
    	        _super.apply(this, arguments);
    	    }
    	    return BadEventName;
    	}(Error));
    	exports.BadEventName = BadEventName;
    	var RequestTimedOut = (function (_super) {
    	    __extends(RequestTimedOut, _super);
    	    function RequestTimedOut() {
    	        _super.apply(this, arguments);
    	    }
    	    return RequestTimedOut;
    	}(Error));
    	exports.RequestTimedOut = RequestTimedOut;
    	var TransportPriorityTooLow = (function (_super) {
    	    __extends(TransportPriorityTooLow, _super);
    	    function TransportPriorityTooLow() {
    	        _super.apply(this, arguments);
    	    }
    	    return TransportPriorityTooLow;
    	}(Error));
    	exports.TransportPriorityTooLow = TransportPriorityTooLow;
    	var TransportClosed = (function (_super) {
    	    __extends(TransportClosed, _super);
    	    function TransportClosed() {
    	        _super.apply(this, arguments);
    	    }
    	    return TransportClosed;
    	}(Error));
    	exports.TransportClosed = TransportClosed;
    	var UnsupportedFeature = (function (_super) {
    	    __extends(UnsupportedFeature, _super);
    	    function UnsupportedFeature() {
    	        _super.apply(this, arguments);
    	    }
    	    return UnsupportedFeature;
    	}(Error));
    	exports.UnsupportedFeature = UnsupportedFeature;
    	var UnsupportedTransport = (function (_super) {
    	    __extends(UnsupportedTransport, _super);
    	    function UnsupportedTransport() {
    	        _super.apply(this, arguments);
    	    }
    	    return UnsupportedTransport;
    	}(Error));
    	exports.UnsupportedTransport = UnsupportedTransport;
    	var UnsupportedStrategy = (function (_super) {
    	    __extends(UnsupportedStrategy, _super);
    	    function UnsupportedStrategy() {
    	        _super.apply(this, arguments);
    	    }
    	    return UnsupportedStrategy;
    	}(Error));
    	exports.UnsupportedStrategy = UnsupportedStrategy;


    /***/ }),
    /* 32 */
    /***/ (function(module, exports, __webpack_require__) {
    	var http_request_1 = __webpack_require__(33);
    	var http_socket_1 = __webpack_require__(34);
    	var http_streaming_socket_1 = __webpack_require__(36);
    	var http_polling_socket_1 = __webpack_require__(37);
    	var http_xhr_request_1 = __webpack_require__(38);
    	var HTTP = {
    	    createStreamingSocket: function (url) {
    	        return this.createSocket(http_streaming_socket_1["default"], url);
    	    },
    	    createPollingSocket: function (url) {
    	        return this.createSocket(http_polling_socket_1["default"], url);
    	    },
    	    createSocket: function (hooks, url) {
    	        return new http_socket_1["default"](hooks, url);
    	    },
    	    createXHR: function (method, url) {
    	        return this.createRequest(http_xhr_request_1["default"], method, url);
    	    },
    	    createRequest: function (hooks, method, url) {
    	        return new http_request_1["default"](hooks, method, url);
    	    }
    	};
    	exports.__esModule = true;
    	exports["default"] = HTTP;


    /***/ }),
    /* 33 */
    /***/ (function(module, exports, __webpack_require__) {
    	var __extends = (this && this.__extends) || function (d, b) {
    	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    	    function __() { this.constructor = d; }
    	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    	};
    	var runtime_1 = __webpack_require__(2);
    	var dispatcher_1 = __webpack_require__(24);
    	var MAX_BUFFER_LENGTH = 256 * 1024;
    	var HTTPRequest = (function (_super) {
    	    __extends(HTTPRequest, _super);
    	    function HTTPRequest(hooks, method, url) {
    	        _super.call(this);
    	        this.hooks = hooks;
    	        this.method = method;
    	        this.url = url;
    	    }
    	    HTTPRequest.prototype.start = function (payload) {
    	        var _this = this;
    	        this.position = 0;
    	        this.xhr = this.hooks.getRequest(this);
    	        this.unloader = function () {
    	            _this.close();
    	        };
    	        runtime_1["default"].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_1["default"].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_1["default"]));
    	exports.__esModule = true;
    	exports["default"] = HTTPRequest;


    /***/ }),
    /* 34 */
    /***/ (function(module, exports, __webpack_require__) {
    	var state_1 = __webpack_require__(35);
    	var util_1 = __webpack_require__(11);
    	var runtime_1 = __webpack_require__(2);
    	var autoIncrement = 1;
    	var HTTPSocket = (function () {
    	    function HTTPSocket(hooks, url) {
    	        this.hooks = hooks;
    	        this.session = randomNumber(1000) + "/" + randomString(8);
    	        this.location = getLocation(url);
    	        this.readyState = state_1["default"].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_1["default"].OPEN) {
    	            try {
    	                runtime_1["default"].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_1["default"].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_1["default"].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_1["default"].CONNECTING) {
    	            if (options && options.hostname) {
    	                this.location.base = replaceHost(this.location.base, options.hostname);
    	            }
    	            this.readyState = state_1["default"].OPEN;
    	            if (this.onopen) {
    	                this.onopen();
    	            }
    	        }
    	        else {
    	            this.onClose(1006, "Server lost session", true);
    	        }
    	    };
    	    HTTPSocket.prototype.onEvent = function (event) {
    	        if (this.readyState === state_1["default"].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_1["default"].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_1["default"].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('');
    	}
    	exports.__esModule = true;
    	exports["default"] = HTTPSocket;


    /***/ }),
    /* 35 */
    /***/ (function(module, exports) {
    	var State;
    	(function (State) {
    	    State[State["CONNECTING"] = 0] = "CONNECTING";
    	    State[State["OPEN"] = 1] = "OPEN";
    	    State[State["CLOSED"] = 3] = "CLOSED";
    	})(State || (State = {}));
    	exports.__esModule = true;
    	exports["default"] = State;


    /***/ }),
    /* 36 */
    /***/ (function(module, exports) {
    	var 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);
    	    }
    	};
    	exports.__esModule = true;
    	exports["default"] = hooks;


    /***/ }),
    /* 37 */
    /***/ (function(module, exports) {
    	var 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);
    	        }
    	    }
    	};
    	exports.__esModule = true;
    	exports["default"] = hooks;


    /***/ }),
    /* 38 */
    /***/ (function(module, exports, __webpack_require__) {
    	var runtime_1 = __webpack_require__(2);
    	var hooks = {
    	    getRequest: function (socket) {
    	        var Constructor = runtime_1["default"].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();
    	    }
    	};
    	exports.__esModule = true;
    	exports["default"] = hooks;


    /***/ }),
    /* 39 */
    /***/ (function(module, exports, __webpack_require__) {
    	var Collections = __webpack_require__(9);
    	var util_1 = __webpack_require__(11);
    	var level_1 = __webpack_require__(40);
    	var 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(Collections.extend({}, event, { timestamp: util_1["default"].now() }));
    	            if (this.options.limit && this.events.length > this.options.limit) {
    	                this.events.shift();
    	            }
    	        }
    	    };
    	    Timeline.prototype.error = function (event) {
    	        this.log(level_1["default"].ERROR, event);
    	    };
    	    Timeline.prototype.info = function (event) {
    	        this.log(level_1["default"].INFO, event);
    	    };
    	    Timeline.prototype.debug = function (event) {
    	        this.log(level_1["default"].DEBUG, event);
    	    };
    	    Timeline.prototype.isEmpty = function () {
    	        return this.events.length === 0;
    	    };
    	    Timeline.prototype.send = function (sendfn, callback) {
    	        var _this = this;
    	        var data = Collections.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;
    	}());
    	exports.__esModule = true;
    	exports["default"] = Timeline;


    /***/ }),
    /* 40 */
    /***/ (function(module, exports) {
    	var TimelineLevel;
    	(function (TimelineLevel) {
    	    TimelineLevel[TimelineLevel["ERROR"] = 3] = "ERROR";
    	    TimelineLevel[TimelineLevel["INFO"] = 6] = "INFO";
    	    TimelineLevel[TimelineLevel["DEBUG"] = 7] = "DEBUG";
    	})(TimelineLevel || (TimelineLevel = {}));
    	exports.__esModule = true;
    	exports["default"] = TimelineLevel;


    /***/ }),
    /* 41 */
    /***/ (function(module, exports, __webpack_require__) {
    	var Collections = __webpack_require__(9);
    	var util_1 = __webpack_require__(11);
    	var transport_manager_1 = __webpack_require__(42);
    	var Errors = __webpack_require__(31);
    	var transport_strategy_1 = __webpack_require__(64);
    	var sequential_strategy_1 = __webpack_require__(65);
    	var best_connected_ever_strategy_1 = __webpack_require__(66);
    	var cached_strategy_1 = __webpack_require__(67);
    	var delayed_strategy_1 = __webpack_require__(68);
    	var if_strategy_1 = __webpack_require__(69);
    	var first_connected_strategy_1 = __webpack_require__(70);
    	var runtime_1 = __webpack_require__(2);
    	var Transports = runtime_1["default"].Transports;
    	exports.build = function (scheme, options) {
    	    var context = Collections.extend({}, globalContext, options);
    	    return evaluate(scheme, context)[1].strategy;
    	};
    	var UnsupportedStrategy = {
    	    isSupported: function () {
    	        return false;
    	    },
    	    connect: function (_, callback) {
    	        var deferred = util_1["default"].defer(function () {
    	            callback(new Errors.UnsupportedStrategy());
    	        });
    	        return {
    	            abort: function () {
    	                deferred.ensureAborted();
    	            },
    	            forceMinPriority: function () { }
    	        };
    	    }
    	};
    	function returnWithOriginalContext(f) {
    	    return function (context) {
    	        return [f.apply(this, arguments), context];
    	    };
    	}
    	var globalContext = {
    	    extend: function (context, first, second) {
    	        return [Collections.extend({}, first, second), context];
    	    },
    	    def: function (context, name, value) {
    	        if (context[name] !== undefined) {
    	            throw "Redefining symbol " + name;
    	        }
    	        context[name] = value;
    	        return [undefined, context];
    	    },
    	    def_transport: function (context, name, type, priority, options, manager) {
    	        var transportClass = Transports[type];
    	        if (!transportClass) {
    	            throw new Errors.UnsupportedTransport(type);
    	        }
    	        var enabled = (!context.enabledTransports ||
    	            Collections.arrayIndexOf(context.enabledTransports, name) !== -1) &&
    	            (!context.disabledTransports ||
    	                Collections.arrayIndexOf(context.disabledTransports, name) === -1);
    	        var transport;
    	        if (enabled) {
    	            transport = new transport_strategy_1["default"](name, priority, manager ? manager.getAssistant(transportClass) : transportClass, Collections.extend({
    	                key: context.key,
    	                useTLS: context.useTLS,
    	                timeline: context.timeline,
    	                ignoreNullOrigin: context.ignoreNullOrigin
    	            }, options));
    	        }
    	        else {
    	            transport = UnsupportedStrategy;
    	        }
    	        var newContext = context.def(context, name, transport)[1];
    	        newContext.Transports = context.Transports || {};
    	        newContext.Transports[name] = transport;
    	        return [undefined, newContext];
    	    },
    	    transport_manager: returnWithOriginalContext(function (_, options) {
    	        return new transport_manager_1["default"](options);
    	    }),
    	    sequential: returnWithOriginalContext(function (_, options) {
    	        var strategies = Array.prototype.slice.call(arguments, 2);
    	        return new sequential_strategy_1["default"](strategies, options);
    	    }),
    	    cached: returnWithOriginalContext(function (context, ttl, strategy) {
    	        return new cached_strategy_1["default"](strategy, context.Transports, {
    	            ttl: ttl,
    	            timeline: context.timeline,
    	            useTLS: context.useTLS
    	        });
    	    }),
    	    first_connected: returnWithOriginalContext(function (_, strategy) {
    	        return new first_connected_strategy_1["default"](strategy);
    	    }),
    	    best_connected_ever: returnWithOriginalContext(function () {
    	        var strategies = Array.prototype.slice.call(arguments, 1);
    	        return new best_connected_ever_strategy_1["default"](strategies);
    	    }),
    	    delayed: returnWithOriginalContext(function (_, delay, strategy) {
    	        return new delayed_strategy_1["default"](strategy, { delay: delay });
    	    }),
    	    "if": returnWithOriginalContext(function (_, test, trueBranch, falseBranch) {
    	        return new if_strategy_1["default"](test, trueBranch, falseBranch);
    	    }),
    	    is_supported: returnWithOriginalContext(function (_, strategy) {
    	        return function () {
    	            return strategy.isSupported();
    	        };
    	    })
    	};
    	function isSymbol(expression) {
    	    return (typeof expression === "string") && expression.charAt(0) === ":";
    	}
    	function getSymbolValue(expression, context) {
    	    return context[expression.slice(1)];
    	}
    	function evaluateListOfExpressions(expressions, context) {
    	    if (expressions.length === 0) {
    	        return [[], context];
    	    }
    	    var head = evaluate(expressions[0], context);
    	    var tail = evaluateListOfExpressions(expressions.slice(1), head[1]);
    	    return [[head[0]].concat(tail[0]), tail[1]];
    	}
    	function evaluateString(expression, context) {
    	    if (!isSymbol(expression)) {
    	        return [expression, context];
    	    }
    	    var value = getSymbolValue(expression, context);
    	    if (value === undefined) {
    	        throw "Undefined symbol " + expression;
    	    }
    	    return [value, context];
    	}
    	function evaluateArray(expression, context) {
    	    if (isSymbol(expression[0])) {
    	        var f = getSymbolValue(expression[0], context);
    	        if (expression.length > 1) {
    	            if (typeof f !== "function") {
    	                throw "Calling non-function " + expression[0];
    	            }
    	            var args = [Collections.extend({}, context)].concat(Collections.map(expression.slice(1), function (arg) {
    	                return evaluate(arg, Collections.extend({}, context))[0];
    	            }));
    	            return f.apply(this, args);
    	        }
    	        else {
    	            return [f, context];
    	        }
    	    }
    	    else {
    	        return evaluateListOfExpressions(expression, context);
    	    }
    	}
    	function evaluate(expression, context) {
    	    if (typeof expression === "string") {
    	        return evaluateString(expression, context);
    	    }
    	    else if (typeof expression === "object") {
    	        if (expression instanceof Array && expression.length > 0) {
    	            return evaluateArray(expression, context);
    	        }
    	    }
    	    return [expression, context];
    	}


    /***/ }),
    /* 42 */
    /***/ (function(module, exports, __webpack_require__) {
    	var factory_1 = __webpack_require__(43);
    	var TransportManager = (function () {
    	    function TransportManager(options) {
    	        this.options = options || {};
    	        this.livesLeft = this.options.lives || Infinity;
    	    }
    	    TransportManager.prototype.getAssistant = function (transport) {
    	        return factory_1["default"].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;
    	}());
    	exports.__esModule = true;
    	exports["default"] = TransportManager;


    /***/ }),
    /* 43 */
    /***/ (function(module, exports, __webpack_require__) {
    	var assistant_to_the_transport_manager_1 = __webpack_require__(44);
    	var handshake_1 = __webpack_require__(45);
    	var pusher_authorizer_1 = __webpack_require__(48);
    	var timeline_sender_1 = __webpack_require__(49);
    	var presence_channel_1 = __webpack_require__(50);
    	var private_channel_1 = __webpack_require__(51);
    	var encrypted_channel_1 = __webpack_require__(54);
    	var channel_1 = __webpack_require__(52);
    	var connection_manager_1 = __webpack_require__(62);
    	var channels_1 = __webpack_require__(63);
    	var Factory = {
    	    createChannels: function () {
    	        return new channels_1["default"]();
    	    },
    	    createConnectionManager: function (key, options) {
    	        return new connection_manager_1["default"](key, options);
    	    },
    	    createChannel: function (name, pusher) {
    	        return new channel_1["default"](name, pusher);
    	    },
    	    createPrivateChannel: function (name, pusher) {
    	        return new private_channel_1["default"](name, pusher);
    	    },
    	    createPresenceChannel: function (name, pusher) {
    	        return new presence_channel_1["default"](name, pusher);
    	    },
    	    createEncryptedChannel: function (name, pusher) {
    	        return new encrypted_channel_1["default"](name, pusher);
    	    },
    	    createTimelineSender: function (timeline, options) {
    	        return new timeline_sender_1["default"](timeline, options);
    	    },
    	    createAuthorizer: function (channel, options) {
    	        if (options.authorizer) {
    	            return options.authorizer(channel, options);
    	        }
    	        return new pusher_authorizer_1["default"](channel, options);
    	    },
    	    createHandshake: function (transport, callback) {
    	        return new handshake_1["default"](transport, callback);
    	    },
    	    createAssistantToTheTransportManager: function (manager, transport, options) {
    	        return new assistant_to_the_transport_manager_1["default"](manager, transport, options);
    	    }
    	};
    	exports.__esModule = true;
    	exports["default"] = Factory;


    /***/ }),
    /* 44 */
    /***/ (function(module, exports, __webpack_require__) {
    	var util_1 = __webpack_require__(11);
    	var Collections = __webpack_require__(9);
    	var 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 = Collections.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_1["default"].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_1["default"].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;
    	}());
    	exports.__esModule = true;
    	exports["default"] = AssistantToTheTransportManager;


    /***/ }),
    /* 45 */
    /***/ (function(module, exports, __webpack_require__) {
    	var Collections = __webpack_require__(9);
    	var Protocol = __webpack_require__(46);
    	var connection_1 = __webpack_require__(47);
    	var Handshake = (function () {
    	    function Handshake(transport, callback) {
    	        this.transport = transport;
    	        this.callback = callback;
    	        this.bindListeners();
    	    }
    	    Handshake.prototype.close = function () {
    	        this.unbindListeners();
    	        this.transport.close();
    	    };
    	    Handshake.prototype.bindListeners = function () {
    	        var _this = this;
    	        this.onMessage = function (m) {
    	            _this.unbindListeners();
    	            var result;
    	            try {
    	                result = Protocol.processHandshake(m);
    	            }
    	            catch (e) {
    	                _this.finish("error", { error: e });
    	                _this.transport.close();
    	                return;
    	            }
    	            if (result.action === "connected") {
    	                _this.finish("connected", {
    	                    connection: new connection_1["default"](result.id, _this.transport),
    	                    activityTimeout: result.activityTimeout
    	                });
    	            }
    	            else {
    	                _this.finish(result.action, { error: result.error });
    	                _this.transport.close();
    	            }
    	        };
    	        this.onClosed = function (closeEvent) {
    	            _this.unbindListeners();
    	            var action = Protocol.getCloseAction(closeEvent) || "backoff";
    	            var error = Protocol.getCloseError(closeEvent);
    	            _this.finish(action, { error: error });
    	        };
    	        this.transport.bind("message", this.onMessage);
    	        this.transport.bind("closed", this.onClosed);
    	    };
    	    Handshake.prototype.unbindListeners = function () {
    	        this.transport.unbind("message", this.onMessage);
    	        this.transport.unbind("closed", this.onClosed);
    	    };
    	    Handshake.prototype.finish = function (action, params) {
    	        this.callback(Collections.extend({ transport: this.transport, action: action }, params));
    	    };
    	    return Handshake;
    	}());
    	exports.__esModule = true;
    	exports["default"] = Handshake;


    /***/ }),
    /* 46 */
    /***/ (function(module, exports) {
    	exports.decodeMessage = function (message) {
    	    try {
    	        var params = JSON.parse(message.data);
    	        if (typeof params.data === 'string') {
    	            try {
    	                params.data = JSON.parse(params.data);
    	            }
    	            catch (e) {
    	                if (!(e instanceof SyntaxError)) {
    	                    throw e;
    	                }
    	            }
    	        }
    	        return params;
    	    }
    	    catch (e) {
    	        throw { type: 'MessageParseError', error: e, data: message.data };
    	    }
    	};
    	exports.encodeMessage = function (message) {
    	    return JSON.stringify(message);
    	};
    	exports.processHandshake = function (message) {
    	    message = exports.decodeMessage(message);
    	    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";
    	    }
    	};
    	exports.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";
    	    }
    	};
    	exports.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;
    	    }
    	};


    /***/ }),
    /* 47 */
    /***/ (function(module, exports, __webpack_require__) {
    	var __extends = (this && this.__extends) || function (d, b) {
    	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    	    function __() { this.constructor = d; }
    	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    	};
    	var Collections = __webpack_require__(9);
    	var dispatcher_1 = __webpack_require__(24);
    	var Protocol = __webpack_require__(46);
    	var logger_1 = __webpack_require__(8);
    	var Connection = (function (_super) {
    	    __extends(Connection, _super);
    	    function Connection(id, transport) {
    	        _super.call(this);
    	        this.id = id;
    	        this.transport = transport;
    	        this.activityTimeout = transport.activityTimeout;
    	        this.bindListeners();
    	    }
    	    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 message = { event: name, data: data };
    	        if (channel) {
    	            message.channel = channel;
    	        }
    	        logger_1["default"].debug('Event sent', message);
    	        return this.send(Protocol.encodeMessage(message));
    	    };
    	    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 (m) {
    	                var message;
    	                try {
    	                    message = Protocol.decodeMessage(m);
    	                }
    	                catch (e) {
    	                    _this.emit('error', {
    	                        type: 'MessageParseError',
    	                        error: e,
    	                        data: m.data
    	                    });
    	                }
    	                if (message !== undefined) {
    	                    logger_1["default"].debug('Event recd', message);
    	                    switch (message.event) {
    	                        case 'pusher:error':
    	                            _this.emit('error', { type: 'PusherError', data: message.data });
    	                            break;
    	                        case 'pusher:ping':
    	                            _this.emit("ping");
    	                            break;
    	                        case 'pusher:pong':
    	                            _this.emit("pong");
    	                            break;
    	                    }
    	                    _this.emit('message', message);
    	                }
    	            },
    	            activity: function () {
    	                _this.emit("activity");
    	            },
    	            error: function (error) {
    	                _this.emit("error", { type: "WebSocketError", error: error });
    	            },
    	            closed: function (closeEvent) {
    	                unbindListeners();
    	                if (closeEvent && closeEvent.code) {
    	                    _this.handleCloseEvent(closeEvent);
    	                }
    	                _this.transport = null;
    	                _this.emit("closed");
    	            }
    	        };
    	        var unbindListeners = function () {
    	            Collections.objectApply(listeners, function (listener, event) {
    	                _this.transport.unbind(event, listener);
    	            });
    	        };
    	        Collections.objectApply(listeners, function (listener, event) {
    	            _this.transport.bind(event, listener);
    	        });
    	    };
    	    Connection.prototype.handleCloseEvent = function (closeEvent) {
    	        var action = Protocol.getCloseAction(closeEvent);
    	        var error = Protocol.getCloseError(closeEvent);
    	        if (error) {
    	            this.emit('error', error);
    	        }
    	        if (action) {
    	            this.emit(action, { action: action, error: error });
    	        }
    	    };
    	    return Connection;
    	}(dispatcher_1["default"]));
    	exports.__esModule = true;
    	exports["default"] = Connection;


    /***/ }),
    /* 48 */
    /***/ (function(module, exports, __webpack_require__) {
    	var runtime_1 = __webpack_require__(2);
    	var PusherAuthorizer = (function () {
    	    function PusherAuthorizer(channel, options) {
    	        this.channel = channel;
    	        var authTransport = options.authTransport;
    	        if (typeof runtime_1["default"].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_1["default"].getAuthorizers();
    	        return PusherAuthorizer.authorizers[this.type].call(this, runtime_1["default"], socketId, callback);
    	    };
    	    return PusherAuthorizer;
    	}());
    	exports.__esModule = true;
    	exports["default"] = PusherAuthorizer;


    /***/ }),
    /* 49 */
    /***/ (function(module, exports, __webpack_require__) {
    	var runtime_1 = __webpack_require__(2);
    	var 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_1["default"].TimelineTransport.getAgent(this, useTLS), callback);
    	    };
    	    return TimelineSender;
    	}());
    	exports.__esModule = true;
    	exports["default"] = TimelineSender;


    /***/ }),
    /* 50 */
    /***/ (function(module, exports, __webpack_require__) {
    	var __extends = (this && this.__extends) || function (d, b) {
    	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    	    function __() { this.constructor = d; }
    	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    	};
    	var private_channel_1 = __webpack_require__(51);
    	var logger_1 = __webpack_require__(8);
    	var members_1 = __webpack_require__(53);
    	var url_store_1 = __webpack_require__(14);
    	var PresenceChannel = (function (_super) {
    	    __extends(PresenceChannel, _super);
    	    function PresenceChannel(name, pusher) {
    	        _super.call(this, name, pusher);
    	        this.members = new members_1["default"]();
    	    }
    	    PresenceChannel.prototype.authorize = function (socketId, callback) {
    	        var _this = this;
    	        _super.prototype.authorize.call(this, socketId, function (error, authData) {
    	            if (!error) {
    	                if (authData.channel_data === undefined) {
    	                    var suffix = url_store_1["default"].buildLogSuffix("authenticationEndpoint");
    	                    logger_1["default"].warn(("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, data) {
    	        switch (event) {
    	            case "pusher_internal:subscription_succeeded":
    	                this.subscriptionPending = false;
    	                this.subscribed = true;
    	                if (this.subscriptionCancelled) {
    	                    this.pusher.unsubscribe(this.name);
    	                }
    	                else {
    	                    this.members.onSubscription(data);
    	                    this.emit("pusher:subscription_succeeded", this.members);
    	                }
    	                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;
    	            default:
    	                private_channel_1["default"].prototype.handleEvent.call(this, event, data);
    	        }
    	    };
    	    PresenceChannel.prototype.disconnect = function () {
    	        this.members.reset();
    	        _super.prototype.disconnect.call(this);
    	    };
    	    return PresenceChannel;
    	}(private_channel_1["default"]));
    	exports.__esModule = true;
    	exports["default"] = PresenceChannel;


    /***/ }),
    /* 51 */
    /***/ (function(module, exports, __webpack_require__) {
    	var __extends = (this && this.__extends) || function (d, b) {
    	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    	    function __() { this.constructor = d; }
    	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    	};
    	var factory_1 = __webpack_require__(43);
    	var channel_1 = __webpack_require__(52);
    	var PrivateChannel = (function (_super) {
    	    __extends(PrivateChannel, _super);
    	    function PrivateChannel() {
    	        _super.apply(this, arguments);
    	    }
    	    PrivateChannel.prototype.authorize = function (socketId, callback) {
    	        var authorizer = factory_1["default"].createAuthorizer(this, this.pusher.config);
    	        return authorizer.authorize(socketId, callback);
    	    };
    	    return PrivateChannel;
    	}(channel_1["default"]));
    	exports.__esModule = true;
    	exports["default"] = PrivateChannel;


    /***/ }),
    /* 52 */
    /***/ (function(module, exports, __webpack_require__) {
    	var __extends = (this && this.__extends) || function (d, b) {
    	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    	    function __() { this.constructor = d; }
    	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    	};
    	var dispatcher_1 = __webpack_require__(24);
    	var Errors = __webpack_require__(31);
    	var logger_1 = __webpack_require__(8);
    	var Channel = (function (_super) {
    	    __extends(Channel, _super);
    	    function Channel(name, pusher) {
    	        _super.call(this, function (event, data) {
    	            logger_1["default"].debug('No callbacks on ' + name + ' for ' + event);
    	        });
    	        this.name = name;
    	        this.pusher = pusher;
    	        this.subscribed = false;
    	        this.subscriptionPending = false;
    	        this.subscriptionCancelled = false;
    	    }
    	    Channel.prototype.authorize = function (socketId, callback) {
    	        return callback(false, {});
    	    };
    	    Channel.prototype.trigger = function (event, data) {
    	        if (event.indexOf("client-") !== 0) {
    	            throw new Errors.BadEventName("Event '" + event + "' does not start with 'client-'");
    	        }
    	        return this.pusher.send_event(event, data, this.name);
    	    };
    	    Channel.prototype.disconnect = function () {
    	        this.subscribed = false;
    	        this.subscriptionPending = false;
    	    };
    	    Channel.prototype.handleEvent = function (event, data) {
    	        if (event.indexOf("pusher_internal:") === 0) {
    	            if (event === "pusher_internal:subscription_succeeded") {
    	                this.subscriptionPending = false;
    	                this.subscribed = true;
    	                if (this.subscriptionCancelled) {
    	                    this.pusher.unsubscribe(this.name);
    	                }
    	                else {
    	                    this.emit("pusher:subscription_succeeded", data);
    	                }
    	            }
    	        }
    	        else {
    	            this.emit(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.handleEvent('pusher:subscription_error', data);
    	            }
    	            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_1["default"]));
    	exports.__esModule = true;
    	exports["default"] = Channel;


    /***/ }),
    /* 53 */
    /***/ (function(module, exports, __webpack_require__) {
    	var Collections = __webpack_require__(9);
    	var 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;
    	        Collections.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;
    	}());
    	exports.__esModule = true;
    	exports["default"] = Members;


    /***/ }),
    /* 54 */
    /***/ (function(module, exports, __webpack_require__) {
    	var __extends = (this && this.__extends) || function (d, b) {
    	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    	    function __() { this.constructor = d; }
    	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    	};
    	var private_channel_1 = __webpack_require__(51);
    	var Errors = __webpack_require__(31);
    	var logger_1 = __webpack_require__(8);
    	var tweetnacl_1 = __webpack_require__(55);
    	var tweetnacl_util_1 = __webpack_require__(57);
    	var EncryptedChannel = (function (_super) {
    	    __extends(EncryptedChannel, _super);
    	    function EncryptedChannel() {
    	        _super.apply(this, arguments);
    	        this.key = null;
    	    }
    	    EncryptedChannel.prototype.authorize = function (socketId, callback) {
    	        var _this = this;
    	        _super.prototype.authorize.call(this, socketId, function (error, authData) {
    	            if (error) {
    	                callback(true, authData);
    	                return;
    	            }
    	            var sharedSecret = authData["shared_secret"];
    	            if (!sharedSecret) {
    	                var errorMsg = "No shared_secret key in auth payload for encrypted channel: " + _this.name;
    	                callback(true, errorMsg);
    	                logger_1["default"].warn("Error: " + errorMsg);
    	                return;
    	            }
    	            _this.key = tweetnacl_util_1.decodeBase64(sharedSecret);
    	            delete authData["shared_secret"];
    	            callback(false, authData);
    	        });
    	    };
    	    EncryptedChannel.prototype.trigger = function (event, data) {
    	        throw new Errors.UnsupportedFeature('Client events are not currently supported for encrypted channels');
    	    };
    	    EncryptedChannel.prototype.handleEvent = function (event, data) {
    	        if (event.indexOf("pusher_internal:") === 0 || event.indexOf("pusher:") === 0) {
    	            _super.prototype.handleEvent.call(this, event, data);
    	            return;
    	        }
    	        this.handleEncryptedEvent(event, data);
    	    };
    	    EncryptedChannel.prototype.handleEncryptedEvent = function (event, data) {
    	        var _this = this;
    	        if (!this.key) {
    	            logger_1["default"].debug('Received encrypted event before key has been retrieved from the authEndpoint');
    	            return;
    	        }
    	        if (!data.ciphertext || !data.nonce) {
    	            logger_1["default"].warn('Unexpected format for encrypted event, expected object with `ciphertext` and `nonce` fields, got: ' + data);
    	            return;
    	        }
    	        var cipherText = tweetnacl_util_1.decodeBase64(data.ciphertext);
    	        if (cipherText.length < tweetnacl_1.secretbox.overheadLength) {
    	            logger_1["default"].warn("Expected encrypted event ciphertext length to be " + tweetnacl_1.secretbox.overheadLength + ", got: " + cipherText.length);
    	            return;
    	        }
    	        var nonce = tweetnacl_util_1.decodeBase64(data.nonce);
    	        if (nonce.length < tweetnacl_1.secretbox.nonceLength) {
    	            logger_1["default"].warn("Expected encrypted event nonce length to be " + tweetnacl_1.secretbox.nonceLength + ", got: " + nonce.length);
    	            return;
    	        }
    	        var bytes = tweetnacl_1.secretbox.open(cipherText, nonce, this.key);
    	        if (bytes === null) {
    	            logger_1["default"].debug('Failed to decrypted 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_1["default"].warn("Failed to make a request to the authEndpoint: " + authData + ". Unable to fetch new key, so dropping encrypted event");
    	                    return;
    	                }
    	                bytes = tweetnacl_1.secretbox.open(cipherText, nonce, _this.key);
    	                if (bytes === null) {
    	                    logger_1["default"].warn("Failed to decrypt event with new key. Dropping encrypted event");
    	                    return;
    	                }
    	                _this.emitJSON(event, tweetnacl_util_1.encodeUTF8(bytes));
    	                return;
    	            });
    	            return;
    	        }
    	        this.emitJSON(event, tweetnacl_util_1.encodeUTF8(bytes));
    	    };
    	    EncryptedChannel.prototype.emitJSON = function (eventName, data) {
    	        try {
    	            this.emit(eventName, JSON.parse(data));
    	        }
    	        catch (e) {
    	            this.emit(eventName, data);
    	        }
    	        return this;
    	    };
    	    return EncryptedChannel;
    	}(private_channel_1["default"]));
    	exports.__esModule = true;
    	exports["default"] = EncryptedChannel;


    /***/ }),
    /* 55 */
    /***/ (function(module, exports, __webpack_require__) {

    	(function(nacl) {

    	// 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 = (x[j] + 128) >> 8;
    	      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, mlen;
    	  var t = new Uint8Array(32), h = new Uint8Array(64);
    	  var p = [gf(), gf(), gf(), gf()],
    	      q = [gf(), gf(), gf(), gf()];

    	  mlen = -1;
    	  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];
    	  mlen = n;
    	  return mlen;
    	}

    	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
    	};

    	/* 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 {
    	    // Node.js.
    	    crypto = __webpack_require__(56);
    	    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);
    	      });
    	    }
    	  }
    	})();

    	})(typeof module !== 'undefined' && module.exports ? module.exports : (self.nacl = self.nacl || {}));


    /***/ }),
    /* 56 */
    /***/ (function(module, exports) {

    	/* (ignored) */

    /***/ }),
    /* 57 */
    /***/ (function(module, exports, __webpack_require__) {

    	/* WEBPACK VAR INJECTION */(function(Buffer) {// Written in 2014-2016 by Dmitry Chestnykh and Devi Mandiri.
    	// Public domain.
    	(function(root, f) {
    	  if (typeof module !== 'undefined' && module.exports) module.exports = f();
    	  else if (root.nacl) root.nacl.util = f();
    	  else {
    	    root.nacl = {};
    	    root.nacl.util = f();
    	  }
    	}(this, function() {

    	  var util = {};

    	  function validateBase64(s) {
    	    if (!(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(s))) {
    	      throw new TypeError('invalid encoding');
    	    }
    	  }

    	  util.decodeUTF8 = function(s) {
    	    if (typeof s !== 'string') throw new TypeError('expected string');
    	    var i, d = unescape(encodeURIComponent(s)), b = new Uint8Array(d.length);
    	    for (i = 0; i < d.length; i++) b[i] = d.charCodeAt(i);
    	    return b;
    	  };

    	  util.encodeUTF8 = function(arr) {
    	    var i, s = [];
    	    for (i = 0; i < arr.length; i++) s.push(String.fromCharCode(arr[i]));
    	    return decodeURIComponent(escape(s.join('')));
    	  };

    	  if (typeof atob === 'undefined') {
    	    // Node.js

    	    if (typeof Buffer.from !== 'undefined') {
    	       // Node v6 and later
    	      util.encodeBase64 = function (arr) { // v6 and later
    	          return Buffer.from(arr).toString('base64');
    	      };

    	      util.decodeBase64 = function (s) {
    	        validateBase64(s);
    	        return new Uint8Array(Array.prototype.slice.call(Buffer.from(s, 'base64'), 0));
    	      };

    	    } else {
    	      // Node earlier than v6
    	      util.encodeBase64 = function (arr) { // v6 and later
    	        return (new Buffer(arr)).toString('base64');
    	      };

    	      util.decodeBase64 = function(s) {
    	        validateBase64(s);
    	        return new Uint8Array(Array.prototype.slice.call(new Buffer(s, 'base64'), 0));
    	      };
    	    }

    	  } else {
    	    // Browsers

    	    util.encodeBase64 = function(arr) {
    	      var i, s = [], len = arr.length;
    	      for (i = 0; i < len; i++) s.push(String.fromCharCode(arr[i]));
    	      return btoa(s.join(''));
    	    };

    	    util.decodeBase64 = function(s) {
    	      validateBase64(s);
    	      var i, d = atob(s), b = new Uint8Array(d.length);
    	      for (i = 0; i < d.length; i++) b[i] = d.charCodeAt(i);
    	      return b;
    	    };

    	  }

    	  return util;

    	}));

    	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(58).Buffer));

    /***/ }),
    /* 58 */
    /***/ (function(module, exports, __webpack_require__) {

    	var base64 = __webpack_require__(59);
    	var ieee754 = __webpack_require__(60);
    	var isArray = __webpack_require__(61);

    	exports.Buffer = Buffer;
    	exports.SlowBuffer = SlowBuffer;
    	exports.INSPECT_MAX_BYTES = 50;

    	/**
    	 * If `Buffer.TYPED_ARRAY_SUPPORT`:
    	 *   === true    Use Uint8Array implementation (fastest)
    	 *   === false   Use Object implementation (most compatible, even IE6)
    	 *
    	 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
    	 * Opera 11.6+, iOS 4.2+.
    	 *
    	 * Due to various browser bugs, sometimes the Object implementation will be used even
    	 * when the browser supports typed arrays.
    	 *
    	 * Note:
    	 *
    	 *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
    	 *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
    	 *
    	 *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
    	 *
    	 *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
    	 *     incorrect length in some situations.

    	 * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
    	 * get the Object implementation, which is slower but behaves correctly.
    	 */
    	Buffer.TYPED_ARRAY_SUPPORT = (window).TYPED_ARRAY_SUPPORT !== undefined
    	  ? (window).TYPED_ARRAY_SUPPORT
    	  : typedArraySupport();

    	/*
    	 * Export kMaxLength after typed array support is determined.
    	 */
    	exports.kMaxLength = kMaxLength();

    	function typedArraySupport () {
    	  try {
    	    var arr = new Uint8Array(1);
    	    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }};
    	    return arr.foo() === 42 && // typed array instances can be augmented
    	        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
    	        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
    	  } catch (e) {
    	    return false
    	  }
    	}

    	function kMaxLength () {
    	  return Buffer.TYPED_ARRAY_SUPPORT
    	    ? 0x7fffffff
    	    : 0x3fffffff
    	}

    	function createBuffer (that, length) {
    	  if (kMaxLength() < length) {
    	    throw new RangeError('Invalid typed array length')
    	  }
    	  if (Buffer.TYPED_ARRAY_SUPPORT) {
    	    // Return an augmented `Uint8Array` instance, for best performance
    	    that = new Uint8Array(length);
    	    that.__proto__ = Buffer.prototype;
    	  } else {
    	    // Fallback: Return an object instance of the Buffer class
    	    if (that === null) {
    	      that = new Buffer(length);
    	    }
    	    that.length = length;
    	  }

    	  return that
    	}

    	/**
    	 * The Buffer constructor returns instances of `Uint8Array` that have their
    	 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
    	 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
    	 * and the `Uint8Array` methods. Square bracket notation works as expected -- it
    	 * returns a single octet.
    	 *
    	 * The `Uint8Array` prototype remains unmodified.
    	 */

    	function Buffer (arg, encodingOrOffset, length) {
    	  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
    	    return new Buffer(arg, encodingOrOffset, length)
    	  }

    	  // Common case.
    	  if (typeof arg === 'number') {
    	    if (typeof encodingOrOffset === 'string') {
    	      throw new Error(
    	        'If encoding is specified then the first argument must be a string'
    	      )
    	    }
    	    return allocUnsafe(this, arg)
    	  }
    	  return from(this, arg, encodingOrOffset, length)
    	}

    	Buffer.poolSize = 8192; // not used by this implementation

    	// TODO: Legacy, not needed anymore. Remove in next major version.
    	Buffer._augment = function (arr) {
    	  arr.__proto__ = Buffer.prototype;
    	  return arr
    	};

    	function from (that, value, encodingOrOffset, length) {
    	  if (typeof value === 'number') {
    	    throw new TypeError('"value" argument must not be a number')
    	  }

    	  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
    	    return fromArrayBuffer(that, value, encodingOrOffset, length)
    	  }

    	  if (typeof value === 'string') {
    	    return fromString(that, value, encodingOrOffset)
    	  }

    	  return fromObject(that, value)
    	}

    	/**
    	 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
    	 * if value is a number.
    	 * Buffer.from(str[, encoding])
    	 * Buffer.from(array)
    	 * Buffer.from(buffer)
    	 * Buffer.from(arrayBuffer[, byteOffset[, length]])
    	 **/
    	Buffer.from = function (value, encodingOrOffset, length) {
    	  return from(null, value, encodingOrOffset, length)
    	};

    	if (Buffer.TYPED_ARRAY_SUPPORT) {
    	  Buffer.prototype.__proto__ = Uint8Array.prototype;
    	  Buffer.__proto__ = Uint8Array;
    	  if (typeof Symbol !== 'undefined' && Symbol.species &&
    	      Buffer[Symbol.species] === Buffer) {
    	    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
    	    Object.defineProperty(Buffer, Symbol.species, {
    	      value: null,
    	      configurable: true
    	    });
    	  }
    	}

    	function assertSize (size) {
    	  if (typeof size !== 'number') {
    	    throw new TypeError('"size" argument must be a number')
    	  } else if (size < 0) {
    	    throw new RangeError('"size" argument must not be negative')
    	  }
    	}

    	function alloc (that, size, fill, encoding) {
    	  assertSize(size);
    	  if (size <= 0) {
    	    return createBuffer(that, size)
    	  }
    	  if (fill !== undefined) {
    	    // Only pay attention to encoding if it's a string. This
    	    // prevents accidentally sending in a number that would
    	    // be interpretted as a start offset.
    	    return typeof encoding === 'string'
    	      ? createBuffer(that, size).fill(fill, encoding)
    	      : createBuffer(that, size).fill(fill)
    	  }
    	  return createBuffer(that, size)
    	}

    	/**
    	 * Creates a new filled Buffer instance.
    	 * alloc(size[, fill[, encoding]])
    	 **/
    	Buffer.alloc = function (size, fill, encoding) {
    	  return alloc(null, size, fill, encoding)
    	};

    	function allocUnsafe (that, size) {
    	  assertSize(size);
    	  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);
    	  if (!Buffer.TYPED_ARRAY_SUPPORT) {
    	    for (var i = 0; i < size; ++i) {
    	      that[i] = 0;
    	    }
    	  }
    	  return that
    	}

    	/**
    	 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
    	 * */
    	Buffer.allocUnsafe = function (size) {
    	  return allocUnsafe(null, size)
    	};
    	/**
    	 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
    	 */
    	Buffer.allocUnsafeSlow = function (size) {
    	  return allocUnsafe(null, size)
    	};

    	function fromString (that, string, encoding) {
    	  if (typeof encoding !== 'string' || encoding === '') {
    	    encoding = 'utf8';
    	  }

    	  if (!Buffer.isEncoding(encoding)) {
    	    throw new TypeError('"encoding" must be a valid string encoding')
    	  }

    	  var length = byteLength(string, encoding) | 0;
    	  that = createBuffer(that, length);

    	  var actual = that.write(string, encoding);

    	  if (actual !== length) {
    	    // Writing a hex string, for example, that contains invalid characters will
    	    // cause everything after the first invalid character to be ignored. (e.g.
    	    // 'abxxcd' will be treated as 'ab')
    	    that = that.slice(0, actual);
    	  }

    	  return that
    	}

    	function fromArrayLike (that, array) {
    	  var length = array.length < 0 ? 0 : checked(array.length) | 0;
    	  that = createBuffer(that, length);
    	  for (var i = 0; i < length; i += 1) {
    	    that[i] = array[i] & 255;
    	  }
    	  return that
    	}

    	function fromArrayBuffer (that, array, byteOffset, length) {
    	  array.byteLength; // this throws if `array` is not a valid ArrayBuffer

    	  if (byteOffset < 0 || array.byteLength < byteOffset) {
    	    throw new RangeError('\'offset\' is out of bounds')
    	  }

    	  if (array.byteLength < byteOffset + (length || 0)) {
    	    throw new RangeError('\'length\' is out of bounds')
    	  }

    	  if (byteOffset === undefined && length === undefined) {
    	    array = new Uint8Array(array);
    	  } else if (length === undefined) {
    	    array = new Uint8Array(array, byteOffset);
    	  } else {
    	    array = new Uint8Array(array, byteOffset, length);
    	  }

    	  if (Buffer.TYPED_ARRAY_SUPPORT) {
    	    // Return an augmented `Uint8Array` instance, for best performance
    	    that = array;
    	    that.__proto__ = Buffer.prototype;
    	  } else {
    	    // Fallback: Return an object instance of the Buffer class
    	    that = fromArrayLike(that, array);
    	  }
    	  return that
    	}

    	function fromObject (that, obj) {
    	  if (Buffer.isBuffer(obj)) {
    	    var len = checked(obj.length) | 0;
    	    that = createBuffer(that, len);

    	    if (that.length === 0) {
    	      return that
    	    }

    	    obj.copy(that, 0, 0, len);
    	    return that
    	  }

    	  if (obj) {
    	    if ((typeof ArrayBuffer !== 'undefined' &&
    	        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
    	      if (typeof obj.length !== 'number' || isnan(obj.length)) {
    	        return createBuffer(that, 0)
    	      }
    	      return fromArrayLike(that, obj)
    	    }

    	    if (obj.type === 'Buffer' && isArray(obj.data)) {
    	      return fromArrayLike(that, obj.data)
    	    }
    	  }

    	  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
    	}

    	function checked (length) {
    	  // Note: cannot use `length < kMaxLength()` here because that fails when
    	  // length is NaN (which is otherwise coerced to zero.)
    	  if (length >= kMaxLength()) {
    	    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
    	                         'size: 0x' + kMaxLength().toString(16) + ' bytes')
    	  }
    	  return length | 0
    	}

    	function SlowBuffer (length) {
    	  if (+length != length) { // eslint-disable-line eqeqeq
    	    length = 0;
    	  }
    	  return Buffer.alloc(+length)
    	}

    	Buffer.isBuffer = function isBuffer (b) {
    	  return !!(b != null && b._isBuffer)
    	};

    	Buffer.compare = function compare (a, b) {
    	  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
    	    throw new TypeError('Arguments must be Buffers')
    	  }

    	  if (a === b) return 0

    	  var x = a.length;
    	  var y = b.length;

    	  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
    	    if (a[i] !== b[i]) {
    	      x = a[i];
    	      y = b[i];
    	      break
    	    }
    	  }

    	  if (x < y) return -1
    	  if (y < x) return 1
    	  return 0
    	};

    	Buffer.isEncoding = function isEncoding (encoding) {
    	  switch (String(encoding).toLowerCase()) {
    	    case 'hex':
    	    case 'utf8':
    	    case 'utf-8':
    	    case 'ascii':
    	    case 'latin1':
    	    case 'binary':
    	    case 'base64':
    	    case 'ucs2':
    	    case 'ucs-2':
    	    case 'utf16le':
    	    case 'utf-16le':
    	      return true
    	    default:
    	      return false
    	  }
    	};

    	Buffer.concat = function concat (list, length) {
    	  if (!isArray(list)) {
    	    throw new TypeError('"list" argument must be an Array of Buffers')
    	  }

    	  if (list.length === 0) {
    	    return Buffer.alloc(0)
    	  }

    	  var i;
    	  if (length === undefined) {
    	    length = 0;
    	    for (i = 0; i < list.length; ++i) {
    	      length += list[i].length;
    	    }
    	  }

    	  var buffer = Buffer.allocUnsafe(length);
    	  var pos = 0;
    	  for (i = 0; i < list.length; ++i) {
    	    var buf = list[i];
    	    if (!Buffer.isBuffer(buf)) {
    	      throw new TypeError('"list" argument must be an Array of Buffers')
    	    }
    	    buf.copy(buffer, pos);
    	    pos += buf.length;
    	  }
    	  return buffer
    	};

    	function byteLength (string, encoding) {
    	  if (Buffer.isBuffer(string)) {
    	    return string.length
    	  }
    	  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
    	      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
    	    return string.byteLength
    	  }
    	  if (typeof string !== 'string') {
    	    string = '' + string;
    	  }

    	  var len = string.length;
    	  if (len === 0) return 0

    	  // Use a for loop to avoid recursion
    	  var loweredCase = false;
    	  for (;;) {
    	    switch (encoding) {
    	      case 'ascii':
    	      case 'latin1':
    	      case 'binary':
    	        return len
    	      case 'utf8':
    	      case 'utf-8':
    	      case undefined:
    	        return utf8ToBytes(string).length
    	      case 'ucs2':
    	      case 'ucs-2':
    	      case 'utf16le':
    	      case 'utf-16le':
    	        return len * 2
    	      case 'hex':
    	        return len >>> 1
    	      case 'base64':
    	        return base64ToBytes(string).length
    	      default:
    	        if (loweredCase) return utf8ToBytes(string).length // assume utf8
    	        encoding = ('' + encoding).toLowerCase();
    	        loweredCase = true;
    	    }
    	  }
    	}
    	Buffer.byteLength = byteLength;

    	function slowToString (encoding, start, end) {
    	  var loweredCase = false;

    	  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
    	  // property of a typed array.

    	  // This behaves neither like String nor Uint8Array in that we set start/end
    	  // to their upper/lower bounds if the value passed is out of range.
    	  // undefined is handled specially as per ECMA-262 6th Edition,
    	  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
    	  if (start === undefined || start < 0) {
    	    start = 0;
    	  }
    	  // Return early if start > this.length. Done here to prevent potential uint32
    	  // coercion fail below.
    	  if (start > this.length) {
    	    return ''
    	  }

    	  if (end === undefined || end > this.length) {
    	    end = this.length;
    	  }

    	  if (end <= 0) {
    	    return ''
    	  }

    	  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
    	  end >>>= 0;
    	  start >>>= 0;

    	  if (end <= start) {
    	    return ''
    	  }

    	  if (!encoding) encoding = 'utf8';

    	  while (true) {
    	    switch (encoding) {
    	      case 'hex':
    	        return hexSlice(this, start, end)

    	      case 'utf8':
    	      case 'utf-8':
    	        return utf8Slice(this, start, end)

    	      case 'ascii':
    	        return asciiSlice(this, start, end)

    	      case 'latin1':
    	      case 'binary':
    	        return latin1Slice(this, start, end)

    	      case 'base64':
    	        return base64Slice(this, start, end)

    	      case 'ucs2':
    	      case 'ucs-2':
    	      case 'utf16le':
    	      case 'utf-16le':
    	        return utf16leSlice(this, start, end)

    	      default:
    	        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
    	        encoding = (encoding + '').toLowerCase();
    	        loweredCase = true;
    	    }
    	  }
    	}

    	// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
    	// Buffer instances.
    	Buffer.prototype._isBuffer = true;

    	function swap (b, n, m) {
    	  var i = b[n];
    	  b[n] = b[m];
    	  b[m] = i;
    	}

    	Buffer.prototype.swap16 = function swap16 () {
    	  var len = this.length;
    	  if (len % 2 !== 0) {
    	    throw new RangeError('Buffer size must be a multiple of 16-bits')
    	  }
    	  for (var i = 0; i < len; i += 2) {
    	    swap(this, i, i + 1);
    	  }
    	  return this
    	};

    	Buffer.prototype.swap32 = function swap32 () {
    	  var len = this.length;
    	  if (len % 4 !== 0) {
    	    throw new RangeError('Buffer size must be a multiple of 32-bits')
    	  }
    	  for (var i = 0; i < len; i += 4) {
    	    swap(this, i, i + 3);
    	    swap(this, i + 1, i + 2);
    	  }
    	  return this
    	};

    	Buffer.prototype.swap64 = function swap64 () {
    	  var len = this.length;
    	  if (len % 8 !== 0) {
    	    throw new RangeError('Buffer size must be a multiple of 64-bits')
    	  }
    	  for (var i = 0; i < len; i += 8) {
    	    swap(this, i, i + 7);
    	    swap(this, i + 1, i + 6);
    	    swap(this, i + 2, i + 5);
    	    swap(this, i + 3, i + 4);
    	  }
    	  return this
    	};

    	Buffer.prototype.toString = function toString () {
    	  var length = this.length | 0;
    	  if (length === 0) return ''
    	  if (arguments.length === 0) return utf8Slice(this, 0, length)
    	  return slowToString.apply(this, arguments)
    	};

    	Buffer.prototype.equals = function equals (b) {
    	  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
    	  if (this === b) return true
    	  return Buffer.compare(this, b) === 0
    	};

    	Buffer.prototype.inspect = function inspect () {
    	  var str = '';
    	  var max = exports.INSPECT_MAX_BYTES;
    	  if (this.length > 0) {
    	    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');
    	    if (this.length > max) str += ' ... ';
    	  }
    	  return '<Buffer ' + str + '>'
    	};

    	Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
    	  if (!Buffer.isBuffer(target)) {
    	    throw new TypeError('Argument must be a Buffer')
    	  }

    	  if (start === undefined) {
    	    start = 0;
    	  }
    	  if (end === undefined) {
    	    end = target ? target.length : 0;
    	  }
    	  if (thisStart === undefined) {
    	    thisStart = 0;
    	  }
    	  if (thisEnd === undefined) {
    	    thisEnd = this.length;
    	  }

    	  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
    	    throw new RangeError('out of range index')
    	  }

    	  if (thisStart >= thisEnd && start >= end) {
    	    return 0
    	  }
    	  if (thisStart >= thisEnd) {
    	    return -1
    	  }
    	  if (start >= end) {
    	    return 1
    	  }

    	  start >>>= 0;
    	  end >>>= 0;
    	  thisStart >>>= 0;
    	  thisEnd >>>= 0;

    	  if (this === target) return 0

    	  var x = thisEnd - thisStart;
    	  var y = end - start;
    	  var len = Math.min(x, y);

    	  var thisCopy = this.slice(thisStart, thisEnd);
    	  var targetCopy = target.slice(start, end);

    	  for (var i = 0; i < len; ++i) {
    	    if (thisCopy[i] !== targetCopy[i]) {
    	      x = thisCopy[i];
    	      y = targetCopy[i];
    	      break
    	    }
    	  }

    	  if (x < y) return -1
    	  if (y < x) return 1
    	  return 0
    	};

    	// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
    	// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
    	//
    	// Arguments:
    	// - buffer - a Buffer to search
    	// - val - a string, Buffer, or number
    	// - byteOffset - an index into `buffer`; will be clamped to an int32
    	// - encoding - an optional encoding, relevant is val is a string
    	// - dir - true for indexOf, false for lastIndexOf
    	function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
    	  // Empty buffer means no match
    	  if (buffer.length === 0) return -1

    	  // Normalize byteOffset
    	  if (typeof byteOffset === 'string') {
    	    encoding = byteOffset;
    	    byteOffset = 0;
    	  } else if (byteOffset > 0x7fffffff) {
    	    byteOffset = 0x7fffffff;
    	  } else if (byteOffset < -0x80000000) {
    	    byteOffset = -0x80000000;
    	  }
    	  byteOffset = +byteOffset;  // Coerce to Number.
    	  if (isNaN(byteOffset)) {
    	    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
    	    byteOffset = dir ? 0 : (buffer.length - 1);
    	  }

    	  // Normalize byteOffset: negative offsets start from the end of the buffer
    	  if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
    	  if (byteOffset >= buffer.length) {
    	    if (dir) return -1
    	    else byteOffset = buffer.length - 1;
    	  } else if (byteOffset < 0) {
    	    if (dir) byteOffset = 0;
    	    else return -1
    	  }

    	  // Normalize val
    	  if (typeof val === 'string') {
    	    val = Buffer.from(val, encoding);
    	  }

    	  // Finally, search either indexOf (if dir is true) or lastIndexOf
    	  if (Buffer.isBuffer(val)) {
    	    // Special case: looking for empty string/buffer always fails
    	    if (val.length === 0) {
    	      return -1
    	    }
    	    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
    	  } else if (typeof val === 'number') {
    	    val = val & 0xFF; // Search for a byte value [0-255]
    	    if (Buffer.TYPED_ARRAY_SUPPORT &&
    	        typeof Uint8Array.prototype.indexOf === 'function') {
    	      if (dir) {
    	        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
    	      } else {
    	        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
    	      }
    	    }
    	    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
    	  }

    	  throw new TypeError('val must be string, number or Buffer')
    	}

    	function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
    	  var indexSize = 1;
    	  var arrLength = arr.length;
    	  var valLength = val.length;

    	  if (encoding !== undefined) {
    	    encoding = String(encoding).toLowerCase();
    	    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
    	        encoding === 'utf16le' || encoding === 'utf-16le') {
    	      if (arr.length < 2 || val.length < 2) {
    	        return -1
    	      }
    	      indexSize = 2;
    	      arrLength /= 2;
    	      valLength /= 2;
    	      byteOffset /= 2;
    	    }
    	  }

    	  function read (buf, i) {
    	    if (indexSize === 1) {
    	      return buf[i]
    	    } else {
    	      return buf.readUInt16BE(i * indexSize)
    	    }
    	  }

    	  var i;
    	  if (dir) {
    	    var foundIndex = -1;
    	    for (i = byteOffset; i < arrLength; i++) {
    	      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
    	        if (foundIndex === -1) foundIndex = i;
    	        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
    	      } else {
    	        if (foundIndex !== -1) i -= i - foundIndex;
    	        foundIndex = -1;
    	      }
    	    }
    	  } else {
    	    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
    	    for (i = byteOffset; i >= 0; i--) {
    	      var found = true;
    	      for (var j = 0; j < valLength; j++) {
    	        if (read(arr, i + j) !== read(val, j)) {
    	          found = false;
    	          break
    	        }
    	      }
    	      if (found) return i
    	    }
    	  }

    	  return -1
    	}

    	Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
    	  return this.indexOf(val, byteOffset, encoding) !== -1
    	};

    	Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
    	  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
    	};

    	Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
    	  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
    	};

    	function hexWrite (buf, string, offset, length) {
    	  offset = Number(offset) || 0;
    	  var remaining = buf.length - offset;
    	  if (!length) {
    	    length = remaining;
    	  } else {
    	    length = Number(length);
    	    if (length > remaining) {
    	      length = remaining;
    	    }
    	  }

    	  // must be an even number of digits
    	  var strLen = string.length;
    	  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')

    	  if (length > strLen / 2) {
    	    length = strLen / 2;
    	  }
    	  for (var i = 0; i < length; ++i) {
    	    var parsed = parseInt(string.substr(i * 2, 2), 16);
    	    if (isNaN(parsed)) return i
    	    buf[offset + i] = parsed;
    	  }
    	  return i
    	}

    	function utf8Write (buf, string, offset, length) {
    	  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
    	}

    	function asciiWrite (buf, string, offset, length) {
    	  return blitBuffer(asciiToBytes(string), buf, offset, length)
    	}

    	function latin1Write (buf, string, offset, length) {
    	  return asciiWrite(buf, string, offset, length)
    	}

    	function base64Write (buf, string, offset, length) {
    	  return blitBuffer(base64ToBytes(string), buf, offset, length)
    	}

    	function ucs2Write (buf, string, offset, length) {
    	  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
    	}

    	Buffer.prototype.write = function write (string, offset, length, encoding) {
    	  // Buffer#write(string)
    	  if (offset === undefined) {
    	    encoding = 'utf8';
    	    length = this.length;
    	    offset = 0;
    	  // Buffer#write(string, encoding)
    	  } else if (length === undefined && typeof offset === 'string') {
    	    encoding = offset;
    	    length = this.length;
    	    offset = 0;
    	  // Buffer#write(string, offset[, length][, encoding])
    	  } else if (isFinite(offset)) {
    	    offset = offset | 0;
    	    if (isFinite(length)) {
    	      length = length | 0;
    	      if (encoding === undefined) encoding = 'utf8';
    	    } else {
    	      encoding = length;
    	      length = undefined;
    	    }
    	  // legacy write(string, encoding, offset, length) - remove in v0.13
    	  } else {
    	    throw new Error(
    	      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
    	    )
    	  }

    	  var remaining = this.length - offset;
    	  if (length === undefined || length > remaining) length = remaining;

    	  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
    	    throw new RangeError('Attempt to write outside buffer bounds')
    	  }

    	  if (!encoding) encoding = 'utf8';

    	  var loweredCase = false;
    	  for (;;) {
    	    switch (encoding) {
    	      case 'hex':
    	        return hexWrite(this, string, offset, length)

    	      case 'utf8':
    	      case 'utf-8':
    	        return utf8Write(this, string, offset, length)

    	      case 'ascii':
    	        return asciiWrite(this, string, offset, length)

    	      case 'latin1':
    	      case 'binary':
    	        return latin1Write(this, string, offset, length)

    	      case 'base64':
    	        // Warning: maxLength not taken into account in base64Write
    	        return base64Write(this, string, offset, length)

    	      case 'ucs2':
    	      case 'ucs-2':
    	      case 'utf16le':
    	      case 'utf-16le':
    	        return ucs2Write(this, string, offset, length)

    	      default:
    	        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
    	        encoding = ('' + encoding).toLowerCase();
    	        loweredCase = true;
    	    }
    	  }
    	};

    	Buffer.prototype.toJSON = function toJSON () {
    	  return {
    	    type: 'Buffer',
    	    data: Array.prototype.slice.call(this._arr || this, 0)
    	  }
    	};

    	function base64Slice (buf, start, end) {
    	  if (start === 0 && end === buf.length) {
    	    return base64.fromByteArray(buf)
    	  } else {
    	    return base64.fromByteArray(buf.slice(start, end))
    	  }
    	}

    	function utf8Slice (buf, start, end) {
    	  end = Math.min(buf.length, end);
    	  var res = [];

    	  var i = start;
    	  while (i < end) {
    	    var firstByte = buf[i];
    	    var codePoint = null;
    	    var bytesPerSequence = (firstByte > 0xEF) ? 4
    	      : (firstByte > 0xDF) ? 3
    	      : (firstByte > 0xBF) ? 2
    	      : 1;

    	    if (i + bytesPerSequence <= end) {
    	      var secondByte, thirdByte, fourthByte, tempCodePoint;

    	      switch (bytesPerSequence) {
    	        case 1:
    	          if (firstByte < 0x80) {
    	            codePoint = firstByte;
    	          }
    	          break
    	        case 2:
    	          secondByte = buf[i + 1];
    	          if ((secondByte & 0xC0) === 0x80) {
    	            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F);
    	            if (tempCodePoint > 0x7F) {
    	              codePoint = tempCodePoint;
    	            }
    	          }
    	          break
    	        case 3:
    	          secondByte = buf[i + 1];
    	          thirdByte = buf[i + 2];
    	          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
    	            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F);
    	            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
    	              codePoint = tempCodePoint;
    	            }
    	          }
    	          break
    	        case 4:
    	          secondByte = buf[i + 1];
    	          thirdByte = buf[i + 2];
    	          fourthByte = buf[i + 3];
    	          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
    	            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F);
    	            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
    	              codePoint = tempCodePoint;
    	            }
    	          }
    	      }
    	    }

    	    if (codePoint === null) {
    	      // we did not generate a valid codePoint so insert a
    	      // replacement char (U+FFFD) and advance only 1 byte
    	      codePoint = 0xFFFD;
    	      bytesPerSequence = 1;
    	    } else if (codePoint > 0xFFFF) {
    	      // encode to utf16 (surrogate pair dance)
    	      codePoint -= 0x10000;
    	      res.push(codePoint >>> 10 & 0x3FF | 0xD800);
    	      codePoint = 0xDC00 | codePoint & 0x3FF;
    	    }

    	    res.push(codePoint);
    	    i += bytesPerSequence;
    	  }

    	  return decodeCodePointsArray(res)
    	}

    	// Based on http://stackoverflow.com/a/22747272/680742, the browser with
    	// the lowest limit is Chrome, with 0x10000 args.
    	// We go 1 magnitude less, for safety
    	var MAX_ARGUMENTS_LENGTH = 0x1000;

    	function decodeCodePointsArray (codePoints) {
    	  var len = codePoints.length;
    	  if (len <= MAX_ARGUMENTS_LENGTH) {
    	    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
    	  }

    	  // Decode in chunks to avoid "call stack size exceeded".
    	  var res = '';
    	  var i = 0;
    	  while (i < len) {
    	    res += String.fromCharCode.apply(
    	      String,
    	      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
    	    );
    	  }
    	  return res
    	}

    	function asciiSlice (buf, start, end) {
    	  var ret = '';
    	  end = Math.min(buf.length, end);

    	  for (var i = start; i < end; ++i) {
    	    ret += String.fromCharCode(buf[i] & 0x7F);
    	  }
    	  return ret
    	}

    	function latin1Slice (buf, start, end) {
    	  var ret = '';
    	  end = Math.min(buf.length, end);

    	  for (var i = start; i < end; ++i) {
    	    ret += String.fromCharCode(buf[i]);
    	  }
    	  return ret
    	}

    	function hexSlice (buf, start, end) {
    	  var len = buf.length;

    	  if (!start || start < 0) start = 0;
    	  if (!end || end < 0 || end > len) end = len;

    	  var out = '';
    	  for (var i = start; i < end; ++i) {
    	    out += toHex(buf[i]);
    	  }
    	  return out
    	}

    	function utf16leSlice (buf, start, end) {
    	  var bytes = buf.slice(start, end);
    	  var res = '';
    	  for (var i = 0; i < bytes.length; i += 2) {
    	    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
    	  }
    	  return res
    	}

    	Buffer.prototype.slice = function slice (start, end) {
    	  var len = this.length;
    	  start = ~~start;
    	  end = end === undefined ? len : ~~end;

    	  if (start < 0) {
    	    start += len;
    	    if (start < 0) start = 0;
    	  } else if (start > len) {
    	    start = len;
    	  }

    	  if (end < 0) {
    	    end += len;
    	    if (end < 0) end = 0;
    	  } else if (end > len) {
    	    end = len;
    	  }

    	  if (end < start) end = start;

    	  var newBuf;
    	  if (Buffer.TYPED_ARRAY_SUPPORT) {
    	    newBuf = this.subarray(start, end);
    	    newBuf.__proto__ = Buffer.prototype;
    	  } else {
    	    var sliceLen = end - start;
    	    newBuf = new Buffer(sliceLen, undefined);
    	    for (var i = 0; i < sliceLen; ++i) {
    	      newBuf[i] = this[i + start];
    	    }
    	  }

    	  return newBuf
    	};

    	/*
    	 * Need to make sure that buffer isn't trying to write out of bounds.
    	 */
    	function checkOffset (offset, ext, length) {
    	  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
    	  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
    	}

    	Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
    	  offset = offset | 0;
    	  byteLength = byteLength | 0;
    	  if (!noAssert) checkOffset(offset, byteLength, this.length);

    	  var val = this[offset];
    	  var mul = 1;
    	  var i = 0;
    	  while (++i < byteLength && (mul *= 0x100)) {
    	    val += this[offset + i] * mul;
    	  }

    	  return val
    	};

    	Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
    	  offset = offset | 0;
    	  byteLength = byteLength | 0;
    	  if (!noAssert) {
    	    checkOffset(offset, byteLength, this.length);
    	  }

    	  var val = this[offset + --byteLength];
    	  var mul = 1;
    	  while (byteLength > 0 && (mul *= 0x100)) {
    	    val += this[offset + --byteLength] * mul;
    	  }

    	  return val
    	};

    	Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
    	  if (!noAssert) checkOffset(offset, 1, this.length);
    	  return this[offset]
    	};

    	Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
    	  if (!noAssert) checkOffset(offset, 2, this.length);
    	  return this[offset] | (this[offset + 1] << 8)
    	};

    	Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
    	  if (!noAssert) checkOffset(offset, 2, this.length);
    	  return (this[offset] << 8) | this[offset + 1]
    	};

    	Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
    	  if (!noAssert) checkOffset(offset, 4, this.length);

    	  return ((this[offset]) |
    	      (this[offset + 1] << 8) |
    	      (this[offset + 2] << 16)) +
    	      (this[offset + 3] * 0x1000000)
    	};

    	Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
    	  if (!noAssert) checkOffset(offset, 4, this.length);

    	  return (this[offset] * 0x1000000) +
    	    ((this[offset + 1] << 16) |
    	    (this[offset + 2] << 8) |
    	    this[offset + 3])
    	};

    	Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
    	  offset = offset | 0;
    	  byteLength = byteLength | 0;
    	  if (!noAssert) checkOffset(offset, byteLength, this.length);

    	  var val = this[offset];
    	  var mul = 1;
    	  var i = 0;
    	  while (++i < byteLength && (mul *= 0x100)) {
    	    val += this[offset + i] * mul;
    	  }
    	  mul *= 0x80;

    	  if (val >= mul) val -= Math.pow(2, 8 * byteLength);

    	  return val
    	};

    	Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
    	  offset = offset | 0;
    	  byteLength = byteLength | 0;
    	  if (!noAssert) checkOffset(offset, byteLength, this.length);

    	  var i = byteLength;
    	  var mul = 1;
    	  var val = this[offset + --i];
    	  while (i > 0 && (mul *= 0x100)) {
    	    val += this[offset + --i] * mul;
    	  }
    	  mul *= 0x80;

    	  if (val >= mul) val -= Math.pow(2, 8 * byteLength);

    	  return val
    	};

    	Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
    	  if (!noAssert) checkOffset(offset, 1, this.length);
    	  if (!(this[offset] & 0x80)) return (this[offset])
    	  return ((0xff - this[offset] + 1) * -1)
    	};

    	Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
    	  if (!noAssert) checkOffset(offset, 2, this.length);
    	  var val = this[offset] | (this[offset + 1] << 8);
    	  return (val & 0x8000) ? val | 0xFFFF0000 : val
    	};

    	Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
    	  if (!noAssert) checkOffset(offset, 2, this.length);
    	  var val = this[offset + 1] | (this[offset] << 8);
    	  return (val & 0x8000) ? val | 0xFFFF0000 : val
    	};

    	Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
    	  if (!noAssert) checkOffset(offset, 4, this.length);

    	  return (this[offset]) |
    	    (this[offset + 1] << 8) |
    	    (this[offset + 2] << 16) |
    	    (this[offset + 3] << 24)
    	};

    	Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
    	  if (!noAssert) checkOffset(offset, 4, this.length);

    	  return (this[offset] << 24) |
    	    (this[offset + 1] << 16) |
    	    (this[offset + 2] << 8) |
    	    (this[offset + 3])
    	};

    	Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
    	  if (!noAssert) checkOffset(offset, 4, this.length);
    	  return ieee754.read(this, offset, true, 23, 4)
    	};

    	Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
    	  if (!noAssert) checkOffset(offset, 4, this.length);
    	  return ieee754.read(this, offset, false, 23, 4)
    	};

    	Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
    	  if (!noAssert) checkOffset(offset, 8, this.length);
    	  return ieee754.read(this, offset, true, 52, 8)
    	};

    	Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
    	  if (!noAssert) checkOffset(offset, 8, this.length);
    	  return ieee754.read(this, offset, false, 52, 8)
    	};

    	function checkInt (buf, value, offset, ext, max, min) {
    	  if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
    	  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
    	  if (offset + ext > buf.length) throw new RangeError('Index out of range')
    	}

    	Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
    	  value = +value;
    	  offset = offset | 0;
    	  byteLength = byteLength | 0;
    	  if (!noAssert) {
    	    var maxBytes = Math.pow(2, 8 * byteLength) - 1;
    	    checkInt(this, value, offset, byteLength, maxBytes, 0);
    	  }

    	  var mul = 1;
    	  var i = 0;
    	  this[offset] = value & 0xFF;
    	  while (++i < byteLength && (mul *= 0x100)) {
    	    this[offset + i] = (value / mul) & 0xFF;
    	  }

    	  return offset + byteLength
    	};

    	Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
    	  value = +value;
    	  offset = offset | 0;
    	  byteLength = byteLength | 0;
    	  if (!noAssert) {
    	    var maxBytes = Math.pow(2, 8 * byteLength) - 1;
    	    checkInt(this, value, offset, byteLength, maxBytes, 0);
    	  }

    	  var i = byteLength - 1;
    	  var mul = 1;
    	  this[offset + i] = value & 0xFF;
    	  while (--i >= 0 && (mul *= 0x100)) {
    	    this[offset + i] = (value / mul) & 0xFF;
    	  }

    	  return offset + byteLength
    	};

    	Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
    	  value = +value;
    	  offset = offset | 0;
    	  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);
    	  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
    	  this[offset] = (value & 0xff);
    	  return offset + 1
    	};

    	function objectWriteUInt16 (buf, value, offset, littleEndian) {
    	  if (value < 0) value = 0xffff + value + 1;
    	  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
    	    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
    	      (littleEndian ? i : 1 - i) * 8;
    	  }
    	}

    	Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
    	  value = +value;
    	  offset = offset | 0;
    	  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
    	  if (Buffer.TYPED_ARRAY_SUPPORT) {
    	    this[offset] = (value & 0xff);
    	    this[offset + 1] = (value >>> 8);
    	  } else {
    	    objectWriteUInt16(this, value, offset, true);
    	  }
    	  return offset + 2
    	};

    	Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
    	  value = +value;
    	  offset = offset | 0;
    	  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
    	  if (Buffer.TYPED_ARRAY_SUPPORT) {
    	    this[offset] = (value >>> 8);
    	    this[offset + 1] = (value & 0xff);
    	  } else {
    	    objectWriteUInt16(this, value, offset, false);
    	  }
    	  return offset + 2
    	};

    	function objectWriteUInt32 (buf, value, offset, littleEndian) {
    	  if (value < 0) value = 0xffffffff + value + 1;
    	  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
    	    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff;
    	  }
    	}

    	Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
    	  value = +value;
    	  offset = offset | 0;
    	  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
    	  if (Buffer.TYPED_ARRAY_SUPPORT) {
    	    this[offset + 3] = (value >>> 24);
    	    this[offset + 2] = (value >>> 16);
    	    this[offset + 1] = (value >>> 8);
    	    this[offset] = (value & 0xff);
    	  } else {
    	    objectWriteUInt32(this, value, offset, true);
    	  }
    	  return offset + 4
    	};

    	Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
    	  value = +value;
    	  offset = offset | 0;
    	  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
    	  if (Buffer.TYPED_ARRAY_SUPPORT) {
    	    this[offset] = (value >>> 24);
    	    this[offset + 1] = (value >>> 16);
    	    this[offset + 2] = (value >>> 8);
    	    this[offset + 3] = (value & 0xff);
    	  } else {
    	    objectWriteUInt32(this, value, offset, false);
    	  }
    	  return offset + 4
    	};

    	Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
    	  value = +value;
    	  offset = offset | 0;
    	  if (!noAssert) {
    	    var limit = Math.pow(2, 8 * byteLength - 1);

    	    checkInt(this, value, offset, byteLength, limit - 1, -limit);
    	  }

    	  var i = 0;
    	  var mul = 1;
    	  var sub = 0;
    	  this[offset] = value & 0xFF;
    	  while (++i < byteLength && (mul *= 0x100)) {
    	    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
    	      sub = 1;
    	    }
    	    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
    	  }

    	  return offset + byteLength
    	};

    	Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
    	  value = +value;
    	  offset = offset | 0;
    	  if (!noAssert) {
    	    var limit = Math.pow(2, 8 * byteLength - 1);

    	    checkInt(this, value, offset, byteLength, limit - 1, -limit);
    	  }

    	  var i = byteLength - 1;
    	  var mul = 1;
    	  var sub = 0;
    	  this[offset + i] = value & 0xFF;
    	  while (--i >= 0 && (mul *= 0x100)) {
    	    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
    	      sub = 1;
    	    }
    	    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
    	  }

    	  return offset + byteLength
    	};

    	Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
    	  value = +value;
    	  offset = offset | 0;
    	  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);
    	  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
    	  if (value < 0) value = 0xff + value + 1;
    	  this[offset] = (value & 0xff);
    	  return offset + 1
    	};

    	Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
    	  value = +value;
    	  offset = offset | 0;
    	  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
    	  if (Buffer.TYPED_ARRAY_SUPPORT) {
    	    this[offset] = (value & 0xff);
    	    this[offset + 1] = (value >>> 8);
    	  } else {
    	    objectWriteUInt16(this, value, offset, true);
    	  }
    	  return offset + 2
    	};

    	Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
    	  value = +value;
    	  offset = offset | 0;
    	  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
    	  if (Buffer.TYPED_ARRAY_SUPPORT) {
    	    this[offset] = (value >>> 8);
    	    this[offset + 1] = (value & 0xff);
    	  } else {
    	    objectWriteUInt16(this, value, offset, false);
    	  }
    	  return offset + 2
    	};

    	Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
    	  value = +value;
    	  offset = offset | 0;
    	  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
    	  if (Buffer.TYPED_ARRAY_SUPPORT) {
    	    this[offset] = (value & 0xff);
    	    this[offset + 1] = (value >>> 8);
    	    this[offset + 2] = (value >>> 16);
    	    this[offset + 3] = (value >>> 24);
    	  } else {
    	    objectWriteUInt32(this, value, offset, true);
    	  }
    	  return offset + 4
    	};

    	Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
    	  value = +value;
    	  offset = offset | 0;
    	  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
    	  if (value < 0) value = 0xffffffff + value + 1;
    	  if (Buffer.TYPED_ARRAY_SUPPORT) {
    	    this[offset] = (value >>> 24);
    	    this[offset + 1] = (value >>> 16);
    	    this[offset + 2] = (value >>> 8);
    	    this[offset + 3] = (value & 0xff);
    	  } else {
    	    objectWriteUInt32(this, value, offset, false);
    	  }
    	  return offset + 4
    	};

    	function checkIEEE754 (buf, value, offset, ext, max, min) {
    	  if (offset + ext > buf.length) throw new RangeError('Index out of range')
    	  if (offset < 0) throw new RangeError('Index out of range')
    	}

    	function writeFloat (buf, value, offset, littleEndian, noAssert) {
    	  if (!noAssert) {
    	    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38);
    	  }
    	  ieee754.write(buf, value, offset, littleEndian, 23, 4);
    	  return offset + 4
    	}

    	Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
    	  return writeFloat(this, value, offset, true, noAssert)
    	};

    	Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
    	  return writeFloat(this, value, offset, false, noAssert)
    	};

    	function writeDouble (buf, value, offset, littleEndian, noAssert) {
    	  if (!noAssert) {
    	    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308);
    	  }
    	  ieee754.write(buf, value, offset, littleEndian, 52, 8);
    	  return offset + 8
    	}

    	Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
    	  return writeDouble(this, value, offset, true, noAssert)
    	};

    	Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
    	  return writeDouble(this, value, offset, false, noAssert)
    	};

    	// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
    	Buffer.prototype.copy = function copy (target, targetStart, start, end) {
    	  if (!start) start = 0;
    	  if (!end && end !== 0) end = this.length;
    	  if (targetStart >= target.length) targetStart = target.length;
    	  if (!targetStart) targetStart = 0;
    	  if (end > 0 && end < start) end = start;

    	  // Copy 0 bytes; we're done
    	  if (end === start) return 0
    	  if (target.length === 0 || this.length === 0) return 0

    	  // Fatal error conditions
    	  if (targetStart < 0) {
    	    throw new RangeError('targetStart out of bounds')
    	  }
    	  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
    	  if (end < 0) throw new RangeError('sourceEnd out of bounds')

    	  // Are we oob?
    	  if (end > this.length) end = this.length;
    	  if (target.length - targetStart < end - start) {
    	    end = target.length - targetStart + start;
    	  }

    	  var len = end - start;
    	  var i;

    	  if (this === target && start < targetStart && targetStart < end) {
    	    // descending copy from end
    	    for (i = len - 1; i >= 0; --i) {
    	      target[i + targetStart] = this[i + start];
    	    }
    	  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
    	    // ascending copy from start
    	    for (i = 0; i < len; ++i) {
    	      target[i + targetStart] = this[i + start];
    	    }
    	  } else {
    	    Uint8Array.prototype.set.call(
    	      target,
    	      this.subarray(start, start + len),
    	      targetStart
    	    );
    	  }

    	  return len
    	};

    	// Usage:
    	//    buffer.fill(number[, offset[, end]])
    	//    buffer.fill(buffer[, offset[, end]])
    	//    buffer.fill(string[, offset[, end]][, encoding])
    	Buffer.prototype.fill = function fill (val, start, end, encoding) {
    	  // Handle string cases:
    	  if (typeof val === 'string') {
    	    if (typeof start === 'string') {
    	      encoding = start;
    	      start = 0;
    	      end = this.length;
    	    } else if (typeof end === 'string') {
    	      encoding = end;
    	      end = this.length;
    	    }
    	    if (val.length === 1) {
    	      var code = val.charCodeAt(0);
    	      if (code < 256) {
    	        val = code;
    	      }
    	    }
    	    if (encoding !== undefined && typeof encoding !== 'string') {
    	      throw new TypeError('encoding must be a string')
    	    }
    	    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
    	      throw new TypeError('Unknown encoding: ' + encoding)
    	    }
    	  } else if (typeof val === 'number') {
    	    val = val & 255;
    	  }

    	  // Invalid ranges are not set to a default, so can range check early.
    	  if (start < 0 || this.length < start || this.length < end) {
    	    throw new RangeError('Out of range index')
    	  }

    	  if (end <= start) {
    	    return this
    	  }

    	  start = start >>> 0;
    	  end = end === undefined ? this.length : end >>> 0;

    	  if (!val) val = 0;

    	  var i;
    	  if (typeof val === 'number') {
    	    for (i = start; i < end; ++i) {
    	      this[i] = val;
    	    }
    	  } else {
    	    var bytes = Buffer.isBuffer(val)
    	      ? val
    	      : utf8ToBytes(new Buffer(val, encoding).toString());
    	    var len = bytes.length;
    	    for (i = 0; i < end - start; ++i) {
    	      this[i + start] = bytes[i % len];
    	    }
    	  }

    	  return this
    	};

    	// HELPER FUNCTIONS
    	// ================

    	var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g;

    	function base64clean (str) {
    	  // Node strips out invalid characters like \n and \t from the string, base64-js does not
    	  str = stringtrim(str).replace(INVALID_BASE64_RE, '');
    	  // Node converts strings with length < 2 to ''
    	  if (str.length < 2) return ''
    	  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
    	  while (str.length % 4 !== 0) {
    	    str = str + '=';
    	  }
    	  return str
    	}

    	function stringtrim (str) {
    	  if (str.trim) return str.trim()
    	  return str.replace(/^\s+|\s+$/g, '')
    	}

    	function toHex (n) {
    	  if (n < 16) return '0' + n.toString(16)
    	  return n.toString(16)
    	}

    	function utf8ToBytes (string, units) {
    	  units = units || Infinity;
    	  var codePoint;
    	  var length = string.length;
    	  var leadSurrogate = null;
    	  var bytes = [];

    	  for (var i = 0; i < length; ++i) {
    	    codePoint = string.charCodeAt(i);

    	    // is surrogate component
    	    if (codePoint > 0xD7FF && codePoint < 0xE000) {
    	      // last char was a lead
    	      if (!leadSurrogate) {
    	        // no lead yet
    	        if (codePoint > 0xDBFF) {
    	          // unexpected trail
    	          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
    	          continue
    	        } else if (i + 1 === length) {
    	          // unpaired lead
    	          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
    	          continue
    	        }

    	        // valid lead
    	        leadSurrogate = codePoint;

    	        continue
    	      }

    	      // 2 leads in a row
    	      if (codePoint < 0xDC00) {
    	        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
    	        leadSurrogate = codePoint;
    	        continue
    	      }

    	      // valid surrogate pair
    	      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;
    	    } else if (leadSurrogate) {
    	      // valid bmp char, but last char was a lead
    	      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
    	    }

    	    leadSurrogate = null;

    	    // encode utf8
    	    if (codePoint < 0x80) {
    	      if ((units -= 1) < 0) break
    	      bytes.push(codePoint);
    	    } else if (codePoint < 0x800) {
    	      if ((units -= 2) < 0) break
    	      bytes.push(
    	        codePoint >> 0x6 | 0xC0,
    	        codePoint & 0x3F | 0x80
    	      );
    	    } else if (codePoint < 0x10000) {
    	      if ((units -= 3) < 0) break
    	      bytes.push(
    	        codePoint >> 0xC | 0xE0,
    	        codePoint >> 0x6 & 0x3F | 0x80,
    	        codePoint & 0x3F | 0x80
    	      );
    	    } else if (codePoint < 0x110000) {
    	      if ((units -= 4) < 0) break
    	      bytes.push(
    	        codePoint >> 0x12 | 0xF0,
    	        codePoint >> 0xC & 0x3F | 0x80,
    	        codePoint >> 0x6 & 0x3F | 0x80,
    	        codePoint & 0x3F | 0x80
    	      );
    	    } else {
    	      throw new Error('Invalid code point')
    	    }
    	  }

    	  return bytes
    	}

    	function asciiToBytes (str) {
    	  var byteArray = [];
    	  for (var i = 0; i < str.length; ++i) {
    	    // Node's code seems to be doing this and not & 0x7F..
    	    byteArray.push(str.charCodeAt(i) & 0xFF);
    	  }
    	  return byteArray
    	}

    	function utf16leToBytes (str, units) {
    	  var c, hi, lo;
    	  var byteArray = [];
    	  for (var i = 0; i < str.length; ++i) {
    	    if ((units -= 2) < 0) break

    	    c = str.charCodeAt(i);
    	    hi = c >> 8;
    	    lo = c % 256;
    	    byteArray.push(lo);
    	    byteArray.push(hi);
    	  }

    	  return byteArray
    	}

    	function base64ToBytes (str) {
    	  return base64.toByteArray(base64clean(str))
    	}

    	function blitBuffer (src, dst, offset, length) {
    	  for (var i = 0; i < length; ++i) {
    	    if ((i + offset >= dst.length) || (i >= src.length)) break
    	    dst[i + offset] = src[i];
    	  }
    	  return i
    	}

    	function isnan (val) {
    	  return val !== val // eslint-disable-line no-self-compare
    	}


    /***/ }),
    /* 59 */
    /***/ (function(module, exports) {

    	exports.byteLength = byteLength;
    	exports.toByteArray = toByteArray;
    	exports.fromByteArray = fromByteArray;

    	var lookup = [];
    	var revLookup = [];
    	var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;

    	var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
    	for (var i = 0, len = code.length; i < len; ++i) {
    	  lookup[i] = code[i];
    	  revLookup[code.charCodeAt(i)] = i;
    	}

    	// Support decoding URL-safe base64 strings, as Node.js does.
    	// See: https://en.wikipedia.org/wiki/Base64#URL_applications
    	revLookup['-'.charCodeAt(0)] = 62;
    	revLookup['_'.charCodeAt(0)] = 63;

    	function getLens (b64) {
    	  var len = b64.length;

    	  if (len % 4 > 0) {
    	    throw new Error('Invalid string. Length must be a multiple of 4')
    	  }

    	  // Trim off extra bytes after placeholder bytes are found
    	  // See: https://github.com/beatgammit/base64-js/issues/42
    	  var validLen = b64.indexOf('=');
    	  if (validLen === -1) validLen = len;

    	  var placeHoldersLen = validLen === len
    	    ? 0
    	    : 4 - (validLen % 4);

    	  return [validLen, placeHoldersLen]
    	}

    	// base64 is 4/3 + up to two characters of the original data
    	function byteLength (b64) {
    	  var lens = getLens(b64);
    	  var validLen = lens[0];
    	  var placeHoldersLen = lens[1];
    	  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
    	}

    	function _byteLength (b64, validLen, placeHoldersLen) {
    	  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
    	}

    	function toByteArray (b64) {
    	  var tmp;
    	  var lens = getLens(b64);
    	  var validLen = lens[0];
    	  var placeHoldersLen = lens[1];

    	  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));

    	  var curByte = 0;

    	  // if there are placeholders, only get up to the last complete 4 chars
    	  var len = placeHoldersLen > 0
    	    ? validLen - 4
    	    : validLen;

    	  for (var i = 0; i < len; i += 4) {
    	    tmp =
    	      (revLookup[b64.charCodeAt(i)] << 18) |
    	      (revLookup[b64.charCodeAt(i + 1)] << 12) |
    	      (revLookup[b64.charCodeAt(i + 2)] << 6) |
    	      revLookup[b64.charCodeAt(i + 3)];
    	    arr[curByte++] = (tmp >> 16) & 0xFF;
    	    arr[curByte++] = (tmp >> 8) & 0xFF;
    	    arr[curByte++] = tmp & 0xFF;
    	  }

    	  if (placeHoldersLen === 2) {
    	    tmp =
    	      (revLookup[b64.charCodeAt(i)] << 2) |
    	      (revLookup[b64.charCodeAt(i + 1)] >> 4);
    	    arr[curByte++] = tmp & 0xFF;
    	  }

    	  if (placeHoldersLen === 1) {
    	    tmp =
    	      (revLookup[b64.charCodeAt(i)] << 10) |
    	      (revLookup[b64.charCodeAt(i + 1)] << 4) |
    	      (revLookup[b64.charCodeAt(i + 2)] >> 2);
    	    arr[curByte++] = (tmp >> 8) & 0xFF;
    	    arr[curByte++] = tmp & 0xFF;
    	  }

    	  return arr
    	}

    	function tripletToBase64 (num) {
    	  return lookup[num >> 18 & 0x3F] +
    	    lookup[num >> 12 & 0x3F] +
    	    lookup[num >> 6 & 0x3F] +
    	    lookup[num & 0x3F]
    	}

    	function encodeChunk (uint8, start, end) {
    	  var tmp;
    	  var output = [];
    	  for (var i = start; i < end; i += 3) {
    	    tmp =
    	      ((uint8[i] << 16) & 0xFF0000) +
    	      ((uint8[i + 1] << 8) & 0xFF00) +
    	      (uint8[i + 2] & 0xFF);
    	    output.push(tripletToBase64(tmp));
    	  }
    	  return output.join('')
    	}

    	function fromByteArray (uint8) {
    	  var tmp;
    	  var len = uint8.length;
    	  var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
    	  var parts = [];
    	  var maxChunkLength = 16383; // must be multiple of 3

    	  // go through the array every three bytes, we'll deal with trailing stuff later
    	  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
    	    parts.push(encodeChunk(
    	      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
    	    ));
    	  }

    	  // pad the end with zeros, but make sure to not forget the extra bytes
    	  if (extraBytes === 1) {
    	    tmp = uint8[len - 1];
    	    parts.push(
    	      lookup[tmp >> 2] +
    	      lookup[(tmp << 4) & 0x3F] +
    	      '=='
    	    );
    	  } else if (extraBytes === 2) {
    	    tmp = (uint8[len - 2] << 8) + uint8[len - 1];
    	    parts.push(
    	      lookup[tmp >> 10] +
    	      lookup[(tmp >> 4) & 0x3F] +
    	      lookup[(tmp << 2) & 0x3F] +
    	      '='
    	    );
    	  }

    	  return parts.join('')
    	}


    /***/ }),
    /* 60 */
    /***/ (function(module, exports) {

    	exports.read = function (buffer, offset, isLE, mLen, nBytes) {
    	  var e, m;
    	  var eLen = (nBytes * 8) - mLen - 1;
    	  var eMax = (1 << eLen) - 1;
    	  var eBias = eMax >> 1;
    	  var nBits = -7;
    	  var i = isLE ? (nBytes - 1) : 0;
    	  var d = isLE ? -1 : 1;
    	  var s = buffer[offset + i];

    	  i += d;

    	  e = s & ((1 << (-nBits)) - 1);
    	  s >>= (-nBits);
    	  nBits += eLen;
    	  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}

    	  m = e & ((1 << (-nBits)) - 1);
    	  e >>= (-nBits);
    	  nBits += mLen;
    	  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}

    	  if (e === 0) {
    	    e = 1 - eBias;
    	  } else if (e === eMax) {
    	    return m ? NaN : ((s ? -1 : 1) * Infinity)
    	  } else {
    	    m = m + Math.pow(2, mLen);
    	    e = e - eBias;
    	  }
    	  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
    	};

    	exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
    	  var e, m, c;
    	  var eLen = (nBytes * 8) - mLen - 1;
    	  var eMax = (1 << eLen) - 1;
    	  var eBias = eMax >> 1;
    	  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0);
    	  var i = isLE ? 0 : (nBytes - 1);
    	  var d = isLE ? 1 : -1;
    	  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;

    	  value = Math.abs(value);

    	  if (isNaN(value) || value === Infinity) {
    	    m = isNaN(value) ? 1 : 0;
    	    e = eMax;
    	  } else {
    	    e = Math.floor(Math.log(value) / Math.LN2);
    	    if (value * (c = Math.pow(2, -e)) < 1) {
    	      e--;
    	      c *= 2;
    	    }
    	    if (e + eBias >= 1) {
    	      value += rt / c;
    	    } else {
    	      value += rt * Math.pow(2, 1 - eBias);
    	    }
    	    if (value * c >= 2) {
    	      e++;
    	      c /= 2;
    	    }

    	    if (e + eBias >= eMax) {
    	      m = 0;
    	      e = eMax;
    	    } else if (e + eBias >= 1) {
    	      m = ((value * c) - 1) * Math.pow(2, mLen);
    	      e = e + eBias;
    	    } else {
    	      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
    	      e = 0;
    	    }
    	  }

    	  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}

    	  e = (e << mLen) | m;
    	  eLen += mLen;
    	  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}

    	  buffer[offset + i - d] |= s * 128;
    	};


    /***/ }),
    /* 61 */
    /***/ (function(module, exports) {

    	var toString = {}.toString;

    	module.exports = Array.isArray || function (arr) {
    	  return toString.call(arr) == '[object Array]';
    	};


    /***/ }),
    /* 62 */
    /***/ (function(module, exports, __webpack_require__) {
    	var __extends = (this && this.__extends) || function (d, b) {
    	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    	    function __() { this.constructor = d; }
    	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    	};
    	var dispatcher_1 = __webpack_require__(24);
    	var timers_1 = __webpack_require__(12);
    	var logger_1 = __webpack_require__(8);
    	var Collections = __webpack_require__(9);
    	var runtime_1 = __webpack_require__(2);
    	var ConnectionManager = (function (_super) {
    	    __extends(ConnectionManager, _super);
    	    function ConnectionManager(key, options) {
    	        var _this = this;
    	        _super.call(this);
    	        this.key = key;
    	        this.options = options || {};
    	        this.state = "initialized";
    	        this.connection = null;
    	        this.usingTLS = !!options.useTLS;
    	        this.timeline = this.options.timeline;
    	        this.errorCallbacks = this.buildErrorCallbacks();
    	        this.connectionCallbacks = this.buildConnectionCallbacks(this.errorCallbacks);
    	        this.handshakeCallbacks = this.buildHandshakeCallbacks(this.errorCallbacks);
    	        var Network = runtime_1["default"].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();
    	    }
    	    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 timers_1.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 timers_1.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 timers_1.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 timers_1.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 Collections.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", { type: "WebSocketError", error: error });
    	            },
    	            closed: function () {
    	                _this.abandonConnection();
    	                if (_this.shouldRetry()) {
    	                    _this.retryIn(1000);
    	                }
    	            }
    	        });
    	    };
    	    ConnectionManager.prototype.buildHandshakeCallbacks = function (errorCallbacks) {
    	        var _this = this;
    	        return Collections.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_1["default"].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_1["default"]));
    	exports.__esModule = true;
    	exports["default"] = ConnectionManager;


    /***/ }),
    /* 63 */
    /***/ (function(module, exports, __webpack_require__) {
    	var Collections = __webpack_require__(9);
    	var factory_1 = __webpack_require__(43);
    	var Errors = __webpack_require__(31);
    	var 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 Collections.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 () {
    	        Collections.objectApply(this.channels, function (channel) {
    	            channel.disconnect();
    	        });
    	    };
    	    return Channels;
    	}());
    	exports.__esModule = true;
    	exports["default"] = Channels;
    	function createChannel(name, pusher) {
    	    if (name.indexOf('private-encrypted-') === 0) {
    	        if (navigator.product == "ReactNative") {
    	            var errorMsg = "Encrypted channels are not yet supported when using React Native builds.";
    	            throw new Errors.UnsupportedFeature(errorMsg);
    	        }
    	        return factory_1["default"].createEncryptedChannel(name, pusher);
    	    }
    	    else if (name.indexOf('private-') === 0) {
    	        return factory_1["default"].createPrivateChannel(name, pusher);
    	    }
    	    else if (name.indexOf('presence-') === 0) {
    	        return factory_1["default"].createPresenceChannel(name, pusher);
    	    }
    	    else {
    	        return factory_1["default"].createChannel(name, pusher);
    	    }
    	}


    /***/ }),
    /* 64 */
    /***/ (function(module, exports, __webpack_require__) {
    	var factory_1 = __webpack_require__(43);
    	var util_1 = __webpack_require__(11);
    	var Errors = __webpack_require__(31);
    	var Collections = __webpack_require__(9);
    	var 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 Errors.UnsupportedStrategy(), callback);
    	        }
    	        else if (this.priority < minPriority) {
    	            return failAttempt(new Errors.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_1["default"].createHandshake(transport, function (result) {
    	                connected = true;
    	                unbindListeners();
    	                callback(null, result);
    	            });
    	        };
    	        var onError = function (error) {
    	            unbindListeners();
    	            callback(error);
    	        };
    	        var onClosed = function () {
    	            unbindListeners();
    	            var serializedTransport;
    	            serializedTransport = Collections.safeJSONStringify(transport);
    	            callback(new Errors.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;
    	}());
    	exports.__esModule = true;
    	exports["default"] = TransportStrategy;
    	function failAttempt(error, callback) {
    	    util_1["default"].defer(function () {
    	        callback(error);
    	    });
    	    return {
    	        abort: function () { },
    	        forceMinPriority: function () { }
    	    };
    	}


    /***/ }),
    /* 65 */
    /***/ (function(module, exports, __webpack_require__) {
    	var Collections = __webpack_require__(9);
    	var util_1 = __webpack_require__(11);
    	var timers_1 = __webpack_require__(12);
    	var 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 Collections.any(this.strategies, util_1["default"].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 timers_1.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;
    	}());
    	exports.__esModule = true;
    	exports["default"] = SequentialStrategy;


    /***/ }),
    /* 66 */
    /***/ (function(module, exports, __webpack_require__) {
    	var Collections = __webpack_require__(9);
    	var util_1 = __webpack_require__(11);
    	var BestConnectedEverStrategy = (function () {
    	    function BestConnectedEverStrategy(strategies) {
    	        this.strategies = strategies;
    	    }
    	    BestConnectedEverStrategy.prototype.isSupported = function () {
    	        return Collections.any(this.strategies, util_1["default"].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;
    	                }
    	                Collections.apply(runners, function (runner) {
    	                    runner.forceMinPriority(handshake.transport.priority);
    	                });
    	                callback(null, handshake);
    	            };
    	        });
    	    };
    	    return BestConnectedEverStrategy;
    	}());
    	exports.__esModule = true;
    	exports["default"] = BestConnectedEverStrategy;
    	function connect(strategies, minPriority, callbackBuilder) {
    	    var runners = Collections.map(strategies, function (strategy, i, _, rs) {
    	        return strategy.connect(minPriority, callbackBuilder(i, rs));
    	    });
    	    return {
    	        abort: function () {
    	            Collections.apply(runners, abortRunner);
    	        },
    	        forceMinPriority: function (p) {
    	            Collections.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;
    	    }
    	}


    /***/ }),
    /* 67 */
    /***/ (function(module, exports, __webpack_require__) {
    	var util_1 = __webpack_require__(11);
    	var runtime_1 = __webpack_require__(2);
    	var sequential_strategy_1 = __webpack_require__(65);
    	var Collections = __webpack_require__(9);
    	var 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_1["default"].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_1["default"]([transport], {
    	                    timeout: info.latency * 2 + 1000,
    	                    failFast: true
    	                }));
    	            }
    	        }
    	        var startTimestamp = util_1["default"].now();
    	        var runner = strategies.pop().connect(minPriority, function cb(error, handshake) {
    	            if (error) {
    	                flushTransportCache(usingTLS);
    	                if (strategies.length > 0) {
    	                    startTimestamp = util_1["default"].now();
    	                    runner = strategies.pop().connect(minPriority, cb);
    	                }
    	                else {
    	                    callback(error);
    	                }
    	            }
    	            else {
    	                storeTransportCache(usingTLS, handshake.transport.name, util_1["default"].now() - startTimestamp);
    	                callback(null, handshake);
    	            }
    	        });
    	        return {
    	            abort: function () {
    	                runner.abort();
    	            },
    	            forceMinPriority: function (p) {
    	                minPriority = p;
    	                if (runner) {
    	                    runner.forceMinPriority(p);
    	                }
    	            }
    	        };
    	    };
    	    return CachedStrategy;
    	}());
    	exports.__esModule = true;
    	exports["default"] = CachedStrategy;
    	function getTransportCacheKey(usingTLS) {
    	    return "pusherTransport" + (usingTLS ? "TLS" : "NonTLS");
    	}
    	function fetchTransportCache(usingTLS) {
    	    var storage = runtime_1["default"].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_1["default"].getLocalStorage();
    	    if (storage) {
    	        try {
    	            storage[getTransportCacheKey(usingTLS)] = Collections.safeJSONStringify({
    	                timestamp: util_1["default"].now(),
    	                transport: transport,
    	                latency: latency
    	            });
    	        }
    	        catch (e) {
    	        }
    	    }
    	}
    	function flushTransportCache(usingTLS) {
    	    var storage = runtime_1["default"].getLocalStorage();
    	    if (storage) {
    	        try {
    	            delete storage[getTransportCacheKey(usingTLS)];
    	        }
    	        catch (e) {
    	        }
    	    }
    	}


    /***/ }),
    /* 68 */
    /***/ (function(module, exports, __webpack_require__) {
    	var timers_1 = __webpack_require__(12);
    	var 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 timers_1.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;
    	}());
    	exports.__esModule = true;
    	exports["default"] = DelayedStrategy;


    /***/ }),
    /* 69 */
    /***/ (function(module, exports) {
    	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;
    	}());
    	exports.__esModule = true;
    	exports["default"] = IfStrategy;


    /***/ }),
    /* 70 */
    /***/ (function(module, exports) {
    	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;
    	}());
    	exports.__esModule = true;
    	exports["default"] = FirstConnectedStrategy;


    /***/ }),
    /* 71 */
    /***/ (function(module, exports, __webpack_require__) {
    	var defaults_1 = __webpack_require__(5);
    	exports.getGlobalConfig = function () {
    	    return {
    	        wsHost: defaults_1["default"].host,
    	        wsPort: defaults_1["default"].ws_port,
    	        wssPort: defaults_1["default"].wss_port,
    	        wsPath: defaults_1["default"].ws_path,
    	        httpHost: defaults_1["default"].sockjs_host,
    	        httpPort: defaults_1["default"].sockjs_http_port,
    	        httpsPort: defaults_1["default"].sockjs_https_port,
    	        httpPath: defaults_1["default"].sockjs_path,
    	        statsHost: defaults_1["default"].stats_host,
    	        authEndpoint: defaults_1["default"].channel_auth_endpoint,
    	        authTransport: defaults_1["default"].channel_auth_transport,
    	        activity_timeout: defaults_1["default"].activity_timeout,
    	        pong_timeout: defaults_1["default"].pong_timeout,
    	        unavailable_timeout: defaults_1["default"].unavailable_timeout
    	    };
    	};
    	exports.getClusterConfig = function (clusterName) {
    	    return {
    	        wsHost: "ws-" + clusterName + ".pusher.com",
    	        httpHost: "sockjs-" + clusterName + ".pusher.com"
    	    };
    	};


    /***/ })
    /******/ ])
    });
    });

    var Pusher = unwrapExports(pusher);

    /**
     * Global environment objects. This ensures that comparisons are true between
     * object pointers. For example: ENVIRONMENTS.TESTING === Util.Environments.Testing
     *
     * @since 1.0.3
     */
    /** @ignore */ var ProductionEnvironment = {
        environment: 'production'
    };
    /** @ignore */ var AdministrationEnvironment = {
        environment: 'production'
    };
    /** @ignore */ var SandboxDevEnvironment = {
        environment: 'sandbox'
    };
    /** @ignore */ var SandboxAdministrationEnvironment = {
        environment: 'sandbox'
    };
    /** @ignore */ var SandboxTwitchEnvironment = {
        environment: 'sandbox'
    };
    /** @ignore */ var ServerEnvironment = { environment: 'server' };
    /** @ignore */ var TestingEnvironment = {
        environment: 'testing'
    };
    /** @ignore */ var StagingDevEnvironment = {
        environment: 'staging'
    };
    /** @ignore */ var StagingAdministrationEnvironment = {
        environment: 'staging'
    };
    /** @ignore */ var StagingTwitchEnvironment = {
        environment: 'staging'
    };
    /**
     * Possible runtime environments for the SDK.
     * @since 1.0.0
     * @deprecated Use {@link Util.Environments} instead.
     */
    /** @ignore */ var ENVIRONMENTS = {
        ADMIN: AdministrationEnvironment,
        PRODUCTION: ProductionEnvironment,
        SANDBOX_ADMIN: SandboxAdministrationEnvironment,
        SANDBOX_DEV: SandboxDevEnvironment,
        SANDBOX_TWITCH: SandboxTwitchEnvironment,
        SERVER: ServerEnvironment,
        TESTING: TestingEnvironment,
        STAGING_ADMIN: StagingAdministrationEnvironment,
        STAGING_DEV: StagingDevEnvironment,
        STAGING_TWITCH: StagingTwitchEnvironment
    };
    /**
     * A collection of static utility functions, available at {@link Muxy.Util}.
     *
     * @example
     * const a = 'a string';
     * Muxy.Util.forceType(a, 'string');
     */
    var Util = /** @class */ (function () {
        function Util() {
        }
        Object.defineProperty(Util, "Environments", {
            /**
             * Possible runtime environments for the library. Used to define available
             * behavior and services.
             *
             * @since 1.0.3
             * @type {Object}
             */
            get: function () {
                return {
                    Admin: AdministrationEnvironment,
                    Production: ProductionEnvironment,
                    SandboxAdmin: SandboxAdministrationEnvironment,
                    SandboxDev: SandboxDevEnvironment,
                    SandboxTwitch: SandboxTwitchEnvironment,
                    Server: ServerEnvironment,
                    Testing: TestingEnvironment,
                    StagingDev: StagingDevEnvironment,
                    StagingTwitch: StagingTwitchEnvironment,
                    StagingAdmin: StagingAdministrationEnvironment
                };
            },
            enumerable: true,
            configurable: true
        });
        /**
         * Wraps a string error response in an (immediately rejected) promise.
         * @since 1.0.0
         *
         * @param {string} err - A string error that the promise will reject.
         *
         * @returns {Promise<string>} Immediately rejects the returned Promise.
         */
        Util.errorPromise = function (err) {
            return Promise.reject(err);
        };
        /**
         * Returns the length of the longest line in the provided array.
         *
         * @since 1.0.0
         * @ignore
         *
         * @param {string[]} lines - An array of strings.
         */
        Util.widestLine = function (lines) {
            return Math.max.apply(null, lines.map(function (x) { return x.length; }));
        };
        /**
         * Draws a box around the lines of text provided.
         *
         * @since 1.0.0
         * @ignore
         *
         * @param {string[]} lines - An array of strings to surround.
         *
         * @returns {string} A string containing all `lines` of text surrounded
         * in an ASCII box art.
         */
        Util.asciiBox = function (lines) {
            var contentWidth = Util.widestLine(lines);
            var intro = ' '.repeat(contentWidth / 2) + "\uD83E\uDD8A";
            var out = [intro];
            out.push("\u250C" + '─'.repeat(contentWidth + 2) + "\u2510");
            lines.forEach(function (line) {
                var paddingRight = ' '.repeat(contentWidth - line.length);
                out.push("| " + line + paddingRight + " |");
            });
            out.push("\u2514" + '─'.repeat(contentWidth + 2) + "\u2518");
            return out;
        };
        /**
         * Checks if the current window object is running in an iframe.
         *
         * @since 1.0.0
         * @ignore
         */
        Util.isWindowFramed = function (overrideWindow) {
            var vWindow;
            if (typeof window !== 'undefined') {
                vWindow = window;
            }
            if (overrideWindow) {
                vWindow = overrideWindow;
            }
            var isNotChildWindow = !vWindow.opener;
            // Cannot compare WindowProxy objects with ===/!==
            var windowTop = vWindow.top && vWindow != vWindow.top; // tslint:disable-line:triple-equals
            var windowParent = vWindow.parent && vWindow != vWindow.parent; // tslint:disable-line:triple-equals
            var hasWindowAncestors = !!(windowTop || windowParent);
            return isNotChildWindow && hasWindowAncestors;
        };
        /**
         * currentEnvironment uses the hostname and available info to determine in what
         * environment the SDK is running. Possible values are available in {@link Util.Environments}.
         * @since 1.0.0
         *
         * @returns {string} Returns a string representation of the current
         * execution environment.
         */
        Util.currentEnvironment = function (overrideWindow) {
            var vWindow;
            if (typeof window !== 'undefined') {
                vWindow = window;
            }
            if (overrideWindow) {
                vWindow = overrideWindow;
            }
            if (Util.overrideEnvironment) {
                return Util.overrideEnvironment;
            }
            try {
                // NodeJS module system, assume server.
                // istanbul ignore if
                if (typeof module !== 'undefined' && module.exports && typeof vWindow === 'undefined') {
                    return ENVIRONMENTS.SERVER;
                }
                // Not in an iframe, assume sandbox dev.
                if (!Util.isWindowFramed(vWindow)) {
                    // See if we're in the admin state.
                    var urlParams = new URLSearchParams(window.location.search);
                    if (urlParams.get('muxyAdminInterface') || vWindow.name === 'SandboxAdmin') {
                        return ENVIRONMENTS.SANDBOX_ADMIN;
                    }
                    return ENVIRONMENTS.SANDBOX_DEV;
                }
                // See if we're in the admin pane.
                if (vWindow.name === 'Admin') {
                    return ENVIRONMENTS.ADMIN;
                }
                // See if we're in the admin state, but in an iframed context.
                var iFrameUrlParams = new URLSearchParams(window.location.search);
                if (iFrameUrlParams.get('muxyAdminInterface') || vWindow.name === 'SandboxAdmin') {
                    return ENVIRONMENTS.SANDBOX_ADMIN;
                }
                // Loaded from Twitch's CDN, assume production.
                if (vWindow.location.origin.indexOf('.ext-twitch.tv') !== -1) {
                    return ENVIRONMENTS.PRODUCTION;
                }
                // Not on Twitch but with their referrer, assume sandbox twitch.
                if (vWindow.document.referrer && vWindow.document.referrer.indexOf('twitch.tv') !== -1) {
                    return ENVIRONMENTS.SANDBOX_TWITCH;
                }
                // Explicity set testing variable, assume testing.
                if (vWindow.testing) {
                    return ENVIRONMENTS.TESTING;
                }
            }
            catch (err) {
                Util.consolePrint(err.toString(), { type: 'error' });
            }
            // Default, assume we're running in sandbox dev environment.
            return ENVIRONMENTS.SANDBOX_DEV;
        };
        /**
         * consolePrint prints each line of text with optional global settings and per-line
         * console flags.
         *
         * **NOTE:** Twitch's CSP enforcement disallows printing to console. This function
         * will not print anything to the console if it is running in production mode.
         *
         * @since 1.0.0
         * @public
         *
         * @param {string|string[]} lines - A single string to output, or an array of lines
         * of text. If lines is an array, each line will appear on its own line. If lines is
         * a single string, it will be split on '\n'.
         *
         * @param {object?} options - An object containing global options.
         * @param {boolean} options.boxed - If true, surrounds the output in an ASCII art box.
         * @param {string} options.style - A CSS style string to append to the console call.
         * @param {string} options.type - The type of print command. May be one of:
         * ['log', 'error', 'debug', 'info', 'warn'], although browser support may not be
         * available for all. Defaults to 'log'.
         *
         * @example
         * consolePrint('Hello World');
         *  Hello World
         *
         * consolePrint('This is a box', { boxed: true });
         *  ┌───────────────┐
         *  | This is a box |
         *  └───────────────┘
         */
        Util.consolePrint = function (lines, options) {
            if (options === void 0) { options = {}; }
            if (!lines || Util.currentEnvironment() === Util.Environments.Production) {
                return;
            }
            var style = 'font-family: monospace;';
            var lineArr = Array.isArray(lines) ? lines : lines.split('\n');
            var type = options.type || 'log';
            if (options.boxed) {
                lineArr = Util.asciiBox(lineArr);
            }
            if (options.style) {
                style += options.style;
            }
            if (Util.currentEnvironment() === Util.Environments.Server) {
                console[type].call(this, lineArr.join('\n')); // eslint-disable-line no-console
            }
            else {
                console[type].call(this, "%c" + lineArr.join('\n'), style); // eslint-disable-line no-console
            }
        };
        /**
         * Matches an input event name with a pattern. An event name is a : delimited
         * list of terms, while a pattern is a : delimited list of terms, with an
         * optional * instead of a term. '*' will match any term.
         *
         * @since 1.0.0
         * @private
         *
         * @param {string} input - An input event name, : delimited.
         * Allowed characters are alpha-numeric and _
         * @param {string} pattern - A pattern to match against, : delimited.
         * Allowed characters are alpha-numeric and _ and *
         *
         * @return Returns true if the pattern matches the input, false otherwise.
         */
        Util.eventPatternMatch = function (input, pattern) {
            var inputParts = input.split(':');
            var patternParts = pattern.split(':');
            if (inputParts.length !== patternParts.length) {
                return false;
            }
            for (var i = 0; i < inputParts.length; i += 1) {
                if (inputParts[i] !== patternParts[i] && patternParts[i] !== '*') {
                    return false;
                }
            }
            return true;
        };
        /**
         * Takes a variable and a Javascript Type identifier and throws a TypeError
         * if the variable's type is not in the provided type list. If the type check
         * passes, the function returns without error. As a convenience, the type may
         * also be an array of types.
         *
         * Acceptable types:
         * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof
         *
         * @since 1.0.0
         * @public
         *
         * @param {any} value - Any JavaScript variable.
         * @param {string} type - A single type string, or an array of multiple types.
         *
         * @throws {TypeError} Throws if typeof value is not in the type list.
         */
        Util.forceType = function (value, type) {
            var types = [].concat(type);
            var typeString = typeof value;
            if (types.indexOf(typeString) === -1) {
                throw new TypeError("expected '" + typeString + "' to be one of [" + types + "]");
            }
        };
        /**
         * Returns information about the current extension environment on twitch
         *
         * @public
         *
         * @return {TwitchEnvironment}
         */
        Util.getTwitchEnvironment = function () {
            var url = new URL(window.location.search);
            var env = {
                anchor: null,
                language: null,
                mode: null,
                platform: null,
                state: null,
                version: null
            };
            var path = url.pathname;
            var splitPath = path.split('/');
            if (splitPath.length > 2) {
                env.version = splitPath[2];
            }
            var urlParams = url.searchParams;
            env.anchor = urlParams.get('anchor');
            env.language = urlParams.get('language');
            env.mode = urlParams.get('mode');
            env.platform = urlParams.get('platform');
            env.state = urlParams.get('state');
            return env;
        };
        /**
         * Attempts to parse the provided JWT and return the payload info
         *
         * @param {Object} jwt - The auth JWT token as returned from the auth harness.
         */
        Util.extractJWTInfo = function (jwt) {
            try {
                var splitToken = jwt.split('.');
                if (splitToken.length === 3) {
                    return JSON.parse(window.atob(splitToken[1]));
                }
            }
            catch (err) {
                throw new Error('Failed to parse JWT');
            }
        };
        return Util;
    }());
    /** @ignore */ var consolePrint = Util.consolePrint;
    /** @ignore */ var forceType = Util.forceType;
    /** @ignore */ var eventPatternMatch = Util.eventPatternMatch;
    /** @ignore */ var CurrentEnvironment = Util.currentEnvironment;

    /**
     * @module SDK
     */
    // TwitchMessenger implements the basic 'messenger' interface, which should be implemented
    // for all pubsub implementations. This is used by SDK to provide low-level access
    // to a pubsub implementation.
    var TwitchMessenger = /** @class */ (function () {
        function TwitchMessenger(debug) {
            this.channelID = '';
            this.extensionID = '';
            this.debug = debug;
        }
        /**
         * send will send a message to all clients.
         * @param id the extension id or app id of the app thats sending the message.
         * @param event an event name. Event names should be in the form [a-z0-9_]+
         * @param either 'broadcast' or 'whisper-<opaque-user-id>'
         * @param body a json object to send
         * @param client a state-client instance. Used to make external calls.
         * The twitch messenger does not need the client, so its not shown in the signature
         * below.
         */
        /* eslint-disable class-methods-use-this */
        TwitchMessenger.prototype.send = function (id, event, target, body) {
            var data = body || {};
            this.debug.onPubsubSend(id, event, target, body);
            window.Twitch.ext.send(target, 'application/json', {
                data: data,
                event: CurrentEnvironment().environment + ":" + id + ":" + event
            });
        };
        /* eslint-enable class-methods-use-this */
        /**
         * listen is the low level listening interface.
         * @param id the extension id or app id of the app thats sending the message.
         * @param topic either `broadcast` or `whisper-<opaque-user-id>`.
         * @param callback a function(body)
         * @return a handle that can be passed into unlisten to unbind the callback.
         */
        /* eslint-disable class-methods-use-this */
        TwitchMessenger.prototype.listen = function (id, topic, callback) {
            var _this = this;
            var cb = function (t, datatype, message) {
                try {
                    var parsed = JSON.parse(message);
                    _this.debug.onPubsubReceive(id, topic, parsed);
                    callback(parsed);
                }
                catch (err) {
                    // TODO: Silent failure?
                }
            };
            this.debug.onPubsubListen(id, topic);
            window.Twitch.ext.listen(topic, cb);
            if (topic === 'broadcast') {
                window.Twitch.ext.listen('global', cb);
            }
            return {
                cb: cb,
                target: topic
            };
        };
        /* eslint-enable class-methods-use-this */
        /**
         * unlisten will unregister a listening callback.
         * @param id the extension id or app id of the app thats sending the message.
         * @param h the handle returned from listen
         */
        /* eslint-disable class-methods-use-this */
        TwitchMessenger.prototype.unlisten = function (id, h) {
            window.Twitch.ext.unlisten(h.target, h.cb);
        };
        /* eslint-enable class-methods-use-this */
        TwitchMessenger.prototype.close = function () {
            /* Nothing to close on Twitch */
        };
        return TwitchMessenger;
    }());
    // PusherMessenger adheres to the 'messenger' interface, but uses https://pusher.com
    // as a pubsub notification provider.
    var PusherMessenger = /** @class */ (function () {
        function PusherMessenger(debug) {
            // @ts-ignore
            this.client = new Pusher('18c26c0d1c7fafb78ba2', {
                cluster: 'us2',
                encrypted: true
            });
            this.channelID = '';
            this.debug = debug;
        }
        PusherMessenger.prototype.send = function (id, event, target, body, client) {
            var scopedEvent = CurrentEnvironment().environment + ":" + id + ":" + event;
            this.debug.onPubsubSend(id, event, target, body);
            client.signedRequest(id, 'POST', 'pusher_broadcast', JSON.stringify({
                data: body,
                event: scopedEvent,
                target: target,
                user_id: this.channelID
            }));
        };
        PusherMessenger.prototype.listen = function (id, topic, callback) {
            var _this = this;
            if (!this.channel) {
                var channelName = "twitch.pubsub." + this.extensionID + "." + this.channelID;
                var globalName = "twitch.pubsub." + this.extensionID + ".all";
                this.channel = this.client.subscribe(channelName);
                this.globalChannel = this.client.subscribe(globalName);
            }
            var cb = function (message) {
                try {
                    var parsed = JSON.parse(message.message);
                    _this.debug.onPubsubReceive(id, topic, parsed);
                    callback(parsed);
                }
                catch (err) {
                    // TODO: Silent failure?
                }
            };
            this.debug.onPubsubListen(id, topic);
            this.channel.bind(topic, cb);
            this.globalChannel.bind(topic, cb);
            return {
                cb: cb,
                target: topic
            };
        };
        PusherMessenger.prototype.unlisten = function (id, h) {
            this.channel.unbind(h.target, h.cb);
            this.globalChannel.unbind(h.target, h.cb);
        };
        PusherMessenger.prototype.close = function () {
            this.client.disconnect();
        };
        return PusherMessenger;
    }());
    // ServerMessenger implements a 'messenger' that is broadcast-only. It cannot
    // listen for messages, but is able to send with a backend-signed JWT.
    var ServerMessenger = /** @class */ (function () {
        function ServerMessenger(debug, ch) {
            this.channelID = ch;
            this.debug = debug;
        }
        ServerMessenger.prototype.send = function (id, event, target, body, client) {
            this.debug.onPubsubSend(id, event, target, body);
            client.signedRequest(id, 'POST', 'broadcast', JSON.stringify({
                data: body,
                event: event,
                target: target,
                user_id: this.channelID
            }));
        };
        /* tslint:disable:no-console */
        ServerMessenger.prototype.listen = function (id, topic, callback) {
            console.error('Server-side message receiving is not implemented.');
            return {
                cb: function () {
                    /* Not Implemented */
                },
                target: ''
            };
        };
        ServerMessenger.prototype.unlisten = function (id, handle) {
            console.error('Server-side message receiving is not implemented.');
        };
        /* tslint:enable:no-console */
        ServerMessenger.prototype.close = function () {
            /* Nothing to close server-side. */
        };
        return ServerMessenger;
    }());
    function DefaultMessenger(debug) {
        switch (CurrentEnvironment()) {
            case ENVIRONMENTS.SANDBOX_DEV:
            case ENVIRONMENTS.ADMIN: // Currently unable to hook into the twitch pubsub system from admin
            case ENVIRONMENTS.SANDBOX_ADMIN:
            case ENVIRONMENTS.STAGING_ADMIN:
            case ENVIRONMENTS.STAGING_DEV:
                return new PusherMessenger(debug);
            case ENVIRONMENTS.SANDBOX_TWITCH:
            case ENVIRONMENTS.PRODUCTION:
            case ENVIRONMENTS.STAGING_TWITCH:
                return new TwitchMessenger(debug);
            case ENVIRONMENTS.SERVER:
                return new ServerMessenger(debug);
            default:
                throw new Error('Could not determine execution environment.');
        }
    }

    /**
     * @module SDK
     */
    var Observer = /** @class */ (function () {
        function Observer() {
            this.observers = [];
        }
        Observer.prototype.register = function (observer) {
            this.observers.push(observer);
        };
        Observer.prototype.unregister = function (observer) {
            var n = this.observers.indexOf(observer);
            this.observers.splice(n, 1);
        };
        Observer.prototype.notify = function (obj) {
            var i = 0;
            var max = this.observers.length;
            for (; i < max; i += 1) {
                this.observers[i].notify(obj);
            }
        };
        return Observer;
    }());
    var ObserverHandler = /** @class */ (function () {
        function ObserverHandler() {
        }
        ObserverHandler.prototype.notify = function (obj) {
            throw new Error('Abstract Method!');
        };
        return ObserverHandler;
    }());

    /**
     * @module SDK
     */
    // Twitch types
    var TwitchAuth = /** @class */ (function () {
        function TwitchAuth() {
        }
        return TwitchAuth;
    }());
    var ContextUpdateCallbackHandle = /** @class */ (function (_super) {
        __extends(ContextUpdateCallbackHandle, _super);
        function ContextUpdateCallbackHandle(cb) {
            var _this = _super.call(this) || this;
            _this.cb = cb;
            return _this;
        }
        ContextUpdateCallbackHandle.prototype.notify = function (context) {
            this.cb(context);
        };
        return ContextUpdateCallbackHandle;
    }(ObserverHandler));

    var DEFAULT_CONTENT_TYPE = 'application/x-www-form-urlencoded; charset=UTF-8';
    var XHRPromise = /** @class */ (function () {
        function XHRPromise(options) {
            if (options === void 0) { options = {}; }
            this.options = {
                data: null,
                headers: {},
                method: 'GET'
            };
            Object.assign(this.options, options);
        }
        XHRPromise.prototype.send = function () {
            var _this = this;
            return new Promise(function (resolve, reject) {
                if (!XMLHttpRequest) {
                    _this.handleResponse('browser', reject, null, "browser doesn't support XMLHttpRequest");
                    return;
                }
                if (typeof _this.options.url !== 'string' ||
                    _this.options.url.length === 0) {
                    _this.handleResponse('url', reject, null, 'URL is a required parameter');
                    return;
                }
                _this.xhr = new XMLHttpRequest();
                _this.xhr.onload = function () {
                    var responseText;
                    try {
                        responseText = _this.getResponseText();
                    }
                    catch (err) {
                        _this.handleResponse('parse', reject, null, 'invalid JSON response');
                        return;
                    }
                    return resolve({
                        headers: _this.getAllResponseHeaders(),
                        responseText: responseText,
                        status: _this.xhr.status,
                        statusText: _this.xhr.statusText,
                        url: _this.getResponseURL(),
                        xhr: _this.xhr
                    });
                };
                _this.xhr.onerror = function () {
                    return _this.handleResponse('error', reject);
                };
                _this.xhr.ontimeout = function () {
                    return _this.handleResponse('timeout', reject);
                };
                _this.xhr.onabort = function () {
                    return _this.handleResponse('abort', reject);
                };
                _this.xhr.open(_this.options.method, _this.options.url);
                if (_this.options.data !== null && !_this.options.headers['Content-Type']) {
                    _this.options.headers['Content-Type'] = DEFAULT_CONTENT_TYPE;
                }
                var ref = _this.options.headers;
                for (var header in ref) {
                    if (ref.hasOwnProperty(header)) {
                        var value = ref[header];
                        _this.xhr.setRequestHeader(header, value);
                    }
                }
                try {
                    return _this.xhr.send(_this.options.data);
                }
                catch (err) {
                    return _this.handleResponse('send', reject, null, err.toString());
                }
            });
        };
        XHRPromise.prototype.getXHR = function () {
            return this.xhr;
        };
        // Converts response headers to map.
        XHRPromise.prototype.getAllResponseHeaders = function () {
            var map = {};
            if (this.xhr.readyState !== this.xhr.HEADERS_RECEIVED) {
                return map;
            }
            var headers = this.xhr.getAllResponseHeaders();
            var arr = headers.trim().split(/[\r\n]+/);
            arr.forEach(function (header) {
                var parts = header.split(': ');
                var h = parts.shift();
                var v = parts.join(': ');
                map[h] = v;
            });
            return map;
        };
        // Returns the XHR response, parsing as json if applicable.
        XHRPromise.prototype.getResponseText = function () {
            var type = (this.xhr.getResponseHeader('Content-Type') || '').split(';')[0];
            var text = typeof this.xhr.responseText === 'string' ? this.xhr.responseText : '';
            if (type === 'application/json' || type === 'text/javascript') {
                text = JSON.parse("" + text);
            }
            return text;
        };
        XHRPromise.prototype.getResponseURL = function () {
            if (this.xhr.responseURL !== null) {
                return this.xhr.responseURL;
            }
            if (/^X-Request-URL:/m.test(this.xhr.getAllResponseHeaders())) {
                return this.xhr.getResponseHeader('X-Request-URL');
            }
            return '';
        };
        XHRPromise.prototype.handleResponse = function (reason, response, status, statusText) {
            return response({
                reason: reason,
                status: status || this.xhr.status,
                statusText: statusText || this.xhr.statusText,
                xhr: this.xhr
            });
        };
        return XHRPromise;
    }());

    /**
     * @module SDK
     */
    /**
     * Muxy production API URL.
     * @ignore
     */
    var API_URL = 'https://api.muxy.io';
    /**
     * Muxy sandbox API URL.
     * @ignore
     */
    var SANDBOX_URL = 'https://sandbox.api.muxy.io';
    /**
     * Localhost for testing purposes.
     * @ignore
     */
    var LOCALHOST_URL = 'http://localhost:5000';
    /**
     * Muxy staging API URL.
     * @ignore
     */
    var STAGING_URL = 'https://staging.api.muxy.io';
    /**
     * API URL to use for backend requests. Uses production API be default, but
     * can be updated using {@link setEnvironment}.
     * @ignore
     */
    var SERVER_URL = API_URL;
    var FAKEAUTH_URL = SANDBOX_URL;
    /**
     * ServerState enum maps the subsets of state persisted to the server to
     * their respective endpoints.
     * @ignore
     */
    var ServerState = {
        ALL: 'all_state',
        AUTHENTICATION: 'authentication',
        CHANNEL: 'channel_state',
        EXTENSION: 'extension_state',
        EXTENSION_SECRET: 'extension_hidden_state',
        EXTENSION_VIEWER: 'extension_viewer_state',
        USER: 'user_info',
        VIEWER: 'viewer_state'
    };
    /**
     * Wraps all extension backend accessor and mutator endpoints in convenience functions.
     *
     * Should not normally be created directly, instead an instance is made available
     * and namespaced appropriately when using {@link Muxy.SDK}.
     *
     * @private
     *
     * @example
     * const sdk = new Muxy.SDK();
     * sdk.getAllState().then((state) => {
     *   console.log(state);
     * });
     */
    var StateClient = /** @class */ (function () {
        /** @ignore */
        function StateClient(loadedPromise, debug) {
            var _this = this;
            /**
             * getState requests a subset of state stored on the server and sets the
             * local cached version of the state to the response.
             * @ignore
             */
            this.getState = function (identifier, substate) {
                return _this.signedRequest(identifier, 'GET', substate || ServerState.ALL);
            };
            /**
             * postState sends data to the current EBS substate endpoint for persistence.
             * @ignore
             */
            this.postState = function (identifier, substate, data) {
                return _this.signedRequest(identifier, 'POST', substate || ServerState.ALL, data);
            };
            /** @ignore */
            this.getUserInfo = function (identifier) { return _this.getState(identifier, ServerState.USER); };
            /** @ignore */
            this.immediateGetUserInfo = function (identifier) { return _this.signedRequest(identifier, 'GET', ServerState.USER, undefined, true); };
            /** @ignore */
            this.getViewerState = function (identifier) { return _this.getState(identifier, ServerState.VIEWER); };
            /** @ignore */
            this.getExtensionViewerState = function (identifier) { return _this.getState(identifier, ServerState.EXTENSION_VIEWER); };
            /** @ignore */
            this.getExtensionSecretState = function (identifier) { return _this.getState(identifier, ServerState.EXTENSION_SECRET); };
            /** @ignore */
            this.getChannelState = function (identifier) { return _this.getState(identifier, ServerState.CHANNEL); };
            /** @ignore */
            this.getExtensionState = function (identifier) { return _this.getState(identifier, ServerState.EXTENSION); };
            /** @ignore */
            this.setViewerState = function (identifier, state) { return _this.postState(identifier, ServerState.VIEWER, JSON.stringify(state)); };
            /** @ignore */
            this.setExtensionViewerState = function (identifier, state) {
                return _this.postState(identifier, ServerState.EXTENSION_VIEWER, JSON.stringify(state));
            };
            /** @ignore */
            this.patchExtensionViewerState = function (identifier, multiState) {
                return _this.signedRequest(identifier, 'PATCH', 'extension_viewer_state', JSON.stringify(multiState));
            };
            /** @ignore */
            this.multiGetExtensionViewerState = function (identifier, users) {
                return _this.signedRequest(identifier, 'GET', "extension_viewer_state?user_ids=" + users.join(','));
            };
            /** @ignore */
            this.setExtensionSecretState = function (identifier, state) {
                return _this.postState(identifier, ServerState.EXTENSION_SECRET, JSON.stringify(state));
            };
            /** @ignore */
            this.setChannelState = function (identifier, state) {
                return _this.postState(identifier, ServerState.CHANNEL, JSON.stringify(state));
            };
            /** @ignore */
            this.setExtensionState = function (identifier, state) {
                return _this.postState(identifier, ServerState.EXTENSION, JSON.stringify(state));
            };
            /** @ignore */
            this.getAccumulation = function (identifier, id, start) {
                return _this.signedRequest(identifier, 'GET', "accumulate?id=" + (id || 'default') + "&start=" + start);
            };
            /** @ignore */
            this.accumulate = function (identifier, id, data) {
                return _this.signedRequest(identifier, 'POST', "accumulate?id=" + (id || 'default'), JSON.stringify(data));
            };
            /** @ignore */
            this.vote = function (identifier, id, data) {
                return _this.signedRequest(identifier, 'POST', "vote?id=" + (id || 'default'), JSON.stringify(data));
            };
            /** @ignore */
            this.getVotes = function (identifier, id) { return _this.signedRequest(identifier, 'GET', "vote?id=" + (id || 'default')); };
            /** @ignore */
            this.getFullVoteLogs = function (identifier, id) { return _this.signedRequest(identifier, 'GET', "vote_logs?id=" + (id || 'default')); };
            /** @ignore */
            this.rank = function (identifier, id, data) {
                return _this.signedRequest(identifier, 'POST', "rank?id=" + (id || 'default'), JSON.stringify(data));
            };
            /** @ignore */
            this.getRank = function (identifier, id) {
                if (id === void 0) { id = 'default'; }
                return _this.signedRequest(identifier, 'GET', "rank?id=" + id);
            };
            /** @ignore */
            this.deleteRank = function (identifier, id) { return _this.signedRequest(identifier, 'DELETE', "rank?id=" + (id || 'default')); };
            /** @ignore */
            this.getJSONStore = function (identifier, id) { return _this.signedRequest(identifier, 'GET', "json_store?id=" + (id || 'default')); };
            /** @ignore */
            this.validateCode = function (identifier, code) {
                return _this.signedRequest(identifier, 'POST', 'validate_pin', JSON.stringify({ pin: code }));
            };
            /** @ignore */
            this.pinTokenExists = function (identifier) { return _this.signedRequest(identifier, 'GET', 'pin_token_exists'); };
            /** @ignore */
            this.revokeAllPINCodes = function (identifier) { return _this.signedRequest(identifier, 'DELETE', 'pin'); };
            /** @ignore */
            this.getEligibleCodes = function (identifier) { return _this.signedRequest(identifier, 'GET', 'codes/eligible'); };
            /** @ignore */
            this.getRedeemedCodes = function (identifier) { return _this.signedRequest(identifier, 'GET', 'codes/redeemed'); };
            /** @ignore */
            this.redeemCode = function (identifier, prizeIndex) {
                return _this.signedRequest(identifier, 'POST', 'codes/redeem', JSON.stringify({ prize: prizeIndex }));
            };
            /** @ignore */
            this.getExtensionUsers = function (identifier, cursor) {
                return _this.signedRequest(identifier, 'GET', "user_ids?cursor=" + (cursor || 0));
            };
            /** @ignore */
            this.joinExtensionTriviaTeam = function (identifier) { return _this.signedRequest(identifier, 'POST', 'team_membership'); };
            /** @ignore */
            this.getExtensionTriviaJoinedTeam = function (identifier) { return _this.signedRequest(identifier, 'GET', 'team_membership'); };
            /** @ignore */
            this.addExtensionTriviaQuestion = function (identifier, triviaQuestion) {
                return _this.signedRequest(identifier, 'POST', 'curated_poll_edit', JSON.stringify(triviaQuestion));
            };
            /** @ignore */
            this.removeExtensionTriviaQuestion = function (identifier, triviaQuestionID) {
                return _this.signedRequest(identifier, 'DELETE', 'curated_poll_edit', JSON.stringify({ id: triviaQuestionID }));
            };
            /** @ignore */
            this.addExtensionTriviaOptionToQuestion = function (identifier, questionID, option) {
                return _this.signedRequest(identifier, 'POST', 'curated_poll_edit_option', JSON.stringify({ question: questionID, option: option }));
            };
            /** @ignore */
            this.removeExtensionTriviaOptionFromQuestion = function (identifier, questionID, optionID) {
                return _this.signedRequest(identifier, 'DELETE', 'curated_poll_edit_option', JSON.stringify({ question: questionID, option: optionID }));
            };
            /** @ignore */
            this.setExtensionTriviaQuestionState = function (identifier, questionID, state, winner) {
                return _this.signedRequest(identifier, 'POST', "curated_poll_state?id=" + questionID, JSON.stringify({ transition: state, winner: winner }));
            };
            /** @ignore */
            this.setExtensionTriviaQuestionVote = function (identifier, questionID, optionID) {
                return _this.signedRequest(identifier, 'POST', 'curated_poll', JSON.stringify({ question_id: questionID, vote: optionID }));
            };
            /** @ignore */
            this.getExtensionTriviaQuestions = function (identifier) { return _this.signedRequest(identifier, 'GET', 'curated_poll'); };
            /** @ignore */
            this.getExtensionTriviaQuestion = function (identifier, questionID) {
                return _this.signedRequest(identifier, 'GET', "curated_poll?id=" + questionID);
            };
            /** @ignore */
            this.getExtensionTriviaLeaderboard = function (identifer) { return _this.signedRequest(identifer, 'GET', 'curated_poll_leaderboard'); };
            /** @ignore */
            this.token = null;
            this.debug = debug;
            this.loaded = loadedPromise;
        }
        /** @ignore */
        StateClient.fetchTestAuth = function (extensionID, debug) {
            var _this = this;
            var data = JSON.stringify({
                app_id: extensionID,
                channel_id: debug.channelID,
                role: debug.role,
                user_id: debug.userID || '12345678'
            });
            var xhr = new XHRPromise({
                data: data,
                headers: {
                    'Content-Type': 'application/json'
                },
                method: 'POST',
                url: (debug.url || SANDBOX_URL) + "/v1/e/authtoken?role=" + debug.role // pass roll as a param for fixtures
            });
            return xhr.send().then(function (resp) {
                if (resp && resp.status < 400) {
                    _this.setEnvironment(null, debug);
                    // Update the API Server variable to point to test
                    var auth = Object.assign(new TwitchAuth(), resp.responseText, {
                        channelId: debug.channelID,
                        clientId: extensionID,
                        userId: debug.userID ? "U" + debug.userID : 'U12345678'
                    });
                    return Promise.resolve(auth);
                }
                else {
                    return Promise.reject(resp.statusText);
                }
            });
        };
        /** @ignore */
        StateClient.setEnvironment = function (env, debug) {
            if (env === ENVIRONMENTS.SANDBOX_DEV || env === ENVIRONMENTS.SANDBOX_TWITCH || env === ENVIRONMENTS.SANDBOX_ADMIN) {
                SERVER_URL = SANDBOX_URL;
            }
            if (env === ENVIRONMENTS.STAGING_DEV || env === ENVIRONMENTS.STAGING_TWITCH) {
                SERVER_URL = STAGING_URL;
                FAKEAUTH_URL = STAGING_URL;
            }
            if (env === ENVIRONMENTS.TESTING) {
                SERVER_URL = LOCALHOST_URL;
                FAKEAUTH_URL = LOCALHOST_URL;
            }
            if (debug && debug.url) {
                SERVER_URL = debug.url;
                FAKEAUTH_URL = debug.url;
            }
        };
        /** @ignore */
        StateClient.prototype.updateAuth = function (token) {
            this.token = token;
        };
        /**
         * signedRequest checks that we have a valid JWT and wraps a standard AJAX
         * request to the EBS with valid auth credentials.s
         * @ignore
         */
        StateClient.prototype.signedRequest = function (extensionID, method, endpoint, data, skipPromise) {
            var _this = this;
            var waitedPromise = this.loaded;
            if (skipPromise) {
                waitedPromise = Promise.resolve();
            }
            return waitedPromise.then(function () {
                if (!_this.validateJWT()) {
                    return Promise.reject('Your authentication token has expired.');
                }
                var xhrPromise = new XHRPromise({
                    data: data,
                    headers: {
                        Authorization: extensionID + " " + _this.token
                    },
                    method: method,
                    url: SERVER_URL + "/v1/e/" + endpoint
                });
                return xhrPromise.send().then(function (resp) {
                    try {
                        if (resp.status < 400) {
                            return Promise.resolve(resp.responseText);
                        }
                        else if (resp.responseText) {
                            return Promise.reject(resp.responseText);
                        }
                        else {
                            return Promise.reject("Server returned status " + resp.status);
                        }
                    }
                    catch (err) {
                        return Promise.reject(err);
                    }
                });
            });
        };
        /**
         * validateJWT ensures that the current JWT is valid and not expired.
         * @ignore
         */
        StateClient.prototype.validateJWT = function () {
            try {
                var splitToken = this.token.split('.');
                if (splitToken.length !== 3) {
                    return false;
                }
                var tk = JSON.parse(atob(splitToken[1]));
                if (!tk.exp) {
                    return false;
                }
                var now = new Date().valueOf();
                if (tk.exp < now / 1000) {
                    return false;
                }
                return true;
            }
            catch (err) {
                return false;
            }
        };
        return StateClient;
    }());

    // 25 minutes between updates of the testing auth token.
    var TEST_AUTH_TIMEOUT_MS = 25 * 60 * 1000;
    // Only process context callbacks once every 30 seconds.
    var CONTEXT_CALLBACK_TIMEOUT = 30 * 1000;
    // Wrapper around global Twitch extension object.
    var Ext = /** @class */ (function () {
        function Ext() {
        }
        Ext.fetchTestAuth = function (opts, cb) {
            StateClient.fetchTestAuth(this.extensionID, opts)
                .then(function (auth) {
                cb(auth);
            })
                .catch(cb);
        };
        Ext.fetchAdminAuth = function (debug, cb) {
            var _this = this;
            var allowedOrigins = ['^https://dev\\.staging.muxy\\.io$', '^https://dev\\.muxy\\.io$', '^https?://localhost'];
            // Show that we're ready to receive.
            var connectionAttempts = 0;
            var connection = setInterval(function () {
                connectionAttempts++;
                // Once we've tried 60 times, back off on attempting to once every 1.5 seconds or so.
                if (connectionAttempts > 60) {
                    if (connectionAttempts % 10 !== 0) {
                        return;
                    }
                }
                window.parent.postMessage({ type: 'connect', id: _this.extensionID }, '*');
            }, 150);
            window.addEventListener('message', function (auth) {
                var allowed = false;
                allowedOrigins.forEach(function (origin) {
                    var r = new RegExp(origin);
                    if (r.test(auth.origin)) {
                        allowed = true;
                    }
                });
                if (!allowed) {
                    return;
                }
                if (auth.data.type === 'jwt') {
                    StateClient.setEnvironment(null, debug);
                    var resp = Object.assign(new TwitchAuth(), {
                        channelId: debug.channelID,
                        clientId: _this.extensionID,
                        token: auth.data.jwt,
                        userId: debug.userID || 'T12345678'
                    });
                    clearInterval(connection);
                    return cb(resp);
                }
            });
        };
        Ext.onAuthorized = function (opts, cb) {
            if (opts.jwt) {
                var auth_1 = this.authFromJWT(opts.jwt);
                return setTimeout(function () {
                    StateClient.setEnvironment(null, opts);
                    cb(auth_1);
                });
            }
            switch (CurrentEnvironment()) {
                case ENVIRONMENTS.SANDBOX_DEV:
                case ENVIRONMENTS.STAGING_DEV:
                    Ext.fetchTestAuth(opts, cb);
                    setInterval(Ext.fetchTestAuth, TEST_AUTH_TIMEOUT_MS, opts, cb);
                    break;
                case ENVIRONMENTS.SANDBOX_ADMIN:
                case ENVIRONMENTS.STAGING_ADMIN:
                case ENVIRONMENTS.ADMIN:
                    Ext.fetchAdminAuth(opts, cb);
                    break;
                case ENVIRONMENTS.SANDBOX_TWITCH:
                case ENVIRONMENTS.STAGING_TWITCH:
                case ENVIRONMENTS.PRODUCTION: {
                    var timer_1 = setTimeout(cb, 1000 * 15);
                    window.Twitch.ext.onAuthorized(function (auth) {
                        clearTimeout(timer_1);
                        StateClient.setEnvironment(null, opts);
                        cb(auth);
                    });
                    break;
                }
                default:
                    consolePrint("No authorization callback for " + CurrentEnvironment(), {
                        type: 'error'
                    });
            }
        };
        Ext.onContext = function (cb) {
            switch (CurrentEnvironment()) {
                case ENVIRONMENTS.SANDBOX_TWITCH:
                case ENVIRONMENTS.STAGING_TWITCH:
                case ENVIRONMENTS.PRODUCTION:
                    (function setupOnContextCallback() {
                        // Twitch currently (2017-08-25) has an issue where certain browser mis-configurations
                        // (like having incorrect system time/timezone settings) will cause the onContext callback
                        // function to fire repeatedly as quickly as possible. To deal with this issue, we
                        // throttle the onContext callbacks.
                        var lastContextCall = 0;
                        window.Twitch.ext.onContext(function (context) {
                            // Check the last time the auth callback was called and restrict.
                            var diff = new Date().getTime() - lastContextCall;
                            if (diff < CONTEXT_CALLBACK_TIMEOUT) {
                                return;
                            }
                            lastContextCall = new Date().getTime();
                            cb(context);
                        });
                    })();
                    break;
                default:
            }
        };
        Ext.beginPurchase = function (sku) {
            switch (CurrentEnvironment()) {
                case ENVIRONMENTS.SANDBOX_TWITCH:
                case ENVIRONMENTS.STAGING_TWITCH:
                case ENVIRONMENTS.PRODUCTION:
                    window.Twitch.ext.purchases.beginPurchase(sku);
                    break;
                default:
                    consolePrint("beginPurchase not supported for " + CurrentEnvironment(), {
                        type: 'error'
                    });
            }
        };
        Ext.getPrices = function (cb) {
            switch (CurrentEnvironment()) {
                case ENVIRONMENTS.SANDBOX_TWITCH:
                case ENVIRONMENTS.STAGING_TWITCH:
                case ENVIRONMENTS.PRODUCTION:
                    window.Twitch.ext.purchases
                        .getPrices()
                        .then(function (prices) {
                        cb(prices);
                    })
                        .catch(cb);
                    break;
                default:
                    consolePrint("getPrices not supported for " + CurrentEnvironment(), {
                        type: 'error'
                    });
            }
        };
        Ext.onReloadEntitlements = function (cb) {
            switch (CurrentEnvironment()) {
                case ENVIRONMENTS.SANDBOX_TWITCH:
                case ENVIRONMENTS.STAGING_TWITCH:
                case ENVIRONMENTS.PRODUCTION:
                    window.Twitch.ext.purchases.onReloadEntitlements(cb);
                    break;
                default:
                    consolePrint("onReloadEntitlements not supported for " + CurrentEnvironment(), {
                        type: 'error'
                    });
            }
        };
        Ext.onVisibilityChanged = function (callback) {
            switch (CurrentEnvironment()) {
                case ENVIRONMENTS.SANDBOX_TWITCH:
                case ENVIRONMENTS.STAGING_TWITCH:
                case ENVIRONMENTS.PRODUCTION:
                    window.Twitch.ext.onVisibilityChanged(callback);
                    break;
                default:
                    consolePrint("onVisibilityChanged not supported for " + CurrentEnvironment(), {
                        type: 'error'
                    });
            }
        };
        Ext.onPositionChanged = function (callback) {
            switch (CurrentEnvironment()) {
                case ENVIRONMENTS.SANDBOX_TWITCH:
                case ENVIRONMENTS.STAGING_TWITCH:
                case ENVIRONMENTS.PRODUCTION:
                    window.Twitch.ext.onPositionChanged(callback);
                    break;
                default:
                    consolePrint("onVisibilityChanged not supported for " + CurrentEnvironment(), {
                        type: 'error'
                    });
            }
        };
        Ext.authFromJWT = function (jwt) {
            var claims = JSON.parse(atob(jwt.split('.')[1]));
            var res = new TwitchAuth();
            res.token = jwt;
            res.channelId = claims.channel_id;
            res.userId = claims.user_id;
            res.clientId = Ext.extensionID;
            return res;
        };
        return Ext;
    }());

    var UserUpdateCallbackHandle = /** @class */ (function (_super) {
        __extends(UserUpdateCallbackHandle, _super);
        function UserUpdateCallbackHandle(cb) {
            var _this = _super.call(this) || this;
            _this.cb = cb;
            return _this;
        }
        UserUpdateCallbackHandle.prototype.notify = function (user) {
            this.cb(user);
        };
        return UserUpdateCallbackHandle;
    }(ObserverHandler));
    /**
     * Stores fields related to the current extension user, either a viewer or the broadcaster.
     * These fields are automatically updated by the SDK.
     */
    var User = /** @class */ (function () {
        /**
         * @since 1.0.0
         * @param {Object} auth - An auth token usable by this user for backend requests.
         */
        function User(auth) {
            /**
             * channelID holds the numeric id of the channel the user is currently watching.
             *
             * @since 1.0.0
             * @type {string}
             */
            this.channelID = auth.channelId;
            /**
             * twitchJWT holds the raw JWT response from the Twitch Extension SDK.
             *
             * @since 1.0.0
             * @type {Object}
             */
            this.twitchJWT = auth.token;
            /**
             * twitchOpaqueID is a Twitch generated ID that will uniquely identify this
             * user (if they are logged in), but does not give us access to their Twitch ID.
             *
             * @since 1.0.0
             * @type {string}
             */
            this.twitchOpaqueID = auth.userId;
            /**
             * twitchID is this viewer's actual Twitch ID. Used to coordinate access to
             * other Twitch services and across the Twitch universe. Only set if the user
             * grants access, null otherwise.
             *
             * @since 1.0.0
             * @type {null|string}
             */
            this.twitchID = null;
            /**
             * registeredWithMuxy will be true if the user has an active muxy account.
             *
             * @since 1.0.0
             * @type {boolean}
             */
            this.registeredWithMuxy = false;
            /**
             * muxyID is this viewer's ID on Muxy. Null if the user has not authenticated with
             * Muxy or is not sharing their Twitch ID with the extension.
             *
             * @since 1.0.0
             * @type {null|string}
             */
            this.muxyID = null;
            /**
             * visualizationID is a unique user string that can be used to identify this user
             * on Muxy's a.muxy.io subdomain. This is used for things like alerts and
             * cheer visualizations, but is not generally useful. Empty string if
             * `registeredWithMuxy` is false.
             *
             * @since 1.0.0
             * @type {string}
             */
            this.visualizationID = '';
            /**
             * role is the current user's role in the extension. May be one of {@link Roles}.
             *
             * @since 1.0.0
             * @type {string}
             */
            this.role = User.Roles.Viewer;
            /**
             * ip is the current user's IP address. May be an empty string if undetectable.
             *
             * @since 1.0.0
             * @type {string}
             */
            this.ip = '';
            /**
             * game is the title of the current channel's game as set by the broadcaster.
             *
             * @since 1.0.0
             * @type {string}
             */
            this.game = '';
            /**
             * User's current video mode. One of {@link VideoModes}.
             *
             * @since 1.0.0
             * @type {string}
             */
            this.videoMode = User.VideoModes.Default;
            /**
             * Current video bitrate. Null if no video or unknown.
             *
             * @since 1.0.0
             * @type {null|number}
             */
            this.bitrate = null;
            /**
             * Current video latency. Null if no video or unknown.
             *
             * @since 1.0.0
             * @type {null|number}
             */
            this.latency = null;
            /**
             * Current buffer size of the viewer's player. Null if no video or unknown.
             *
             * @since 1.0.0
             * @type {null|number}
             */
            this.buffer = null;
            /**
             * Current theme the user has selected on twitch. Null if unknown, otherwise "light" or "dark"
             * @type {null|string}
             */
            this.theme = null;
            /**
             * Current volume level of the Twitch video player. Values between 0 and 1.
             * @type {number}
             */
            this.volume = 0;
            // If the user has authorized an extension to see their Twitch ID, it will be
            // hidden in the JWT payload.
            this.extractJWTInfo(auth.token);
            /**
             * Offset of this user from the server time.
             * @private
             */
            this.timeOffset = 0;
        }
        Object.defineProperty(User, "Roles", {
            /**
             * Defines the current user's role on Twitch relative to the current channel being
             * viewed. May be "viewer" if the user is simply viewing the channel, "moderator"
             * if the user is a moderator of the channel or "broadcaster" if the user is also
             * the broadcaster of the channel.
             *
             * @since 1.0.3
             */
            get: function () {
                return {
                    Broadcaster: 'broadcaster',
                    Moderator: 'moderator',
                    Viewer: 'viewer'
                };
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(User, "VideoModes", {
            /**
             * Defines the video mode for the current user. This may be "default" for the default
             * windowed viewing experience on Twitch, "fullscreen" for the fullscreen, video-only
             * mode or "theatre" for the video full window-width.
             *
             * @since 1.0.3
             */
            get: function () {
                return {
                    Default: 'default',
                    Fullscreen: 'fullscreen',
                    Theatre: 'theatre'
                };
            },
            enumerable: true,
            configurable: true
        });
        /**
         * Attempts to parse the provided JWT and persist any found information in store.
         * @since 1.0.0
         *
         * @param {Object} jwt - The auth JWT token as returned from the auth harness.
         */
        User.prototype.extractJWTInfo = function (jwt) {
            try {
                var token = Util.extractJWTInfo(jwt);
                this.role = token.role;
                if (token.user_id) {
                    this.twitchID = token.user_id;
                }
            }
            catch (err) {
                // Silently fail (enforcement of Twitch ID is done externally).
            }
        };
        /**
         * Returns whether or not the current extension user is anonymous.
         * Twitch defines an anonymous user as one who is not logged in to the channel
         * page running this extension, or one who has not opted-in to sharing
         * auth information with this extension.
         * @since 1.0.0
         *
         * @return {boolean} True if the user is not logged in to Twitch or has not granted
         * access to their Twitch ID.
         */
        User.prototype.anonymous = function () {
            return !this.twitchOpaqueID || this.twitchOpaqueID[0] !== 'U';
        };
        /**
         * Stores values from a new auth token in the local store.
         * @since 1.0.0
         *
         * @param {Object} auth - An auth JWT with updated user information.
         */
        User.prototype.updateAuth = function (auth) {
            this.twitchJWT = auth.token;
            this.extractJWTInfo(auth.token);
        };
        /**
         * Returns a date object that is based on the Muxy server time.
         *
         * @return {Date}
         */
        User.prototype.getOffsetDate = function () {
            return new Date(new Date().getTime() + this.timeOffset);
        };
        return User;
    }());

    /**
     * @module SDK
     */
    var TriviaQuestionState;
    (function (TriviaQuestionState) {
        // Inactive marks a poll as inactive. Only admins can see an inactive poll.
        TriviaQuestionState["Inactive"] = "state-inactive";
        // Unlocked marks a poll as being visible to everyone, and open to votes.
        TriviaQuestionState["Unlocked"] = "state-unlocked";
        // Unlocked marks a poll as being visible to everyone, but closed to votes. No results
        // are visible while unlocked.
        TriviaQuestionState["Locked"] = "state-locked";
        // Results marks a poll as complete, and results are available.
        TriviaQuestionState["Results"] = "state-results";
    })(TriviaQuestionState || (TriviaQuestionState = {}));
    /**
     * The Muxy Extensions SDK, used to communicate with Muxy's Extension Backend Service.
     *
     * Instances of this class created through the global `Muxy` object can be used to easily
     * interact with Muxy's Extension Backend Service. It includes functionality to aggregate
     * and persist user data, set extension configuration, send analytics events and authenticate
     * broadcasters across servers and applications.
     *
     * To begin using the SDK, create a new instance by calling `const sdk = Muxy.SDK()`.
     *
     * **Note for Overlay App Developers:**
     * An instance of the Muxy SDK is automatically created for you that is namespaced to your
     * app id. You can access it in any app that imports AppMixin as `this.muxy.<method>`. The
     * methods described below behave similarly to how they would in an extension context, however
     * all data is exclusive to your app. Differences are noted in the comments to the individual
     * methods.
     */
    var SDK = /** @class */ (function () {
        /** @ignore */
        function SDK(id) {
            if (!mxy.setupCalled) {
                throw new Error('Muxy.setup() must be called before creating a new SDK instance');
            }
            var identifier = id || mxy.twitchClientID;
            if (!identifier) {
                return null;
            }
            if (!mxy.watchingAuth) {
                mxy.watchingAuth = true;
                mxy.watchAuth(identifier);
            }
            if (!mxy.SDKClients[identifier]) {
                this.setup(identifier, mxy.client, mxy.user, mxy.messenger, mxy.analytics, mxy.loadPromise, mxy.SKUs, mxy.debugOptions);
                mxy.SDKClients[identifier] = this;
            }
            return mxy.SDKClients[identifier];
        }
        /**
         * Returns a Promise that will resolve once this SDK instance is ready for use.
         * Will reject if an error occurs communicating with the backend server.
         * @since 1.0.0
         *
         * @return {Promise}
         *
         * @example
         * const sdk = new Muxy.SDK();
         * sdk.loaded().then(() => {
         *   sdk.send('Hello World');
         * }).catch((err) => {
         *   console.error(err);
         * });
         */
        SDK.prototype.loaded = function () {
            return this.loadPromise;
        };
        /**
         * Updates the internally stored user object with the provided value.
         * Also calls any stored user update callbacks with the new user object.
         * @since 1.5
         *
         * @example
         * const sdk = new Muxy.SDK();
         * sdk.loaded().then(() => {
         *   sdk.updateUser({<user object>});
         * });
         */
        SDK.prototype.updateUser = function (user) {
            this.user = user;
            this.userObservers.notify(user);
        };
        /**
         * Registers a new callback for when the current user's info is updated.
         */
        SDK.prototype.onUserUpdate = function (callback) {
            var handler = new UserUpdateCallbackHandle(callback);
            this.userObservers.register(handler);
            return handler;
        };
        /**
         * Registers a new callback for when the context is updated.
         */
        SDK.prototype.onContextUpdate = function (callback) {
            var handler = new ContextUpdateCallbackHandle(callback);
            this.contextObservers.register(handler);
            return handler;
        };
        /**
         * Returns a date object that is based on the Muxy server time.
         * This method only returns valid results after .loaded() resolves.
         *
         * @return {Date}
         */
        SDK.prototype.getOffsetDate = function () {
            return new Date(new Date().getTime() + this.timeOffset);
        };
        /**
         * Returns a promise to get the user object. This automatically
         * waits for .loaded() to resolve.
         */
        SDK.prototype.getUser = function () {
            var _this = this;
            return this.loaded().then(function () {
                return Promise.resolve(_this.user);
            });
        };
        /**
         * Invokes a request to the backend.
         */
        SDK.prototype.signedRequest = function (method, endpoint, data) {
            return this.client.signedRequest(this.identifier, method, endpoint, data);
        };
        /**
         * Data Accumulation
         */
        /**
         * Fetches the accumulated user data for a given id received by the backend since start.
         *
         * Broadcaster-only functionality.
         *
         * @async
         * @since 1.0.0
         *
         * @throws {TypeError} Will throw an error if accumulationID is not a string.
         *
         * @param {string} accumulationID - The identifier of the accumulated data to fetch.
         * @param {number} start - A Unix timestamp in milliseconds of the earliest accumulation
         * record to fetch.
         *
         * @return {Promise<AccumulateData>} Resolves with requested accumulation data on
         * server response.
         *
         * @example
         * const oneMinuteAgo = (new Date().getTime()) - (1000 * 60);
         * sdk.getAccumulation('awesomeness_level', oneMinuteAgo).then((resp) => {
         *   console.log(`${resp.data.length}: ${resp.latest}`);
         *   console.log(resp.data); // A list of all accumulate values since oneMinuteAgo.
         * });
         */
        SDK.prototype.getAccumulateData = function (accumulationID, start) {
            forceType(accumulationID, 'string');
            return this.client.getAccumulation(this.identifier, accumulationID, start);
        };
        /**
         * @deprecated Use getAccumulateData instead.
         */
        SDK.prototype.getAccumulation = function (accumulationID, start) {
            return this.getAccumulateData(accumulationID, start);
        };
        /**
         * Sends data to be accumulated by the server.
         * @since 1.0.0
         *
         * @param {string} accumulationID - The identifier that this datum is accumulated with.
         * @param {Object} data - Any JSON serializable JavaScript object.
         *
         * @return {Promise} Will resolve on successful server-send. Rejects on failure.
         *
         * @example
         * sdk.accumulate('awesomeness_level', {
         *   awesomeness_level: {
         *     great: 10,
         *     good: 2.5,
         *     poor: 'dank'
         *   }
         * });
         */
        SDK.prototype.accumulate = function (accumulationID, data) {
            forceType(accumulationID, 'string');
            return this.client.accumulate(this.identifier, accumulationID, data);
        };
        /**
         * User Voting
         */
        /**
         * Fetches the current stored vote data for a given vote identifier.
         * @async
         * @since 1.0.0
         *
         * @throws {TypeError} Will throw an error if voteID is not a string.
         *
         * @param {string} voteID - The identifer to fetch associated vote data.
         *
         * @return {Promise<VoteData>} Resolves with requested vote data on server response. Rejects on
         * server error.
         *
         * @example
         * sdk.getVoteData('poll-number-1').then((voteData) => {
         *   console.log(voteData.sum);
         * });
         */
        SDK.prototype.getVoteData = function (voteID) {
            forceType(voteID, 'string');
            return this.client.getVotes(this.identifier, voteID);
        };
        /**
         * Gets the vote logs for a given vote ID. This endpoint may only be called by
         * an admin.
         *
         * @async
         * @param voteID - the identifier to fetch the vote logs for.
         * @return {Promise<VoteLog>} Resolves with the logs on server response. Rejects on server error.
         *
         * @example
         * const sdk = new Muxy.SDK();
         * sdk.getFullVoteLogs('global-12345').then((logs) => {
         *   const audit = logs.result;
         *
         *   // ... process the audit logs ...
         *   const valueToUsersMapping = {};
         *   for (const i = 0; i < audit.length; ++i) {
         *     const value = audit[i].value;
         *     const identifier = audit[i].identifier;
         *
         *     const list = valueToUsersMapping[value] || [];
         *     list.append(identifier);
         *
         *     valueTousersMapping[value] = list;
         *   }
         * });
         */
        SDK.prototype.getFullVoteLogs = function (voteID) {
            forceType(voteID, 'string');
            return this.client.getFullVoteLogs(this.identifier, voteID);
        };
        /**
         * Submit a user vote associated with a vote identifier.
         * @async
         * @since 1.0.0
         *
         * @throws {TypeError} Will throw an error if `voteID` is not a string or if `value` is not
         * a Number.
         *
         * @param {string} voteID - The identifer to fetch associated vote data.
         * @param {number} value - Any numeric value to represent this user's vote. Note that only
         * values of 0-5 will be included in the `specific` field returned from `getVoteData`.
         *
         * @return {Promise} Will resolve on successful server-send. Rejects on failure.
         *
         * @example
         * sdk.vote('poll-number-1', 1);
         */
        SDK.prototype.vote = function (voteID, value) {
            forceType(voteID, 'string');
            forceType(value, 'number');
            return this.client.vote(this.identifier, voteID, { value: value });
        };
        /**
         * User Ranking
         */
        /**
         * Fetches the current ranked data associated with the rank identifier.
         * @async
         * @since 1.0.0
         *
         * @throws {TypeError} Will throw an error if rankID is not a string.
         *
         * @param {string} rankID - The identifier to fetch associated rank data.
         *
         * @return {Promise<RankData>} Resolves with requested rank data on server response. Rejects
         * on server error.
         *
         * @example
         * sdk.getRankData('favorite_color').then((colors) => {
         *   if (colors.length > 0) {
         *     colors.forEach((color) => {
         *       console.log(`${color.key}: ${color.score}`);
         *     });
         *   }
         * });
         */
        SDK.prototype.getRankData = function (rankID) {
            var _this = this;
            forceType(rankID, 'string');
            return new Promise(function (accept, reject) {
                _this.client
                    .getRank(_this.identifier, rankID)
                    .then(function (data) {
                    accept(data.data);
                })
                    .catch(reject);
            });
        };
        /**
         * Submit user rank data associated with a rank identifier.
         * @async
         * @since 1.0.0
         *
         * @throws {TypeError} Will throw an error if rankID or value are not strings.
         *
         * @param {string} rankID - The identifer to fetch associated rank data.
         * @param {string} value - Any string value to represent this user's rank data. Will be returned
         * as the `key` field when rank data is requested.
         *
         * @return {Promise<RankResponse>} Will resolve on success. Rejects on failure.
         *
         * @example
         * const usersFavoriteColor = 'rebeccapurple';
         * this.muxy.rank('favorite_color', usersFavoriteColor);
         */
        SDK.prototype.rank = function (rankID, value) {
            forceType(rankID, 'string');
            forceType(value, 'string');
            return this.client.rank(this.identifier, rankID, { key: value });
        };
        /**
         * Clear all rank data associated with the rank identifier.
         *
         * Broadcaster-only functionality.
         *
         * @async
         * @since 1.0.0
         *
         * @throws {TypeError} Will throw an error if rankID is not a string.
         *
         * @param {string} rankID - The identifer to fetch associated rank data.
         *
         * @return {Promise} Will resolve on success. Rejects on failure.
         */
        SDK.prototype.clearRankData = function (rankID) {
            forceType(rankID, 'string');
            return this.client.deleteRank(this.identifier, rankID);
        };
        /**
         * @deprecated Deprecated in 1.0.0. Use getRankData instead.
         */
        SDK.prototype.getRankingData = function (rankID) {
            return this.getRankData(rankID);
        };
        /**
         * @deprecated Deprecated in 1.0.0. Use clearRankData instead.
         */
        SDK.prototype.clearRanking = function (rankID) {
            return this.clearRanking(rankID);
        };
        /**
         * User State
         */
        /**
         * Sets the channel specific viewer-specific state to a JS object, this can be called by
         * any viewer.
         * Future calls to {@link getAllState} by **this** user will have a clone of this object in the
         * `viewer` field.
         * @async
         * @since 1.0.0
         *
         * @param {Object} state - A complete JS object representing the current viewer state.
         *
         * @return {Promise} Will resolve on successful server-send. Rejects on failure.
         *
         * @example
         * sdk.setViewerState({
         *   favorite_movie: 'Jaws: The Revenge'
         * }).then(() => {
         *   console.log('Viewer state saved!');
         * }).catch((err) => {
         *   console.error(`Failed saving viewer state: ${err}`);
         * });
         */
        SDK.prototype.setViewerState = function (state) {
            return this.client.setViewerState(this.identifier, state);
        };
        /**
         * Sets the extension wide viewer-specific state to a JS object, this is only a valid call for a
         * user that has shared their identity.
         * Future calls to {@link getAllState} by **this** user will have a clone of this object in the
         * `extension_viewer` field.
         * @async
         * @since 1.1.0
         *
         * @param {Object} state - A complete JS object representing the current viewer state.
         *
         * @return {Promise} Will resolve on successful server-send. Rejects on failure.
         *
         * @example
         * sdk.setExtensionViewerState({
         *   favorite_movie: 'Jaws: The Revenge'
         * }).then(() => {
         *   console.log('Viewer state saved!');
         * }).catch((err) => {
         *   console.error(`Failed saving viewer state: ${err}`);
         * });
         */
        SDK.prototype.setExtensionViewerState = function (state) {
            return this.client.setExtensionViewerState(this.identifier, state);
        };
        /**
         * Applies a set of patches to multiple extension-wide viewer-specific states.
         * This method requires a mapping of user_id to objects. The provided state
         * objects per user are merged server-side. A key may be specified to be 'null'
         * to delete the key on the server. Arrays are overwritten in their entirety on merge.
         * Objects are merged recursively.
         *
         * This method can only set state for viewers who have shared their ID.
         *
         * This method requires an admin context.
         * @async
         * @param userStates - a mapping of userID to patch objects.
         *
         * @return {Promise} Will resolve on successful setting of state. Rejects on failure.
         *
         * @example
         * sdk.patchExtensionViewerState({
         *  '12452': { 'hello': 'world' },
         *  '12422': { 'foo': 'bar' }
         * });
         */
        SDK.prototype.patchExtensionViewerState = function (userStates) {
            return this.client.patchExtensionViewerState(this.identifier, userStates);
        };
        /**
         * Sets the extension wide state to a JS object, this may only be called in a broadcaster context
         * for the extension owner. Extension owner may be configured through the development portal.
         * Future calls to {@link getAllState} by all users will have a clone of this object in the
         * `extension` field.
         * @async
         * @since 1.1.0
         *
         * @param {Object} state - A complete JS object representing the current extension's state.
         *
         * @return {Promise} Will resolve on successful server-send. Rejects on failure.
         *
         * @example
         * sdk.setExtensionState({
         *   favorite_movie: 'Jaws: The Revenge'
         * }).then(() => {
         *   console.log('Extension state saved!');
         * }).catch((err) => {
         *   console.error(`Failed saving viewer state: ${err}`);
         * });
         */
        SDK.prototype.setExtensionState = function (state) {
            return this.client.setExtensionState(this.identifier, state);
        };
        /**
         * Sets the extension-wide secret state to a JS object, this may only be called by an extension
         * owner. This state object will never be returned to the broadcaster or viewers.
         * @async
         * @since 2.0.0
         *
         * @param {Object} state - A complete JS object
         *
         * @return {Promise} Will resolve on successful server-send. Rejects on failure.
         *
         * @example
         * sdk.setExtensionSecretState({
         *   favorite_movie: 'Twilight: New Moon'
         * }).then(() => {
         *   console.log('Extension secrets saved!');
         * }).catch((err) => {
         *   console.error(`Failed saving secret state: ${err}`);
         * });
         */
        SDK.prototype.setExtensionSecretState = function (state) {
            return this.client.setExtensionSecretState(this.identifier, state);
        };
        /**
         * Sets the channel-specific state to a JS object. Future calls to {@link getAllState} by **any**
         * user on this channel will have a clone of this object in the `channel` field.
         *
         * Broadcaster-only functionality.
         *
         * @async
         * @since 1.0.0
         *
         * @param {Object} state - A complete JS object representing the current channel state.
         *
         * @return {Promise} Will resolve on successful server-send. Rejects on failure.
         *
         * @example
         * sdk.setChannelState({
         *   broadcasters_mood: 'sanguine, my brother',
         *   chats_mood: 'kreygasm'
         * }).then(() => {
         *   // Let viewers know that new channel state is available.
         * }).catch((err) => {
         *   console.error(`Failed saving channel state: ${err}`);
         * });
         */
        SDK.prototype.setChannelState = function (state) {
            return this.client.setChannelState(this.identifier, state);
        };
        /**
         * Returns the current state object as set for the current extension, channel and
         * viewer combination.
         * @async
         * @since 1.0.0
         *
         * @return {Promise<AllState>} Resolves on successful server request with a populated AllState
         * object.
         *
         * @example
         * sdk.getAllState().then((state) => {
         *   if (state.channel.broadcasters_mood) {
         *     console.log(`Broadcaster set their mood as: ${state.channel.broadcasters_mood}`);
         *   }
         *   if (state.viewer.favorite_movie) {
         *     console.log(`But your favorite movie is: ${state.viewer.favorite_movie}`);
         *   }
         * });
         */
        SDK.prototype.getAllState = function () {
            return this.client.getState(this.identifier);
        };
        /**
         * Returns the current extension state object
         * @async
         *
         * @return {Promise<Object>} Resolves on successful server request with a populated extension state object.
         */
        SDK.prototype.getExtensionState = function () {
            return this.client.getExtensionState(this.identifier);
        };
        /**
         * Returns the current channel state object
         * @async
         *
         * @return {Promise<Object>} Resolves on successful server request with a populated channel state object.
         */
        SDK.prototype.getChannelState = function () {
            return this.client.getChannelState(this.identifier);
        };
        /**
         * Returns the current extension viewer state object
         * @async
         *
         * @return {Promise<Object>} Resolves on successful server request with a populated extension viewer state object.
         */
        SDK.prototype.getExtensionViewerState = function () {
            return this.client.getExtensionViewerState(this.identifier);
        };
        /**
         * Returns the current viewer state object
         * @async
         *
         * @return {Promise<Object>} Resolves on successful server request with a populated viewer state object.
         */
        SDK.prototype.getViewerState = function () {
            return this.client.getViewerState(this.identifier);
        };
        /**
         * Returns the current extension secret state if the requesting user has access to the secret state.
         * @async
         *
         * @return {Promise<Object>} Resolves on successful server request with a populated extension secret state object.
         */
        SDK.prototype.getExtensionSecretState = function () {
            return this.client.getExtensionSecretState(this.identifier);
        };
        /**
         * Returns a mapping of user_id to extension specific viewer states.
         * If a viewer doesn't have state set, but was requested, that user will
         * not be in the response object. The maximum numer of users that can be
         * queried with this call is 1000.
         * @async
         *
         * @param users - an array of userIDs to request state for.
         *
         * @return {Promise<object>} Resolves on successful server request with an object that is a mapping
         *  of userID to state. Rejects on failure.
         *
         * @example
         * sdk.patchExtensionViewerState({
         *  'valid-user-id': {
         *    'hello': 'world'
         *  }
         * }).then(() => {
         *  sdk.multiGetExtensionViewerState(['valid-user-id', 'invalid-user-id']).then(state => {
         *    console.log(state['valid-user-id'].hello) // prints 'world'
         *    console.log(state['invalid-user-id']) // is undefined.
         *  });
         * }
         */
        SDK.prototype.multiGetExtensionViewerState = function (users) {
            if (users.length > 1000) {
                throw new Error('Too many users specified in call to multiGetExtensionViewerState');
            }
            return this.client.multiGetExtensionViewerState(this.identifier, users);
        };
        /**
         * JSON Store
         */
        /**
         * The JSON store is used similarly to the channel state, in that a broadcaster can use it to
         * store arbitrary JSON data that is accessible to all viewers. The stored data is specific to
         * a particular channel and cannot be accessed by viewers of a different channel.
         *
         * Unlike channel state however, each channel can have several JSON stores, accessed by different
         * keys. The data associated with each key must be under 2KB, but there is no limit to the number
         * of keys in use.
         *
         * Also, when pushing new data to the JSON store, a messenger event is automatically sent to all
         * active viewers of the associated channel and the broadcaster's live and config pages. This
         * event will have the format `json_store_update:${key}`. See {@link listen} for details on
         * receiving this event.
         *
         * @async
         * @since 1.0.0
         *
         * @throws {TypeError} Will throw an error if key is provided but is not a string.
         *
         * @param {string?} key - The lookup key for data in the JSON store. Uses 'default' if no value
         * is provided.
         *
         * @return {Promise<Object>} Resolves with the stored JSON parsed to a JS Object associated with
         * the key. Rejects on server error or if the key has no associated data.
         *
         * @example
         * sdk.getJSONStore('basecamp').then((basecamp) => {
         *   if (basecamp && basecamp.tanks) {
         *     deploy(basecamp.tanks);
         *   }
         * });
         */
        SDK.prototype.getJSONStore = function (key) {
            if (key) {
                forceType(key, 'string');
            }
            return this.client.getJSONStore(this.identifier, key);
        };
        /**
         * Two-Factor Auth
         */
        /**
         * Attempts to validate a broadcaster's PIN with Muxy's Two-Factor auth system. For this to work,
         * the broadcaster must have initiated a Two-Factor request for this channel within the auth
         * window.
         *
         * Broadcaster-only functionality.
         *
         * @async
         * @since 1.0.0
         *
         * @throws {TypeError} Will throw an error if `pin` is not a string.
         *
         * @param {string} pin - The broadcaster's PIN to validate the associated auth token.
         *
         * @return {Promise} Resolves if the auth token associated with this PIN can now be used to make
         * requests on behalf of this broadcaster, rejects with an error otherwise.
         *
         * @example
         * sdk.validateCode('MUXY').then(() => {
         *   console.log('Validated! Go go go!');
         * });
         */
        SDK.prototype.validateCode = function (pin) {
            forceType(pin, 'string');
            return this.client.validateCode(this.identifier, pin);
        };
        /**
         * Checks to see if the broadcaster has validated an auth token in the current context. It does
         * not return information about the PIN used or auth token that is valid.
         *
         * Broadcaster-only functionality.
         *
         * @async
         * @since 1.0.0
         *
         * @return {Promise<Object>}
         * @property {boolean} exists - True if an auth token has been validated, false otherwise.
         *
         * @example
         * sdk.pinTokenExists().then((resp) => {
         *   if (!resp.exists) {
         *     showBroadcasterPINInput();
         *   } else {
         *     console.log('Already authorized');
         *   }
         * });
         */
        SDK.prototype.pinTokenExists = function () {
            return this.client.pinTokenExists(this.identifier);
        };
        /**
         * Revokes all auth tokens ever generated for this channel and identifier. After calling this
         * method, tokens currently in use by external apps will cease to function.
         *
         * Broadcaster-only functionality.
         *
         * @async
         * @since 1.0.0
         *
         * @return {Promise} Resolves on sucess, rejects with an error otherwise.
         *
         * @example
         * sdk.revokeAllPINCodes().then(() => {
         *   console.log('No more data coming in!');
         * });
         */
        SDK.prototype.revokeAllPINCodes = function () {
            return this.client.revokeAllPINCodes(this.identifier);
        };
        /**
         * Event System
         */
        /**
         * Sends a message to all listening clients. And viewers or broadcaters listening for the
         * event name will be automatically notified. See {@link listen} for receiving events.
         *
         * Broadcaster-only functionality.
         *
         * @async
         * @since 1.0.0
         *
         * @param {string} event - An event name, in the form [a-z0-9_]+
         * @param {string|*} userID - An optional opaque user id, used to limit the
         * scope of send to that user only.
         * @param {*} [data] - Any JSON serializable primitive to send to all viewers.
         *
         * @example
         * sdk.send('new_song', {
         *   artist: 'Celine Dion',
         *   title: 'My Heart Will Go On',
         *   album: 'Let\'s Talk About Love',
         *   year: 1997
         * });
         */
        SDK.prototype.send = function (event, userID, data) {
            if (!mxy.didLoad) {
                throw new Error('sdk.loaded() was not complete. Please call this method only after the promise has resolved.');
            }
            forceType(event, 'string');
            var target = 'broadcast';
            var realData = data;
            if (!data) {
                realData = userID;
            }
            else {
                target = "whisper-" + userID;
            }
            this.messenger.send(this.identifier, event, target, realData, this.client);
        };
        /**
         * Registers a callback to listen for events. In general, events are named in the form
         * `event[:identifier]`, where the identifier is the `event` parameter to {@link send}.
         *
         * You can listen to wildcards by using * instead of an event or identifier name.
         *
         * Some methods also automatically send special namespaced events. See {@link vote} and
         * {@link getJSONStore} for examples.
         *
         * You can listen for these events by using `vote_update:next_game` or `vote_update:*`
         * to receive vote updates for specifically the `next_game` vote id, or all vote
         * updates respectively.
         *
         * @since 1.0.0
         *
         * @param {string} inEvent - The event name to listen on. May include wildcards `*`.
         * @param {string|Function} inUserID - An optional opaque user id, used to limit
         * the scope of this listen to that user only.
         * @param {Function} [inCallback] - A callback with the signature `function(body, eventname)`.
         * This callback will receive the message body as its first parameter and the `event` parameter
         * to {@link send} as the second.
         *
         * @return {Object} A listener handle that can be passed to {@see unlisten} to unbind
         * this callback.
         *
         * @example
         * sdk.listen('new_song', (track) => {
         *   console.log(`${track.artist} - {track.title} (${track.year})`);
         * });
         */
        SDK.prototype.listen = function (inEvent, inUserID, inCallback) {
            var _this = this;
            if (!mxy.didLoad) {
                throw new Error('sdk.loaded() was not complete. Please call this method only after the promise has resolved.');
            }
            var realEvent = CurrentEnvironment().environment + ":" + this.identifier + ":" + inEvent;
            var l = 'broadcast';
            var callback = inCallback;
            if (callback) {
                l = "whisper-" + inUserID;
            }
            else {
                callback = inUserID;
            }
            var messageBuffer = [];
            var cb = function (msg) {
                try {
                    // Production messages may be unprefixed.
                    if (CurrentEnvironment().environment === 'production') {
                        if (eventPatternMatch(msg.event, _this.identifier + ":" + inEvent)) {
                            var truncatedEvent = msg.event
                                .split(':')
                                .slice(1)
                                .join(':');
                            callback(msg.data, truncatedEvent);
                            return;
                        }
                    }
                    if (eventPatternMatch(msg.event, realEvent)) {
                        // Consumers of the SDK only ever interact with events
                        // without the app-id or extension-id prefix.
                        var truncatedEvent = msg.event
                            .split(':')
                            .slice(2)
                            .join(':');
                        var serialized_1 = JSON.stringify(msg);
                        var now_1 = new Date().valueOf();
                        var deduped_1 = false;
                        messageBuffer.forEach(function (b) {
                            if (b.content === serialized_1) {
                                if (now_1 - b.timestamp < 5 * 1000) {
                                    deduped_1 = true;
                                }
                            }
                        });
                        if (deduped_1) {
                            return;
                        }
                        messageBuffer.unshift({
                            content: serialized_1,
                            timestamp: now_1
                        });
                        messageBuffer = messageBuffer.slice(0, 10);
                        callback(msg.data, truncatedEvent);
                    }
                }
                catch (err) {
                    // TODO: Should this fail silently?
                    consolePrint(err, { type: 'error' });
                }
            };
            return this.messenger.listen(this.identifier, l, cb);
        };
        /**
         * Unbinds a callback from the event system.
         *
         * @since 1.0.0
         *
         * @param {Object} handle - An event handle as returned from {@see listen}.
         */
        SDK.prototype.unlisten = function (handle) {
            return this.messenger.unlisten(this.identifier, handle);
        };
        /**
         * Analytics
         */
        /**
         * Sends an arbitrary event to the analytics backend.
         *
         * @async
         * @since 1.0.0
         *
         * @param {string} name - A unique identifier for this event.
         * @param {number} [value=1] - A value to associate with this event.
         * @param {string} [label=''] - A human-readable label for this event.
         */
        SDK.prototype.sendAnalyticsEvent = function (name, value, label) {
            if (value === void 0) { value = 1; }
            if (label === void 0) { label = ''; }
            this.analytics.sendEvent(this.identifier, name, value, label);
        };
        /**
         * Monetization
         */
        /**
         * Begins the purchase flow for a given product's SKU.
         *
         * @param {string} sku - The SKU of the digital good that the user has indicated they want to buy.
         */
        SDK.prototype.beginPurchase = function (sku) {
            if (this.SKUs.length === 0) {
                throw new Error('beginPurchase() cannot be used unless SKUs are provided.');
            }
            forceType(sku, 'string');
            return Ext.beginPurchase(sku);
        };
        /**
         * Gets the current price for each item offered.
         *
         * @async
         *
         * @return {Object} An object with the SKU codes as keys.
         */
        SDK.prototype.getPrices = function () {
            if (this.SKUs.length === 0) {
                throw new Error('getPrices() cannot be used unless SKUs are provided.');
            }
            return new Promise(function (resolve) {
                Ext.getPrices(function (prices) {
                    resolve(prices);
                });
            });
        };
        /**
         * Sets a function to be used as a callback when entitlements need to be reloaded, i.e. after a
         * purchase has been made.
         *
         * @param {function} callback - A function to be called to update user entitlements.
         */
        SDK.prototype.onReloadEntitlements = function (callback) {
            if (this.SKUs.length === 0) {
                throw new Error('onReloadEntitlements() cannot be used unless SKUs are provided.');
            }
            return Ext.onReloadEntitlements(callback);
        };
        /**
         * Sets a function to be used as a callback that is triggered when the extension visibility changes
         * (This occurs only for mobile or component extensions.)
         *
         * @param {function} callback
         */
        SDK.prototype.onVisibilityChanged = function (callback) {
            return Ext.onVisibilityChanged(callback);
        };
        /**
         * Sets a function to be used as a callback that is triggered when the extension changes position in the player
         * This occurs only for video-component extensions.
         *
         * @param {function} callback
         */
        SDK.prototype.onPositionChanged = function (callback) {
            return Ext.onPositionChanged(callback);
        };
        /**
         * Attempt to exchange one eligibility status for a single prize code.
         * If a code is redeemed, the returned body will have a `code` member, which is the code that was redeemed.
         * @async
         *
         * @throws {TypeError} Will throw an error if prizeIndex is not a valid number
         *
         * @param {number} prize_idx - The prize index
         *
         * @return {Promise<RedeemResult>}
         */
        SDK.prototype.redeemCode = function (prizeIndex) {
            forceType(prizeIndex, 'number');
            return this.client.redeemCode(this.identifier, prizeIndex);
        };
        /**
         * Fetches all codes that the user has redeemed for this extension.
         * @async
         *
         * @return {Promise<RedeemedCodes>} Will resolve on success. Rejects on failure.
         */
        SDK.prototype.getRedeemedCodes = function () {
            return this.client.getRedeemedCodes(this.identifier);
        };
        /**
         * Fetches information about which codes a user is eligible for
         * @async
         *
         * @return {Promise<EligibleCodes>} Will resolve on success. Rejects on failure.
         */
        SDK.prototype.getEligibleCodes = function () {
            return this.client.getEligibleCodes(this.identifier);
        };
        /**
         * Sets the user's trivia team to the current channel.
         * @async
         *
         * @return {Promise<any>}
         */
        SDK.prototype.joinExtensionTriviaTeam = function () {
            return this.client.joinExtensionTriviaTeam(this.identifier);
        };
        /**
         * Return the user's stored trivia team.
         * @async
         *
         * @return {Promise<TriviaTeam>}
         */
        SDK.prototype.getExtensionTriviaJoinedTeam = function () {
            return this.client.getExtensionTriviaJoinedTeam(this.identifier);
        };
        /**
         * Add a trivia question to the extension.
         * Requires extension admin permissions.
         * @async
         *
         * @return {Promise<any>}
         */
        SDK.prototype.addExtensionTriviaQuestion = function (question) {
            return this.client.addExtensionTriviaQuestion(this.identifier, question);
        };
        /**
         * Removes a trivia question from the extension.
         * Requires extension admin permissions.
         * @async
         *
         * @return {Promise<any>}
         */
        SDK.prototype.removeExtensionTriviaQuestion = function (triviaQuestionID) {
            return this.client.removeExtensionTriviaQuestion(this.identifier, triviaQuestionID);
        };
        /**
         * Add an option to a trivia question.
         * Requires extension admin permissions.
         * @async
         *
         * @return {Promise<any>}
         */
        SDK.prototype.addExtensionTriviaOptionToQuestion = function (questionID, option) {
            return this.client.addExtensionTriviaOptionToQuestion(this.identifier, questionID, option);
        };
        /**
         * Remove an option from a trivia question.
         * Requires extension admin permissions.
         * @async
         *
         * @return {Promise<any>}
         */
        SDK.prototype.removeExtensionTriviaOptionFromQuestion = function (questionID, optionID) {
            return this.client.removeExtensionTriviaOptionFromQuestion(this.identifier, questionID, optionID);
        };
        /**
         * Change the state of a extension trivia question.
         * Requires extension admin permissions.
         * @async
         *
         * @return {Promise<any>}
         */
        SDK.prototype.setExtensionTriviaQuestionState = function (questionID, state, winner) {
            return this.client.setExtensionTriviaQuestionState(this.identifier, questionID, state, winner);
        };
        /**
         * As a user place a vote on a trivia question
         * @async
         *
         * @return {Promise<any>}
         */
        SDK.prototype.setExtensionTriviaQuestionVote = function (questionID, optionID) {
            return this.client.setExtensionTriviaQuestionVote(this.identifier, questionID, optionID);
        };
        /**
         * Returns all of the current trivia questions
         * @async
         *
         * @return {Promise<TriviaQuestionResponse>}
         */
        SDK.prototype.getExtensionTriviaQuestions = function () {
            return this.client.getExtensionTriviaQuestions(this.identifier);
        };
        /**
         * Get information about a specific trivia question
         * @async
         *
         * @return {Promise<TriviaQuestion>}
         */
        SDK.prototype.getExtensionTriviaQuestion = function (questionID) {
            return this.client.getExtensionTriviaQuestion(this.identifier, questionID);
        };
        /**
         * Return the trivia leaderboard
         * @async
         *
         * @return {Promise<TriviaLeaderboardTeam[]>}
         */
        SDK.prototype.getExtensionTriviaLeaderboard = function () {
            return this.client.getExtensionTriviaLeaderboard(this.identifier);
        };
        /**
         * Admin-level functionality
         */
        /**
         * Fetches a list of all users who have shared their identity with the extension.
         *
         * This function takes an optional `next` value which should match that returned from previous
         * invocations to iterate through the response. If the returned `next` value is `0`, all
         * available values have been returned and iteration can be stopped.
         *
         * At most 1000 entries will be returned in a single call.
         *
         * Note that because of the asynchronous nature, duplicate entries may be returned and should be
         * uniqued on the client.
         *
         * Admin-only function.
         * @async
         *
         * @return {Promise<ExtensionUsersResult>} Will resolve on success. Rejects on failure.
         */
        SDK.prototype.getExtensionUsers = function (next) {
            return this.client.getExtensionUsers(this.identifier, next);
        };
        /**
         * Private Instance Methods
         */
        /** @ignore */
        SDK.prototype.setup = function (identifier, client, user, messenger, analytics, loadPromise, SKUs, debug) {
            /** @ignore */
            this.userObservers = new Observer();
            /** @ignore */
            this.contextObservers = new Observer();
            /** @ignore */
            this.loadPromise = loadPromise;
            /**
             * A unique instance identifier. Either the extension or app ID.
             * @public
             * @type {string}
             */
            this.identifier = identifier;
            /**
             * The backend state client.
             * @private
             * @type {Client}
             *
             */
            this.client = client;
            /**
             * The backend event messenger client.
             * @private
             * @type {Messenger}
             *
             */
            this.messenger = messenger;
            /**
             * The backend analytics client.
             * @private
             * @type {Analytics}
             *
             */
            this.analytics = analytics;
            /**
             * An automatically updated User instance for the current extension user.
             * This is only valid after .loaded() has resolved.
             * @public
             * @type {User}
             */
            this.user = user;
            /**
             * SKUs associated with the products offered in the extension.
             * @public
             * @type {Object}
             */
            this.SKUs = SKUs;
            /** @ignore */
            this.debug = debug;
        };
        return SDK;
    }());

    /**
     * A single good object as from {@link getUserGoods}.
     *
     * @typedef {Object} ExtensionGood
     *
     * @property {string} next_instruction - The next instruction (action) for the purchase. Can be:
     *   - "NOOP" - No action is needed, the good was fullfilled.
     *   - "FULFILL" - Fulfill the purchase, then call the Twitch entitlement system to indicate
     *     successful completion of the fullfillment.
     *   - "REVOKE" - Unwind the transaction.
     * @property {string} receipt_id - An ID which uniquely identifies the purchase transaction.
     * @property {string} sku - The SKU for the digital good.
     */
    /**
     * A receipt detailing which good's fulfillment status needs to be set. Used as a parameter for
     * {@link updateFulfilledGoods}.
     *
     * @typedef {Object} Receipt
     *
     * @property {string} fulfillment_address - Twitch User ID
     * @property {string} receipt_id - Receipt ID for the digital good, returned by {@link getUserGoods}
     * @property {string} last_instruction - The last thing you did. Corresponds to the "next
     * instruction" for the purchase returned by {@link getUserGoods}. Value value: `FULFILL`.
     */
    /**
     * Provides a convenient interface for Twitch API requests with an automatically set and updated
     * extension client id.
     *
     * Should not normally be created directly, instead an instance is made available
     * and namespaced appropriately when using {@link Muxy.TwitchClient}.
     *
     * @private
     *
     * @example
     * const twitchClient = new Muxy.TwitchClient();
     * twitchClient.getAllState().then((state) => {
     *   console.log(state);
     * });
     */
    var TwitchClient = /** @class */ (function () {
        /**
         * Create an instance of TwitchClient bound to the provided client ID.
         *
         * Prefer {@link Muxy.TwitchClient} instead.
         *
         * @since 1.0.0
         * @ignore
         *
         * @param {string} clientID - A valid Twitch Extension Client ID.
         */
        function TwitchClient(clientID) {
            /** @ignore */
            this.extensionId = clientID;
            /** @ignore */
            this.promise = Promise.resolve();
        }
        /**
         * Returns a promise which will resolve once the TwitchClient is available for use.
         *
         * @since 1.0.0
         * @public
         *
         * @return {Promise} Will resolve when the TwitchClient is ready for use.
         */
        TwitchClient.prototype.loaded = function () {
            return this.promise;
        };
        /**
         * Wraps an AJAX request to Twitch's kraken API. Used internally by the API
         * convenience methods.
         *
         * @async
         * @since 1.0.0
         * @ignore
         *
         * @param {string} method - The AJAX request method, e.g. "POST", "GET", etc.
         * @param {string} endpoint - The Twitch kraken API endpoint.
         * @param {string?} data - A string-encoded JSON payload to send with the request.
         * @param {Object} JWT - Signed JWT, accessible from sdk.user.twitchJWT.
         *
         * @return {Promise} Resolves with the AJAX payload on response < 400.
         * Rejects otherwise.
         */
        TwitchClient.prototype.signedTwitchRequest = function (method, endpoint, data, JWT) {
            var headers = {
                Accept: 'application/vnd.twitchtv.v5+json',
                'Client-ID': this.extensionId,
                Authorization: undefined
            };
            if (JWT) {
                headers.Authorization = "Bearer " + JWT;
            }
            return new Promise(function (resolve, reject) {
                var xhrPromise = new XHRPromise({
                    data: data,
                    headers: headers,
                    method: method,
                    url: "https://api.twitch.tv/kraken/" + endpoint
                });
                return xhrPromise
                    .send()
                    .catch(reject)
                    .then(function (resp) {
                    if (resp.status < 400) {
                        resolve(resp.responseText);
                    }
                    reject(resp.responseText);
                });
            });
        };
        /**
         * Wraps an AJAX request to Twitch's helix API. Used internally by the API
         * convenience methods.
         *
         * @async
         * @ignore
         *
         * @param {string} method - The AJAX request method, e.g. "POST", "GET", etc.
         * @param {string} endpoint - The Twitch helix API endpoint.
         * @param {string?} data - A string-encoded JSON payload to send with the request.
         * @param {Object} JWT - Signed JWT, accessible from sdk.user.twitchJWT.
         *
         * @return {Promise} Resolves with the AJAX payload on response < 400.
         * Rejects otherwise.
         */
        TwitchClient.prototype.signedTwitchHelixRequest = function (method, endpoint, data, JWT) {
            var headers = {
                Authorization: undefined,
                'Client-ID': this.extensionId
            };
            if (JWT) {
                headers.Authorization = "Bearer " + JWT;
            }
            return new Promise(function (resolve, reject) {
                var xhrPromise = new XHRPromise({
                    data: data,
                    headers: headers,
                    method: method,
                    url: "https://api.twitch.tv/helix/" + endpoint
                });
                return xhrPromise
                    .send()
                    .then(function (resp) {
                    if (resp.status < 400) {
                        try {
                            if (resp.responseText.hasOwnProperty('data')) {
                                var anyResp = resp.responseText;
                                var r = anyResp.data;
                                resolve(r);
                            }
                            else {
                                resolve(resp.responseText);
                            }
                        }
                        catch (err) {
                            reject('Unexpected response from Twitch');
                        }
                    }
                    reject(resp.responseText);
                })
                    .catch(reject);
            });
        };
        /**
         * Wraps an AJAX request to Twitch's Extension API. Used internally by the API
         * convenience methods.
         *
         * @async
         * @ignore
         *
         * @param {string} method - The AJAX request method, e.g. "POST", "GET", etc.
         * @param {string} endpoint - The Twitch Extension API endpoint.
         * @param {string?} data - A string-encoded JSON payload to send with the request.
         * @param {Object} JWT - Signed JWT, accessible from sdk.user.twitchJWT.
         *
         * @return {Promise} Resolves with the AJAX payload on response < 400.
         * Rejects otherwise.
         */
        TwitchClient.prototype.signedTwitchExtensionRequest = function (method, endpoint, data, JWT) {
            var headers = {
                'Client-ID': this.extensionId,
                Authorization: undefined
            };
            if (JWT) {
                headers.Authorization = "Bearer " + JWT;
            }
            return new Promise(function (resolve, reject) {
                var xhrPromise = new XHRPromise({
                    data: data,
                    headers: headers,
                    method: method,
                    url: "https://api.twitch.tv/extensions/" + endpoint
                });
                return xhrPromise
                    .send()
                    .catch(reject)
                    .then(function (resp) {
                    if (resp.status < 400) {
                        resolve(resp.responseText);
                    }
                    reject(resp.responseText);
                });
            });
        };
        /**
         * Returns a list of Twitch User objects for a given list of usernames.
         *
         * @async
         * @since 1.0.0
         *
         * @throws {TypeError} Will throw an error if users is not an array of strings.
         *
         * @param {[]string} usernames - A list of usernames to lookup on Twitch.
         *
         * @return {Promise<[]TwitchUser>} Resolves with a list of {@link TwitchUser}
         * objects for each of the usernames provided.
         *
         * @example
         * twitchClient.getTwitchUsers(['muxy'], (response) => {
         *  console.log(response.users[0].display_name);
         * });
         */
        TwitchClient.prototype.getTwitchUsers = function (usernames) {
            if (usernames.length === 0) {
                return Promise.resolve([]);
            }
            return this.signedTwitchRequest('GET', "users?login=" + usernames.join(','));
        };
        /**
         * Returns a list of Twitch User objects for a given list of user IDs.
         *
         * @async
         *
         * @throws {TypeError} Will throw an error if userIDs is not an array of strings.
         *
         * @param {[]string} userIDs - A list of user IDs to lookup on Twitch.
         *
         * @return {Promise<[]HelixTwitchUser>} Resolves with a list of {@link HelixTwitchUser}
         * objects for each of the user IDs provided.
         *
         * @example
         * twitchClient.getTwitchUsersByID(['126955211'], (response) => {
         *  console.log(response.users[0].display_name);
         * });
         */
        TwitchClient.prototype.getTwitchUsersByID = function (userIDs) {
            if (userIDs.length === 0) {
                return Promise.resolve([]);
            }
            return this.signedTwitchHelixRequest('GET', "users?id=" + userIDs.join(','));
        };
        /**
         * Monetization
         */
        /**
         * Gets a list of the digital goods the current user has.
         *
         * @param {Object} jwt - Signed JWT, accessible from sdk.user.twitchJWT
         *
         * @return {Promise<[]ExtensionGood>} Resolves with a list of {@link ExtensionGood} objects for
         * each of the goods the user is entitled to.
         */
        TwitchClient.prototype.getUserGoods = function (jwt) {
            return this.signedTwitchRequest('POST', 'commerce/user/goods', '{}', jwt);
        };
        /**
         * Sets the fulfillment status for the specified receipts (purchases).
         *
         * @param {Object} jwt - Signed JWT, accessible from sdk.user.twitchJWT
         * @param {[]Receipt} receipts - List of {@link Receipt} objects detailing which goods need to be
         * updated.
         *
         * @return {Promise<[]Object>} Resolves with a list of results, one for each Receipt in the
         * Receipts parameter.
         */
        TwitchClient.prototype.updateFulfilledGoods = function (jwt, receipts) {
            return this.signedTwitchRequest('POST', 'commerce/user/goods/fulfill', receipts, jwt);
        };
        /**
         * Sets the required configuration string enabling an extension to be enabled
         *
         * SEE: https://dev.twitch.tv/docs/extensions/reference/#set-extension-required-configuration
         *
         * @param jwt - Signed JWT, accessible from sdk.user.twitchJWT
         * @param configurationString - A string that matches the required configuration string in the extension config
         */
        TwitchClient.prototype.setExtensionRequiredConfiguration = function (jwt, configurationString) {
            var environment = Util.getTwitchEnvironment();
            var data = { required_configuration: configurationString };
            var token = Util.extractJWTInfo(jwt);
            return this.signedTwitchExtensionRequest('PUT', this.extensionId + "/" + environment.version + "/required_configuration?channel_id=" + token.channel_id, JSON.stringify(data), jwt);
        };
        return TwitchClient;
    }());

    var author = "Muxy, Inc.";
    var version = "2.2.6";
    var repository = "https://github.com/muxy/extensions-js";

    /**
     * @module Muxy
     */
    /**
     * The main extension entry interface, available as the global `Muxy` object.
     *
     * This class handles environment detection, data harness collection and updates (for
     * authentication and backend communication) and SDK instance creation.
     *
     * On import or inclusion in an HTML file, a singleton object will be globally accessible
     * as `Muxy`.
     */
    var Muxy = /** @class */ (function () {
        /**
         * Private constructor for singleton use only.
         * @ignore
         */
        function Muxy() {
            var _this = this;
            /**
             * Returns a version of the Muxy SDK associated with the provided identifier.
             * @since 1.0.0
             * @public
             *
             * @param {string?} id - A unique identifier for this extension or app. If omitted, the
             * extension client id will be used.
             *
             * @throws {Error} Will throw an error if called before {@link Muxy.setup}.
             *
             * @returns {SDK} An instance of the SDK class.
             *
             * @example
             * const sdk = new Muxy.SDK();
             * sdk.loaded().then(() => {
             *   sdk.send('Hello World');
             * }).catch((err) => {
             *   console.error(err);
             * });
             */
            this.SDK = SDK;
            /**
             * Makes trivia state enum available from the global `Muxy` object
             */
            this.TriviaQuestionState = TriviaQuestionState;
            this.Util = Util;
            this.setupCalled = false;
            this.testChannelID = '23161357';
            this.testJWTRole = 'viewer';
            this.twitchClientID = '';
            this.SDKClients = {};
            this.client = null;
            this.messenger = null;
            this.cachedTwitchClient = null;
            this.analytics = null;
            this.user = null;
            this.didLoad = false;
            this.loadPromise = new Promise(function (resolve, reject) {
                /** @ignore */
                _this.loadResolve = resolve;
                /** @ignore */
                _this.loadReject = reject;
            });
            this.SKUs = [];
            this.debugOptions = null;
            this.watchingAuth = false;
            StateClient.setEnvironment(Util.currentEnvironment(), null);
        }
        /**
         * Prints to console a description of the library's current version and
         * environment info. This is called automatically when the library is
         * setup, unless the `quiet` parameter is passed to {@link setup}.
         *
         * @since 1.0.0
         * @public
         *
         * @example
         * Muxy.printInfo();
         * ┌──────────────────────────────────────────────────┐
         * | Muxy Extensions SDK                              |
         * | v1.0.0 © 2017 Muxy, Inc.                         |
         * | https://github.com/muxy/extensions-js            |
         * |                                                  |
         * | Running in sandbox environment outside of Twitch |
         * └──────────────────────────────────────────────────┘
         *
         */
        Muxy.printInfo = function () {
            var SDKInfoText = [
                'Muxy Extensions SDK',
                "v" + version + " \u00A9 " + new Date().getFullYear() + " " + author,
                repository,
                ''
            ];
            switch (Util.currentEnvironment()) {
                case Util.Environments.Production:
                    SDKInfoText.push('Running on production');
                    break;
                case Util.Environments.SandboxDev:
                    SDKInfoText.push('Running in sandbox environment outside of Twitch');
                    break;
                case Util.Environments.SandboxTwitch:
                    SDKInfoText.push('Running in sandbox environment on Twitch');
                    break;
                case Util.Environments.SandboxAdmin:
                    SDKInfoText.push('Running in sandbox environment in the Admin panel');
                    break;
                case Util.Environments.Admin:
                    SDKInfoText.push('Running in the Admin panel');
                    break;
                case Util.Environments.Testing:
                    SDKInfoText.push('Running in testing environment outside of Twitch');
                    break;
                case Util.Environments.Server:
                    SDKInfoText.push('Running on a NodeJS server');
                    break;
                default:
                    SDKInfoText.push('Could not determine execution environment.');
            }
            Util.consolePrint(SDKInfoText, { boxed: true });
        };
        /**
         * Called the first time the {@link setup} is called to start watching the auth
         * and context callbacks and updating values automatically. This method should
         * not normally be called directly.
         *
         * @since 1.0.0
         * @ignore
         *
         * @param {string} extensionID - The Twitch Extension Client ID to use for all
         * Twitch API requests.
         */
        Muxy.prototype.watchAuth = function (extensionID) {
            var _this = this;
            Ext.extensionID = extensionID;
            // Auth callback handler
            Ext.onAuthorized(this.debugOptions, function (auth) {
                if (!auth) {
                    _this.loadReject('Received invalid authorization from Twitch');
                    return;
                }
                _this.twitchClientID = auth.clientId;
                _this.messenger.extensionID = auth.clientId;
                _this.messenger.channelID = auth.channelId;
                _this.client.updateAuth(auth.token);
                var resolvePromise = function (user) {
                    _this.user = user;
                    var keys = Object.keys(_this.SDKClients);
                    for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
                        var key = keys_1[_i];
                        _this.SDKClients[key].updateUser(_this.user);
                    }
                    if (_this.analytics) {
                        _this.analytics.user = _this.user;
                    }
                };
                var onFirstAuth = function () {
                    _this.client
                        .immediateGetUserInfo(extensionID)
                        .then(function (userinfo) {
                        var offset = userinfo.server_time - new Date().getTime();
                        var user = new User(auth);
                        user.ip = userinfo.ip_address;
                        user.registeredWithMuxy = userinfo.registered || false;
                        user.visualizationID = userinfo.visualization_id || '';
                        user.timeOffset = offset;
                        var keys = Object.keys(_this.SDKClients);
                        for (var _i = 0, keys_2 = keys; _i < keys_2.length; _i++) {
                            var key = keys_2[_i];
                            _this.SDKClients[key].timeOffset = offset;
                        }
                        updateUserContextSettings.call(_this);
                        _this.didLoad = true;
                        resolvePromise(user);
                        _this.loadResolve();
                    })
                        .catch(function (err) {
                        _this.loadReject(err);
                    });
                };
                if (_this.user) {
                    _this.user.updateAuth(auth);
                    resolvePromise(_this.user);
                }
                else {
                    onFirstAuth();
                }
            });
            // Context callback handler
            var updateUserContextSettings = function () {
                if (!_this.user || !_this.context) {
                    return;
                }
                // Set Video Mode
                if (_this.context.isFullScreen) {
                    _this.user.videoMode = 'fullscreen';
                }
                else if (_this.context.isTheatreMode) {
                    _this.user.videoMode = 'theatre';
                }
                else {
                    _this.user.videoMode = 'default';
                }
                _this.user.game = _this.context.game;
                _this.user.bitrate = Math.round(_this.context.bitrate || 0);
                _this.user.latency = _this.context.hlsLatencyBroadcaster;
                _this.user.buffer = _this.context.bufferSize;
                _this.user.theme = _this.context.theme;
                _this.user.volume = _this.context.volume;
                var keys = Object.keys(_this.SDKClients);
                for (var _i = 0, keys_3 = keys; _i < keys_3.length; _i++) {
                    var key = keys_3[_i];
                    _this.SDKClients[key].updateUser(_this.user);
                }
                // If buffer size goes to 0, send an analytics event that
                // this user's video is buffering.
                if (_this.context.bufferSize < 1 && _this.analytics) {
                    _this.analytics.user = _this.user;
                    _this.analytics.sendEvent('video', 'buffer', 1);
                }
            };
            Ext.onContext(function (context) {
                _this.context = context;
                if (_this.user) {
                    updateUserContextSettings.call(_this);
                }
                var keys = Object.keys(_this.SDKClients);
                for (var _i = 0, keys_4 = keys; _i < keys_4.length; _i++) {
                    var key = keys_4[_i];
                    _this.SDKClients[key].contextObservers.notify(context);
                }
            });
        };
        /**
         * Mandatory SDK setup call. Must be called once and only once to establish the Extension
         * environment and client ID to use.
         *
         * @since 1.0.0
         * @public
         *
         * @param {Object} options
         *
         * @param {string} options.clientID - The Extension Client ID as provided by Twitch.
         * @since 1.0.4
         *
         * @param {string?} options.uaString - An optional Google Analytics UA_String to send
         * events to.
         * @since 1.0.0
         *
         * @param {boolean?} options.quiet - If true, will not print library information to the
         * console. This is always true when running in production.
         * @since 1.0.3
         *
         * @throws {Error} Will throw an error if setup() has already been called, or if no
         * Extension Client ID is provided.
         *
         * @example
         * Muxy.setup({
         *   clientID: <your extension client id>
         * });
         */
        Muxy.prototype.setup = function (options) {
            if (this.setupCalled) {
                throw new Error('Muxy.setup() can only be called once.');
            }
            if (!options) {
                throw new Error('Muxy.setup() was called with invalid options');
            }
            var clientID = options.clientID || options.extensionID;
            if (!clientID) {
                throw new Error('Muxy.setup() was called without an Extension Client ID');
            }
            if (!this.debugOptions) {
                var noop = function () {
                    var args = [];
                    for (var _i = 0; _i < arguments.length; _i++) {
                        args[_i] = arguments[_i];
                    }
                    /* Default to doing nothing on callback */
                };
                this.debugOptions = {
                    channelID: this.testChannelID,
                    role: this.testJWTRole,
                    onPubsubListen: noop,
                    onPubsubReceive: noop,
                    onPubsubSend: noop
                };
            }
            if (this.debugOptions.environment) {
                Util.overrideEnvironment = Util.Environments[this.debugOptions.environment];
            }
            this.client = new StateClient(this.loadPromise, this.debugOptions);
            this.messenger = DefaultMessenger(this.debugOptions);
            this.twitchClientID = clientID;
            this.cachedTwitchClient = new TwitchClient(this.twitchClientID);
            this.cachedTwitchClient.promise = this.loadPromise;
            if (options.uaString) {
                this.analytics = new Analytics(options.uaString, this.loadPromise);
            }
            if (!options.quiet) {
                Muxy.printInfo();
            }
            this.setupCalled = true;
        };
        /**
         * Setup debugging options for the application. This allows the application to fake
         * what user they are running as, the channel the extension is running on, pubsub debug
         * message frequency, and even the backend URL that the extension uses.
         *
         * This should be called before setup().
         *
         * @param {*} options - an instance of DebuggingOptions
         */
        Muxy.prototype.debug = function (options) {
            this.debugOptions = __assign({ channelID: this.testChannelID, role: this.testJWTRole }, this.debugOptions, options.options);
        };
        /**
         * Returns a twitch client to use. Can only be used after the loaded promise resolves.
         *
         * @since 1.0.0
         * @public
         *
         * @returns {TwitchClient} An instance of the TwitchClient class.
         *
         * @throws {Error} Will throw an error if called before {@link Muxy.setup}.
         */
        Muxy.prototype.TwitchClient = function () {
            /* Implemented below to deal with scoping issues. */
            return undefined;
        };
        return Muxy;
    }());
    /**
     * Global Muxy singleton object.
     * @ignore
     */
    var mxy = new Muxy();
    /** @ignore */
    mxy.TwitchClient = function NewTwitchClient() {
        if (!mxy.setupCalled) {
            throw new Error('Muxy.setup() must be called before creating a new TwitchClient instance');
        }
        return mxy.cachedTwitchClient;
    };
    mxy.DebuggingOptions = DebuggingOptions;
    // Backwards compatibility shim
    // tslint:disable-next-line
    mxy['default'] = mxy;

    return mxy;

})));