new file mode 100644
--- /dev/null
+++ b/strophe.js
@@ -0,0 +1,6101 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["strophe"] = factory();
+	else
+		root["strophe"] = factory();
+})(window, function() {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = "./src/strophe.js");
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ "./node_modules/webpack/buildin/global.js":
+/*!***********************************!*\
+  !*** (webpack)/buildin/global.js ***!
+  \***********************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+var g;
+
+// This works in non-strict mode
+g = (function() {
+	return this;
+})();
+
+try {
+	// This works if eval is allowed (see CSP)
+	g = g || Function("return this")() || (1, eval)("this");
+} catch (e) {
+	// This works if the window reference is available
+	if (typeof window === "object") g = window;
+}
+
+// g can still be undefined, but nothing to do about it...
+// We return undefined, instead of nothing here, so it's
+// easier to handle this case. if(!global) { ...}
+
+module.exports = g;
+
+
+/***/ }),
+
+/***/ "./src/bosh.js":
+/*!*********************!*\
+  !*** ./src/bosh.js ***!
+  \*********************/
+/*! no exports provided */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core */ "./src/core.js");
+/*
+    This program is distributed under the terms of the MIT license.
+    Please see the LICENSE file for details.
+
+    Copyright 2006-2008, OGG, LLC
+*/
+
+/* global window, setTimeout, clearTimeout, XMLHttpRequest, ActiveXObject */
+
+var Strophe = core__WEBPACK_IMPORTED_MODULE_0__["default"].Strophe;
+var $build = core__WEBPACK_IMPORTED_MODULE_0__["default"].$build;
+/** PrivateClass: Strophe.Request
+ *  _Private_ helper class that provides a cross implementation abstraction
+ *  for a BOSH related XMLHttpRequest.
+ *
+ *  The Strophe.Request class is used internally to encapsulate BOSH request
+ *  information.  It is not meant to be used from user's code.
+ */
+
+/** PrivateConstructor: Strophe.Request
+ *  Create and initialize a new Strophe.Request object.
+ *
+ *  Parameters:
+ *    (XMLElement) elem - The XML data to be sent in the request.
+ *    (Function) func - The function that will be called when the
+ *      XMLHttpRequest readyState changes.
+ *    (Integer) rid - The BOSH rid attribute associated with this request.
+ *    (Integer) sends - The number of times this same request has been sent.
+ */
+
+Strophe.Request = function (elem, func, rid, sends) {
+  this.id = ++Strophe._requestId;
+  this.xmlData = elem;
+  this.data = Strophe.serialize(elem); // save original function in case we need to make a new request
+  // from this one.
+
+  this.origFunc = func;
+  this.func = func;
+  this.rid = rid;
+  this.date = NaN;
+  this.sends = sends || 0;
+  this.abort = false;
+  this.dead = null;
+
+  this.age = function () {
+    if (!this.date) {
+      return 0;
+    }
+
+    var now = new Date();
+    return (now - this.date) / 1000;
+  };
+
+  this.timeDead = function () {
+    if (!this.dead) {
+      return 0;
+    }
+
+    var now = new Date();
+    return (now - this.dead) / 1000;
+  };
+
+  this.xhr = this._newXHR();
+};
+
+Strophe.Request.prototype = {
+  /** PrivateFunction: getResponse
+   *  Get a response from the underlying XMLHttpRequest.
+   *
+   *  This function attempts to get a response from the request and checks
+   *  for errors.
+   *
+   *  Throws:
+   *    "parsererror" - A parser error occured.
+   *    "bad-format" - The entity has sent XML that cannot be processed.
+   *
+   *  Returns:
+   *    The DOM element tree of the response.
+   */
+  getResponse: function getResponse() {
+    var node = null;
+
+    if (this.xhr.responseXML && this.xhr.responseXML.documentElement) {
+      node = this.xhr.responseXML.documentElement;
+
+      if (node.tagName === "parsererror") {
+        Strophe.error("invalid response received");
+        Strophe.error("responseText: " + this.xhr.responseText);
+        Strophe.error("responseXML: " + Strophe.serialize(this.xhr.responseXML));
+        throw new Error("parsererror");
+      }
+    } else if (this.xhr.responseText) {
+      // In React Native, we may get responseText but no responseXML.  We can try to parse it manually.
+      Strophe.debug("Got responseText but no responseXML; attempting to parse it with DOMParser...");
+      node = new DOMParser().parseFromString(this.xhr.responseText, 'application/xml').documentElement;
+
+      if (!node) {
+        throw new Error('Parsing produced null node');
+      } else if (node.querySelector('parsererror')) {
+        Strophe.error("invalid response received: " + node.querySelector('parsererror').textContent);
+        Strophe.error("responseText: " + this.xhr.responseText);
+        var error = new Error();
+        error.name = Strophe.ErrorCondition.BAD_FORMAT;
+        throw error;
+      }
+    }
+
+    return node;
+  },
+
+  /** PrivateFunction: _newXHR
+   *  _Private_ helper function to create XMLHttpRequests.
+   *
+   *  This function creates XMLHttpRequests across all implementations.
+   *
+   *  Returns:
+   *    A new XMLHttpRequest.
+   */
+  _newXHR: function _newXHR() {
+    var xhr = null;
+
+    if (window.XMLHttpRequest) {
+      xhr = new XMLHttpRequest();
+
+      if (xhr.overrideMimeType) {
+        xhr.overrideMimeType("text/xml; charset=utf-8");
+      }
+    } else if (window.ActiveXObject) {
+      xhr = new ActiveXObject("Microsoft.XMLHTTP");
+    } // use Function.bind() to prepend ourselves as an argument
+
+
+    xhr.onreadystatechange = this.func.bind(null, this);
+    return xhr;
+  }
+};
+/** Class: Strophe.Bosh
+ *  _Private_ helper class that handles BOSH Connections
+ *
+ *  The Strophe.Bosh class is used internally by Strophe.Connection
+ *  to encapsulate BOSH sessions. It is not meant to be used from user's code.
+ */
+
+/** File: bosh.js
+ *  A JavaScript library to enable BOSH in Strophejs.
+ *
+ *  this library uses Bidirectional-streams Over Synchronous HTTP (BOSH)
+ *  to emulate a persistent, stateful, two-way connection to an XMPP server.
+ *  More information on BOSH can be found in XEP 124.
+ */
+
+/** PrivateConstructor: Strophe.Bosh
+ *  Create and initialize a Strophe.Bosh object.
+ *
+ *  Parameters:
+ *    (Strophe.Connection) connection - The Strophe.Connection that will use BOSH.
+ *
+ *  Returns:
+ *    A new Strophe.Bosh object.
+ */
+
+Strophe.Bosh = function (connection) {
+  this._conn = connection;
+  /* request id for body tags */
+
+  this.rid = Math.floor(Math.random() * 4294967295);
+  /* The current session ID. */
+
+  this.sid = null; // default BOSH values
+
+  this.hold = 1;
+  this.wait = 60;
+  this.window = 5;
+  this.errors = 0;
+  this.inactivity = null;
+  this.lastResponseHeaders = null;
+  this._requests = [];
+};
+
+Strophe.Bosh.prototype = {
+  /** Variable: strip
+   *
+   *  BOSH-Connections will have all stanzas wrapped in a <body> tag when
+   *  passed to <Strophe.Connection.xmlInput> or <Strophe.Connection.xmlOutput>.
+   *  To strip this tag, User code can set <Strophe.Bosh.strip> to "body":
+   *
+   *  > Strophe.Bosh.prototype.strip = "body";
+   *
+   *  This will enable stripping of the body tag in both
+   *  <Strophe.Connection.xmlInput> and <Strophe.Connection.xmlOutput>.
+   */
+  strip: null,
+
+  /** PrivateFunction: _buildBody
+   *  _Private_ helper function to generate the <body/> wrapper for BOSH.
+   *
+   *  Returns:
+   *    A Strophe.Builder with a <body/> element.
+   */
+  _buildBody: function _buildBody() {
+    var bodyWrap = $build('body', {
+      'rid': this.rid++,
+      'xmlns': Strophe.NS.HTTPBIND
+    });
+
+    if (this.sid !== null) {
+      bodyWrap.attrs({
+        'sid': this.sid
+      });
+    }
+
+    if (this._conn.options.keepalive && this._conn._sessionCachingSupported()) {
+      this._cacheSession();
+    }
+
+    return bodyWrap;
+  },
+
+  /** PrivateFunction: _reset
+   *  Reset the connection.
+   *
+   *  This function is called by the reset function of the Strophe Connection
+   */
+  _reset: function _reset() {
+    this.rid = Math.floor(Math.random() * 4294967295);
+    this.sid = null;
+    this.errors = 0;
+
+    if (this._conn._sessionCachingSupported()) {
+      window.sessionStorage.removeItem('strophe-bosh-session');
+    }
+
+    this._conn.nextValidRid(this.rid);
+  },
+
+  /** PrivateFunction: _connect
+   *  _Private_ function that initializes the BOSH connection.
+   *
+   *  Creates and sends the Request that initializes the BOSH connection.
+   */
+  _connect: function _connect(wait, hold, route) {
+    this.wait = wait || this.wait;
+    this.hold = hold || this.hold;
+    this.errors = 0;
+
+    var body = this._buildBody().attrs({
+      "to": this._conn.domain,
+      "xml:lang": "en",
+      "wait": this.wait,
+      "hold": this.hold,
+      "content": "text/xml; charset=utf-8",
+      "ver": "1.6",
+      "xmpp:version": "1.0",
+      "xmlns:xmpp": Strophe.NS.BOSH
+    });
+
+    if (route) {
+      body.attrs({
+        'route': route
+      });
+    }
+
+    var _connect_cb = this._conn._connect_cb;
+
+    this._requests.push(new Strophe.Request(body.tree(), this._onRequestStateChange.bind(this, _connect_cb.bind(this._conn)), body.tree().getAttribute("rid")));
+
+    this._throttledRequestHandler();
+  },
+
+  /** PrivateFunction: _attach
+   *  Attach to an already created and authenticated BOSH session.
+   *
+   *  This function is provided to allow Strophe to attach to BOSH
+   *  sessions which have been created externally, perhaps by a Web
+   *  application.  This is often used to support auto-login type features
+   *  without putting user credentials into the page.
+   *
+   *  Parameters:
+   *    (String) jid - The full JID that is bound by the session.
+   *    (String) sid - The SID of the BOSH session.
+   *    (String) rid - The current RID of the BOSH session.  This RID
+   *      will be used by the next request.
+   *    (Function) callback The connect callback function.
+   *    (Integer) wait - The optional HTTPBIND wait value.  This is the
+   *      time the server will wait before returning an empty result for
+   *      a request.  The default setting of 60 seconds is recommended.
+   *      Other settings will require tweaks to the Strophe.TIMEOUT value.
+   *    (Integer) hold - The optional HTTPBIND hold value.  This is the
+   *      number of connections the server will hold at one time.  This
+   *      should almost always be set to 1 (the default).
+   *    (Integer) wind - The optional HTTBIND window value.  This is the
+   *      allowed range of request ids that are valid.  The default is 5.
+   */
+  _attach: function _attach(jid, sid, rid, callback, wait, hold, wind) {
+    this._conn.jid = jid;
+    this.sid = sid;
+    this.rid = rid;
+    this._conn.connect_callback = callback;
+    this._conn.domain = Strophe.getDomainFromJid(this._conn.jid);
+    this._conn.authenticated = true;
+    this._conn.connected = true;
+    this.wait = wait || this.wait;
+    this.hold = hold || this.hold;
+    this.window = wind || this.window;
+
+    this._conn._changeConnectStatus(Strophe.Status.ATTACHED, null);
+  },
+
+  /** PrivateFunction: _restore
+   *  Attempt to restore a cached BOSH session
+   *
+   *  Parameters:
+   *    (String) jid - The full JID that is bound by the session.
+   *      This parameter is optional but recommended, specifically in cases
+   *      where prebinded BOSH sessions are used where it's important to know
+   *      that the right session is being restored.
+   *    (Function) callback The connect callback function.
+   *    (Integer) wait - The optional HTTPBIND wait value.  This is the
+   *      time the server will wait before returning an empty result for
+   *      a request.  The default setting of 60 seconds is recommended.
+   *      Other settings will require tweaks to the Strophe.TIMEOUT value.
+   *    (Integer) hold - The optional HTTPBIND hold value.  This is the
+   *      number of connections the server will hold at one time.  This
+   *      should almost always be set to 1 (the default).
+   *    (Integer) wind - The optional HTTBIND window value.  This is the
+   *      allowed range of request ids that are valid.  The default is 5.
+   */
+  _restore: function _restore(jid, callback, wait, hold, wind) {
+    var session = JSON.parse(window.sessionStorage.getItem('strophe-bosh-session'));
+
+    if (typeof session !== "undefined" && session !== null && session.rid && session.sid && session.jid && (typeof jid === "undefined" || jid === null || Strophe.getBareJidFromJid(session.jid) === Strophe.getBareJidFromJid(jid) || // If authcid is null, then it's an anonymous login, so
+    // we compare only the domains:
+    Strophe.getNodeFromJid(jid) === null && Strophe.getDomainFromJid(session.jid) === jid)) {
+      this._conn.restored = true;
+
+      this._attach(session.jid, session.sid, session.rid, callback, wait, hold, wind);
+    } else {
+      var error = new Error("_restore: no restoreable session.");
+      error.name = "StropheSessionError";
+      throw error;
+    }
+  },
+
+  /** PrivateFunction: _cacheSession
+   *  _Private_ handler for the beforeunload event.
+   *
+   *  This handler is used to process the Bosh-part of the initial request.
+   *  Parameters:
+   *    (Strophe.Request) bodyWrap - The received stanza.
+   */
+  _cacheSession: function _cacheSession() {
+    if (this._conn.authenticated) {
+      if (this._conn.jid && this.rid && this.sid) {
+        window.sessionStorage.setItem('strophe-bosh-session', JSON.stringify({
+          'jid': this._conn.jid,
+          'rid': this.rid,
+          'sid': this.sid
+        }));
+      }
+    } else {
+      window.sessionStorage.removeItem('strophe-bosh-session');
+    }
+  },
+
+  /** PrivateFunction: _connect_cb
+   *  _Private_ handler for initial connection request.
+   *
+   *  This handler is used to process the Bosh-part of the initial request.
+   *  Parameters:
+   *    (Strophe.Request) bodyWrap - The received stanza.
+   */
+  _connect_cb: function _connect_cb(bodyWrap) {
+    var typ = bodyWrap.getAttribute("type");
+
+    if (typ !== null && typ === "terminate") {
+      // an error occurred
+      var cond = bodyWrap.getAttribute("condition");
+      Strophe.error("BOSH-Connection failed: " + cond);
+      var conflict = bodyWrap.getElementsByTagName("conflict");
+
+      if (cond !== null) {
+        if (cond === "remote-stream-error" && conflict.length > 0) {
+          cond = "conflict";
+        }
+
+        this._conn._changeConnectStatus(Strophe.Status.CONNFAIL, cond);
+      } else {
+        this._conn._changeConnectStatus(Strophe.Status.CONNFAIL, "unknown");
+      }
+
+      this._conn._doDisconnect(cond);
+
+      return Strophe.Status.CONNFAIL;
+    } // check to make sure we don't overwrite these if _connect_cb is
+    // called multiple times in the case of missing stream:features
+
+
+    if (!this.sid) {
+      this.sid = bodyWrap.getAttribute("sid");
+    }
+
+    var wind = bodyWrap.getAttribute('requests');
+
+    if (wind) {
+      this.window = parseInt(wind, 10);
+    }
+
+    var hold = bodyWrap.getAttribute('hold');
+
+    if (hold) {
+      this.hold = parseInt(hold, 10);
+    }
+
+    var wait = bodyWrap.getAttribute('wait');
+
+    if (wait) {
+      this.wait = parseInt(wait, 10);
+    }
+
+    var inactivity = bodyWrap.getAttribute('inactivity');
+
+    if (inactivity) {
+      this.inactivity = parseInt(inactivity, 10);
+    }
+  },
+
+  /** PrivateFunction: _disconnect
+   *  _Private_ part of Connection.disconnect for Bosh
+   *
+   *  Parameters:
+   *    (Request) pres - This stanza will be sent before disconnecting.
+   */
+  _disconnect: function _disconnect(pres) {
+    this._sendTerminate(pres);
+  },
+
+  /** PrivateFunction: _doDisconnect
+   *  _Private_ function to disconnect.
+   *
+   *  Resets the SID and RID.
+   */
+  _doDisconnect: function _doDisconnect() {
+    this.sid = null;
+    this.rid = Math.floor(Math.random() * 4294967295);
+
+    if (this._conn._sessionCachingSupported()) {
+      window.sessionStorage.removeItem('strophe-bosh-session');
+    }
+
+    this._conn.nextValidRid(this.rid);
+  },
+
+  /** PrivateFunction: _emptyQueue
+   * _Private_ function to check if the Request queue is empty.
+   *
+   *  Returns:
+   *    True, if there are no Requests queued, False otherwise.
+   */
+  _emptyQueue: function _emptyQueue() {
+    return this._requests.length === 0;
+  },
+
+  /** PrivateFunction: _callProtocolErrorHandlers
+   *  _Private_ function to call error handlers registered for HTTP errors.
+   *
+   *  Parameters:
+   *    (Strophe.Request) req - The request that is changing readyState.
+   */
+  _callProtocolErrorHandlers: function _callProtocolErrorHandlers(req) {
+    var reqStatus = this._getRequestStatus(req);
+
+    var err_callback = this._conn.protocolErrorHandlers.HTTP[reqStatus];
+
+    if (err_callback) {
+      err_callback.call(this, reqStatus);
+    }
+  },
+
+  /** PrivateFunction: _hitError
+   *  _Private_ function to handle the error count.
+   *
+   *  Requests are resent automatically until their error count reaches
+   *  5.  Each time an error is encountered, this function is called to
+   *  increment the count and disconnect if the count is too high.
+   *
+   *  Parameters:
+   *    (Integer) reqStatus - The request status.
+   */
+  _hitError: function _hitError(reqStatus) {
+    this.errors++;
+    Strophe.warn("request errored, status: " + reqStatus + ", number of errors: " + this.errors);
+
+    if (this.errors > 4) {
+      this._conn._onDisconnectTimeout();
+    }
+  },
+
+  /** PrivateFunction: _no_auth_received
+   *
+   * Called on stream start/restart when no stream:features
+   * has been received and sends a blank poll request.
+   */
+  _no_auth_received: function _no_auth_received(callback) {
+    Strophe.warn("Server did not yet offer a supported authentication " + "mechanism. Sending a blank poll request.");
+
+    if (callback) {
+      callback = callback.bind(this._conn);
+    } else {
+      callback = this._conn._connect_cb.bind(this._conn);
+    }
+
+    var body = this._buildBody();
+
+    this._requests.push(new Strophe.Request(body.tree(), this._onRequestStateChange.bind(this, callback), body.tree().getAttribute("rid")));
+
+    this._throttledRequestHandler();
+  },
+
+  /** PrivateFunction: _onDisconnectTimeout
+   *  _Private_ timeout handler for handling non-graceful disconnection.
+   *
+   *  Cancels all remaining Requests and clears the queue.
+   */
+  _onDisconnectTimeout: function _onDisconnectTimeout() {
+    this._abortAllRequests();
+  },
+
+  /** PrivateFunction: _abortAllRequests
+   *  _Private_ helper function that makes sure all pending requests are aborted.
+   */
+  _abortAllRequests: function _abortAllRequests() {
+    while (this._requests.length > 0) {
+      var req = this._requests.pop();
+
+      req.abort = true;
+      req.xhr.abort(); // jslint complains, but this is fine. setting to empty func
+      // is necessary for IE6
+
+      req.xhr.onreadystatechange = function () {}; // jshint ignore:line
+
+    }
+  },
+
+  /** PrivateFunction: _onIdle
+   *  _Private_ handler called by Strophe.Connection._onIdle
+   *
+   *  Sends all queued Requests or polls with empty Request if there are none.
+   */
+  _onIdle: function _onIdle() {
+    var data = this._conn._data; // if no requests are in progress, poll
+
+    if (this._conn.authenticated && this._requests.length === 0 && data.length === 0 && !this._conn.disconnecting) {
+      Strophe.info("no requests during idle cycle, sending " + "blank request");
+      data.push(null);
+    }
+
+    if (this._conn.paused) {
+      return;
+    }
+
+    if (this._requests.length < 2 && data.length > 0) {
+      var body = this._buildBody();
+
+      for (var i = 0; i < data.length; i++) {
+        if (data[i] !== null) {
+          if (data[i] === "restart") {
+            body.attrs({
+              "to": this._conn.domain,
+              "xml:lang": "en",
+              "xmpp:restart": "true",
+              "xmlns:xmpp": Strophe.NS.BOSH
+            });
+          } else {
+            body.cnode(data[i]).up();
+          }
+        }
+      }
+
+      delete this._conn._data;
+      this._conn._data = [];
+
+      this._requests.push(new Strophe.Request(body.tree(), this._onRequestStateChange.bind(this, this._conn._dataRecv.bind(this._conn)), body.tree().getAttribute("rid")));
+
+      this._throttledRequestHandler();
+    }
+
+    if (this._requests.length > 0) {
+      var time_elapsed = this._requests[0].age();
+
+      if (this._requests[0].dead !== null) {
+        if (this._requests[0].timeDead() > Math.floor(Strophe.SECONDARY_TIMEOUT * this.wait)) {
+          this._throttledRequestHandler();
+        }
+      }
+
+      if (time_elapsed > Math.floor(Strophe.TIMEOUT * this.wait)) {
+        Strophe.warn("Request " + this._requests[0].id + " timed out, over " + Math.floor(Strophe.TIMEOUT * this.wait) + " seconds since last activity");
+
+        this._throttledRequestHandler();
+      }
+    }
+  },
+
+  /** PrivateFunction: _getRequestStatus
+   *
+   *  Returns the HTTP status code from a Strophe.Request
+   *
+   *  Parameters:
+   *    (Strophe.Request) req - The Strophe.Request instance.
+   *    (Integer) def - The default value that should be returned if no
+   *          status value was found.
+   */
+  _getRequestStatus: function _getRequestStatus(req, def) {
+    var reqStatus;
+
+    if (req.xhr.readyState === 4) {
+      try {
+        reqStatus = req.xhr.status;
+      } catch (e) {
+        // ignore errors from undefined status attribute. Works
+        // around a browser bug
+        Strophe.error("Caught an error while retrieving a request's status, " + "reqStatus: " + reqStatus);
+      }
+    }
+
+    if (typeof reqStatus === "undefined") {
+      reqStatus = typeof def === 'number' ? def : 0;
+    }
+
+    return reqStatus;
+  },
+
+  /** PrivateFunction: _onRequestStateChange
+   *  _Private_ handler for Strophe.Request state changes.
+   *
+   *  This function is called when the XMLHttpRequest readyState changes.
+   *  It contains a lot of error handling logic for the many ways that
+   *  requests can fail, and calls the request callback when requests
+   *  succeed.
+   *
+   *  Parameters:
+   *    (Function) func - The handler for the request.
+   *    (Strophe.Request) req - The request that is changing readyState.
+   */
+  _onRequestStateChange: function _onRequestStateChange(func, req) {
+    Strophe.debug("request id " + req.id + "." + req.sends + " state changed to " + req.xhr.readyState);
+
+    if (req.abort) {
+      req.abort = false;
+      return;
+    }
+
+    if (req.xhr.readyState !== 4) {
+      // The request is not yet complete
+      return;
+    }
+
+    var reqStatus = this._getRequestStatus(req);
+
+    this.lastResponseHeaders = req.xhr.getAllResponseHeaders();
+
+    if (this.disconnecting && reqStatus >= 400) {
+      this._hitError(reqStatus);
+
+      this._callProtocolErrorHandlers(req);
+
+      return;
+    }
+
+    var valid_request = reqStatus > 0 && reqStatus < 500;
+    var too_many_retries = req.sends > this._conn.maxRetries;
+
+    if (valid_request || too_many_retries) {
+      // remove from internal queue
+      this._removeRequest(req);
+
+      Strophe.debug("request id " + req.id + " should now be removed");
+    }
+
+    if (reqStatus === 200) {
+      // request succeeded
+      var reqIs0 = this._requests[0] === req;
+      var reqIs1 = this._requests[1] === req; // if request 1 finished, or request 0 finished and request
+      // 1 is over Strophe.SECONDARY_TIMEOUT seconds old, we need to
+      // restart the other - both will be in the first spot, as the
+      // completed request has been removed from the queue already
+
+      if (reqIs1 || reqIs0 && this._requests.length > 0 && this._requests[0].age() > Math.floor(Strophe.SECONDARY_TIMEOUT * this.wait)) {
+        this._restartRequest(0);
+      }
+
+      this._conn.nextValidRid(Number(req.rid) + 1);
+
+      Strophe.debug("request id " + req.id + "." + req.sends + " got 200");
+      func(req); // call handler
+
+      this.errors = 0;
+    } else if (reqStatus === 0 || reqStatus >= 400 && reqStatus < 600 || reqStatus >= 12000) {
+      // request failed
+      Strophe.error("request id " + req.id + "." + req.sends + " error " + reqStatus + " happened");
+
+      this._hitError(reqStatus);
+
+      this._callProtocolErrorHandlers(req);
+
+      if (reqStatus >= 400 && reqStatus < 500) {
+        this._conn._changeConnectStatus(Strophe.Status.DISCONNECTING, null);
+
+        this._conn._doDisconnect();
+      }
+    } else {
+      Strophe.error("request id " + req.id + "." + req.sends + " error " + reqStatus + " happened");
+    }
+
+    if (!valid_request && !too_many_retries) {
+      this._throttledRequestHandler();
+    } else if (too_many_retries && !this._conn.connected) {
+      this._conn._changeConnectStatus(Strophe.Status.CONNFAIL, "giving-up");
+    }
+  },
+
+  /** PrivateFunction: _processRequest
+   *  _Private_ function to process a request in the queue.
+   *
+   *  This function takes requests off the queue and sends them and
+   *  restarts dead requests.
+   *
+   *  Parameters:
+   *    (Integer) i - The index of the request in the queue.
+   */
+  _processRequest: function _processRequest(i) {
+    var _this = this;
+
+    var req = this._requests[i];
+
+    var reqStatus = this._getRequestStatus(req, -1); // make sure we limit the number of retries
+
+
+    if (req.sends > this._conn.maxRetries) {
+      this._conn._onDisconnectTimeout();
+
+      return;
+    }
+
+    var time_elapsed = req.age();
+    var primary_timeout = !isNaN(time_elapsed) && time_elapsed > Math.floor(Strophe.TIMEOUT * this.wait);
+    var secondary_timeout = req.dead !== null && req.timeDead() > Math.floor(Strophe.SECONDARY_TIMEOUT * this.wait);
+    var server_error = req.xhr.readyState === 4 && (reqStatus < 1 || reqStatus >= 500);
+
+    if (primary_timeout || secondary_timeout || server_error) {
+      if (secondary_timeout) {
+        Strophe.error("Request ".concat(this._requests[i].id, " timed out (secondary), restarting"));
+      }
+
+      req.abort = true;
+      req.xhr.abort(); // setting to null fails on IE6, so set to empty function
+
+      req.xhr.onreadystatechange = function () {};
+
+      this._requests[i] = new Strophe.Request(req.xmlData, req.origFunc, req.rid, req.sends);
+      req = this._requests[i];
+    }
+
+    if (req.xhr.readyState === 0) {
+      Strophe.debug("request id " + req.id + "." + req.sends + " posting");
+
+      try {
+        var content_type = this._conn.options.contentType || "text/xml; charset=utf-8";
+        req.xhr.open("POST", this._conn.service, this._conn.options.sync ? false : true);
+
+        if (typeof req.xhr.setRequestHeader !== 'undefined') {
+          // IE9 doesn't have setRequestHeader
+          req.xhr.setRequestHeader("Content-Type", content_type);
+        }
+
+        if (this._conn.options.withCredentials) {
+          req.xhr.withCredentials = true;
+        }
+      } catch (e2) {
+        Strophe.error("XHR open failed: " + e2.toString());
+
+        if (!this._conn.connected) {
+          this._conn._changeConnectStatus(Strophe.Status.CONNFAIL, "bad-service");
+        }
+
+        this._conn.disconnect();
+
+        return;
+      } // Fires the XHR request -- may be invoked immediately
+      // or on a gradually expanding retry window for reconnects
+
+
+      var sendFunc = function sendFunc() {
+        req.date = new Date();
+
+        if (_this._conn.options.customHeaders) {
+          var headers = _this._conn.options.customHeaders;
+
+          for (var header in headers) {
+            if (Object.prototype.hasOwnProperty.call(headers, header)) {
+              req.xhr.setRequestHeader(header, headers[header]);
+            }
+          }
+        }
+
+        req.xhr.send(req.data);
+      }; // Implement progressive backoff for reconnects --
+      // First retry (send === 1) should also be instantaneous
+
+
+      if (req.sends > 1) {
+        // Using a cube of the retry number creates a nicely
+        // expanding retry window
+        var backoff = Math.min(Math.floor(Strophe.TIMEOUT * this.wait), Math.pow(req.sends, 3)) * 1000;
+        setTimeout(function () {
+          // XXX: setTimeout should be called only with function expressions (23974bc1)
+          sendFunc();
+        }, backoff);
+      } else {
+        sendFunc();
+      }
+
+      req.sends++;
+
+      if (this._conn.xmlOutput !== Strophe.Connection.prototype.xmlOutput) {
+        if (req.xmlData.nodeName === this.strip && req.xmlData.childNodes.length) {
+          this._conn.xmlOutput(req.xmlData.childNodes[0]);
+        } else {
+          this._conn.xmlOutput(req.xmlData);
+        }
+      }
+
+      if (this._conn.rawOutput !== Strophe.Connection.prototype.rawOutput) {
+        this._conn.rawOutput(req.data);
+      }
+    } else {
+      Strophe.debug("_processRequest: " + (i === 0 ? "first" : "second") + " request has readyState of " + req.xhr.readyState);
+    }
+  },
+
+  /** PrivateFunction: _removeRequest
+   *  _Private_ function to remove a request from the queue.
+   *
+   *  Parameters:
+   *    (Strophe.Request) req - The request to remove.
+   */
+  _removeRequest: function _removeRequest(req) {
+    Strophe.debug("removing request");
+
+    for (var i = this._requests.length - 1; i >= 0; i--) {
+      if (req === this._requests[i]) {
+        this._requests.splice(i, 1);
+      }
+    } // IE6 fails on setting to null, so set to empty function
+
+
+    req.xhr.onreadystatechange = function () {};
+
+    this._throttledRequestHandler();
+  },
+
+  /** PrivateFunction: _restartRequest
+   *  _Private_ function to restart a request that is presumed dead.
+   *
+   *  Parameters:
+   *    (Integer) i - The index of the request in the queue.
+   */
+  _restartRequest: function _restartRequest(i) {
+    var req = this._requests[i];
+
+    if (req.dead === null) {
+      req.dead = new Date();
+    }
+
+    this._processRequest(i);
+  },
+
+  /** PrivateFunction: _reqToData
+   * _Private_ function to get a stanza out of a request.
+   *
+   * Tries to extract a stanza out of a Request Object.
+   * When this fails the current connection will be disconnected.
+   *
+   *  Parameters:
+   *    (Object) req - The Request.
+   *
+   *  Returns:
+   *    The stanza that was passed.
+   */
+  _reqToData: function _reqToData(req) {
+    try {
+      return req.getResponse();
+    } catch (e) {
+      if (e.message !== "parsererror") {
+        throw e;
+      }
+
+      this._conn.disconnect("strophe-parsererror");
+    }
+  },
+
+  /** PrivateFunction: _sendTerminate
+   *  _Private_ function to send initial disconnect sequence.
+   *
+   *  This is the first step in a graceful disconnect.  It sends
+   *  the BOSH server a terminate body and includes an unavailable
+   *  presence if authentication has completed.
+   */
+  _sendTerminate: function _sendTerminate(pres) {
+    Strophe.info("_sendTerminate was called");
+
+    var body = this._buildBody().attrs({
+      type: "terminate"
+    });
+
+    if (pres) {
+      body.cnode(pres.tree());
+    }
+
+    var req = new Strophe.Request(body.tree(), this._onRequestStateChange.bind(this, this._conn._dataRecv.bind(this._conn)), body.tree().getAttribute("rid"));
+
+    this._requests.push(req);
+
+    this._throttledRequestHandler();
+  },
+
+  /** PrivateFunction: _send
+   *  _Private_ part of the Connection.send function for BOSH
+   *
+   * Just triggers the RequestHandler to send the messages that are in the queue
+   */
+  _send: function _send() {
+    var _this2 = this;
+
+    clearTimeout(this._conn._idleTimeout);
+
+    this._throttledRequestHandler();
+
+    this._conn._idleTimeout = setTimeout(function () {
+      return _this2._conn._onIdle();
+    }, 100);
+  },
+
+  /** PrivateFunction: _sendRestart
+   *
+   *  Send an xmpp:restart stanza.
+   */
+  _sendRestart: function _sendRestart() {
+    this._throttledRequestHandler();
+
+    clearTimeout(this._conn._idleTimeout);
+  },
+
+  /** PrivateFunction: _throttledRequestHandler
+   *  _Private_ function to throttle requests to the connection window.
+   *
+   *  This function makes sure we don't send requests so fast that the
+   *  request ids overflow the connection window in the case that one
+   *  request died.
+   */
+  _throttledRequestHandler: function _throttledRequestHandler() {
+    if (!this._requests) {
+      Strophe.debug("_throttledRequestHandler called with " + "undefined requests");
+    } else {
+      Strophe.debug("_throttledRequestHandler called with " + this._requests.length + " requests");
+    }
+
+    if (!this._requests || this._requests.length === 0) {
+      return;
+    }
+
+    if (this._requests.length > 0) {
+      this._processRequest(0);
+    }
+
+    if (this._requests.length > 1 && Math.abs(this._requests[0].rid - this._requests[1].rid) < this.window) {
+      this._processRequest(1);
+    }
+  }
+};
+
+/***/ }),
+
+/***/ "./src/core.js":
+/*!*********************!*\
+  !*** ./src/core.js ***!
+  \*********************/
+/*! exports provided: Strophe, $build, $iq, $msg, $pres, SHA1, MD5, default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Strophe", function() { return Strophe; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "$build", function() { return $build; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "$iq", function() { return $iq; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "$msg", function() { return $msg; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "$pres", function() { return $pres; });
+/* harmony import */ var md5__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! md5 */ "./src/md5.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "MD5", function() { return md5__WEBPACK_IMPORTED_MODULE_0__["default"]; });
+
+/* harmony import */ var sha1__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! sha1 */ "./src/sha1.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "SHA1", function() { return sha1__WEBPACK_IMPORTED_MODULE_1__["default"]; });
+
+/* harmony import */ var utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! utils */ "./src/utils.js");
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+/*
+    This program is distributed under the terms of the MIT license.
+    Please see the LICENSE file for details.
+
+    Copyright 2006-2018, OGG, LLC
+*/
+
+/*global define, document, sessionStorage, setTimeout, clearTimeout, ActiveXObject, DOMParser, btoa, atob, module */
+
+
+
+/** Function: $build
+ *  Create a Strophe.Builder.
+ *  This is an alias for 'new Strophe.Builder(name, attrs)'.
+ *
+ *  Parameters:
+ *    (String) name - The root element name.
+ *    (Object) attrs - The attributes for the root element in object notation.
+ *
+ *  Returns:
+ *    A new Strophe.Builder object.
+ */
+
+function $build(name, attrs) {
+  return new Strophe.Builder(name, attrs);
+}
+/** Function: $msg
+ *  Create a Strophe.Builder with a <message/> element as the root.
+ *
+ *  Parameters:
+ *    (Object) attrs - The <message/> element attributes in object notation.
+ *
+ *  Returns:
+ *    A new Strophe.Builder object.
+ */
+
+
+function $msg(attrs) {
+  return new Strophe.Builder("message", attrs);
+}
+/** Function: $iq
+ *  Create a Strophe.Builder with an <iq/> element as the root.
+ *
+ *  Parameters:
+ *    (Object) attrs - The <iq/> element attributes in object notation.
+ *
+ *  Returns:
+ *    A new Strophe.Builder object.
+ */
+
+
+function $iq(attrs) {
+  return new Strophe.Builder("iq", attrs);
+}
+/** Function: $pres
+ *  Create a Strophe.Builder with a <presence/> element as the root.
+ *
+ *  Parameters:
+ *    (Object) attrs - The <presence/> element attributes in object notation.
+ *
+ *  Returns:
+ *    A new Strophe.Builder object.
+ */
+
+
+function $pres(attrs) {
+  return new Strophe.Builder("presence", attrs);
+}
+/** Class: Strophe
+ *  An object container for all Strophe library functions.
+ *
+ *  This class is just a container for all the objects and constants
+ *  used in the library.  It is not meant to be instantiated, but to
+ *  provide a namespace for library objects, constants, and functions.
+ */
+
+
+var Strophe = {
+  /** Constant: VERSION */
+  VERSION: "1.3.1",
+
+  /** Constants: XMPP Namespace Constants
+   *  Common namespace constants from the XMPP RFCs and XEPs.
+   *
+   *  NS.HTTPBIND - HTTP BIND namespace from XEP 124.
+   *  NS.BOSH - BOSH namespace from XEP 206.
+   *  NS.CLIENT - Main XMPP client namespace.
+   *  NS.AUTH - Legacy authentication namespace.
+   *  NS.ROSTER - Roster operations namespace.
+   *  NS.PROFILE - Profile namespace.
+   *  NS.DISCO_INFO - Service discovery info namespace from XEP 30.
+   *  NS.DISCO_ITEMS - Service discovery items namespace from XEP 30.
+   *  NS.MUC - Multi-User Chat namespace from XEP 45.
+   *  NS.SASL - XMPP SASL namespace from RFC 3920.
+   *  NS.STREAM - XMPP Streams namespace from RFC 3920.
+   *  NS.BIND - XMPP Binding namespace from RFC 3920.
+   *  NS.SESSION - XMPP Session namespace from RFC 3920.
+   *  NS.XHTML_IM - XHTML-IM namespace from XEP 71.
+   *  NS.XHTML - XHTML body namespace from XEP 71.
+   */
+  NS: {
+    HTTPBIND: "http://jabber.org/protocol/httpbind",
+    BOSH: "urn:xmpp:xbosh",
+    CLIENT: "jabber:client",
+    AUTH: "jabber:iq:auth",
+    ROSTER: "jabber:iq:roster",
+    PROFILE: "jabber:iq:profile",
+    DISCO_INFO: "http://jabber.org/protocol/disco#info",
+    DISCO_ITEMS: "http://jabber.org/protocol/disco#items",
+    MUC: "http://jabber.org/protocol/muc",
+    SASL: "urn:ietf:params:xml:ns:xmpp-sasl",
+    STREAM: "http://etherx.jabber.org/streams",
+    FRAMING: "urn:ietf:params:xml:ns:xmpp-framing",
+    BIND: "urn:ietf:params:xml:ns:xmpp-bind",
+    SESSION: "urn:ietf:params:xml:ns:xmpp-session",
+    VERSION: "jabber:iq:version",
+    STANZAS: "urn:ietf:params:xml:ns:xmpp-stanzas",
+    XHTML_IM: "http://jabber.org/protocol/xhtml-im",
+    XHTML: "http://www.w3.org/1999/xhtml"
+  },
+
+  /** Constants: XHTML_IM Namespace
+   *  contains allowed tags, tag attributes, and css properties.
+   *  Used in the createHtml function to filter incoming html into the allowed XHTML-IM subset.
+   *  See http://xmpp.org/extensions/xep-0071.html#profile-summary for the list of recommended
+   *  allowed tags and their attributes.
+   */
+  XHTML: {
+    tags: ['a', 'blockquote', 'br', 'cite', 'em', 'img', 'li', 'ol', 'p', 'span', 'strong', 'ul', 'body'],
+    attributes: {
+      'a': ['href'],
+      'blockquote': ['style'],
+      'br': [],
+      'cite': ['style'],
+      'em': [],
+      'img': ['src', 'alt', 'style', 'height', 'width'],
+      'li': ['style'],
+      'ol': ['style'],
+      'p': ['style'],
+      'span': ['style'],
+      'strong': [],
+      'ul': ['style'],
+      'body': []
+    },
+    css: ['background-color', 'color', 'font-family', 'font-size', 'font-style', 'font-weight', 'margin-left', 'margin-right', 'text-align', 'text-decoration'],
+
+    /** Function: XHTML.validTag
+     *
+     * Utility method to determine whether a tag is allowed
+     * in the XHTML_IM namespace.
+     *
+     * XHTML tag names are case sensitive and must be lower case.
+     */
+    validTag: function validTag(tag) {
+      for (var i = 0; i < Strophe.XHTML.tags.length; i++) {
+        if (tag === Strophe.XHTML.tags[i]) {
+          return true;
+        }
+      }
+
+      return false;
+    },
+
+    /** Function: XHTML.validAttribute
+     *
+     * Utility method to determine whether an attribute is allowed
+     * as recommended per XEP-0071
+     *
+     * XHTML attribute names are case sensitive and must be lower case.
+     */
+    validAttribute: function validAttribute(tag, attribute) {
+      if (typeof Strophe.XHTML.attributes[tag] !== 'undefined' && Strophe.XHTML.attributes[tag].length > 0) {
+        for (var i = 0; i < Strophe.XHTML.attributes[tag].length; i++) {
+          if (attribute === Strophe.XHTML.attributes[tag][i]) {
+            return true;
+          }
+        }
+      }
+
+      return false;
+    },
+    validCSS: function validCSS(style) {
+      for (var i = 0; i < Strophe.XHTML.css.length; i++) {
+        if (style === Strophe.XHTML.css[i]) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+  },
+
+  /** Constants: Connection Status Constants
+   *  Connection status constants for use by the connection handler
+   *  callback.
+   *
+   *  Status.ERROR - An error has occurred
+   *  Status.CONNECTING - The connection is currently being made
+   *  Status.CONNFAIL - The connection attempt failed
+   *  Status.AUTHENTICATING - The connection is authenticating
+   *  Status.AUTHFAIL - The authentication attempt failed
+   *  Status.CONNECTED - The connection has succeeded
+   *  Status.DISCONNECTED - The connection has been terminated
+   *  Status.DISCONNECTING - The connection is currently being terminated
+   *  Status.ATTACHED - The connection has been attached
+   *  Status.REDIRECT - The connection has been redirected
+   *  Status.CONNTIMEOUT - The connection has timed out
+   */
+  Status: {
+    ERROR: 0,
+    CONNECTING: 1,
+    CONNFAIL: 2,
+    AUTHENTICATING: 3,
+    AUTHFAIL: 4,
+    CONNECTED: 5,
+    DISCONNECTED: 6,
+    DISCONNECTING: 7,
+    ATTACHED: 8,
+    REDIRECT: 9,
+    CONNTIMEOUT: 10
+  },
+  ErrorCondition: {
+    BAD_FORMAT: "bad-format",
+    CONFLICT: "conflict",
+    MISSING_JID_NODE: "x-strophe-bad-non-anon-jid",
+    NO_AUTH_MECH: "no-auth-mech",
+    UNKNOWN_REASON: "unknown"
+  },
+
+  /** Constants: Log Level Constants
+   *  Logging level indicators.
+   *
+   *  LogLevel.DEBUG - Debug output
+   *  LogLevel.INFO - Informational output
+   *  LogLevel.WARN - Warnings
+   *  LogLevel.ERROR - Errors
+   *  LogLevel.FATAL - Fatal errors
+   */
+  LogLevel: {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+    FATAL: 4
+  },
+
+  /** PrivateConstants: DOM Element Type Constants
+   *  DOM element types.
+   *
+   *  ElementType.NORMAL - Normal element.
+   *  ElementType.TEXT - Text data element.
+   *  ElementType.FRAGMENT - XHTML fragment element.
+   */
+  ElementType: {
+    NORMAL: 1,
+    TEXT: 3,
+    CDATA: 4,
+    FRAGMENT: 11
+  },
+
+  /** PrivateConstants: Timeout Values
+   *  Timeout values for error states.  These values are in seconds.
+   *  These should not be changed unless you know exactly what you are
+   *  doing.
+   *
+   *  TIMEOUT - Timeout multiplier. A waiting request will be considered
+   *      failed after Math.floor(TIMEOUT * wait) seconds have elapsed.
+   *      This defaults to 1.1, and with default wait, 66 seconds.
+   *  SECONDARY_TIMEOUT - Secondary timeout multiplier. In cases where
+   *      Strophe can detect early failure, it will consider the request
+   *      failed if it doesn't return after
+   *      Math.floor(SECONDARY_TIMEOUT * wait) seconds have elapsed.
+   *      This defaults to 0.1, and with default wait, 6 seconds.
+   */
+  TIMEOUT: 1.1,
+  SECONDARY_TIMEOUT: 0.1,
+
+  /** Function: addNamespace
+   *  This function is used to extend the current namespaces in
+   *  Strophe.NS.  It takes a key and a value with the key being the
+   *  name of the new namespace, with its actual value.
+   *  For example:
+   *  Strophe.addNamespace('PUBSUB', "http://jabber.org/protocol/pubsub");
+   *
+   *  Parameters:
+   *    (String) name - The name under which the namespace will be
+   *      referenced under Strophe.NS
+   *    (String) value - The actual namespace.
+   */
+  addNamespace: function addNamespace(name, value) {
+    Strophe.NS[name] = value;
+  },
+
+  /** Function: forEachChild
+   *  Map a function over some or all child elements of a given element.
+   *
+   *  This is a small convenience function for mapping a function over
+   *  some or all of the children of an element.  If elemName is null, all
+   *  children will be passed to the function, otherwise only children
+   *  whose tag names match elemName will be passed.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - The element to operate on.
+   *    (String) elemName - The child element tag name filter.
+   *    (Function) func - The function to apply to each child.  This
+   *      function should take a single argument, a DOM element.
+   */
+  forEachChild: function forEachChild(elem, elemName, func) {
+    for (var i = 0; i < elem.childNodes.length; i++) {
+      var childNode = elem.childNodes[i];
+
+      if (childNode.nodeType === Strophe.ElementType.NORMAL && (!elemName || this.isTagEqual(childNode, elemName))) {
+        func(childNode);
+      }
+    }
+  },
+
+  /** Function: isTagEqual
+   *  Compare an element's tag name with a string.
+   *
+   *  This function is case sensitive.
+   *
+   *  Parameters:
+   *    (XMLElement) el - A DOM element.
+   *    (String) name - The element name.
+   *
+   *  Returns:
+   *    true if the element's tag name matches _el_, and false
+   *    otherwise.
+   */
+  isTagEqual: function isTagEqual(el, name) {
+    return el.tagName === name;
+  },
+
+  /** PrivateVariable: _xmlGenerator
+   *  _Private_ variable that caches a DOM document to
+   *  generate elements.
+   */
+  _xmlGenerator: null,
+
+  /** PrivateFunction: _makeGenerator
+   *  _Private_ function that creates a dummy XML DOM document to serve as
+   *  an element and text node generator.
+   */
+  _makeGenerator: function _makeGenerator() {
+    var doc; // IE9 does implement createDocument(); however, using it will cause the browser to leak memory on page unload.
+    // Here, we test for presence of createDocument() plus IE's proprietary documentMode attribute, which would be
+    // less than 10 in the case of IE9 and below.
+
+    if (document.implementation.createDocument === undefined || document.implementation.createDocument && document.documentMode && document.documentMode < 10) {
+      doc = this._getIEXmlDom();
+      doc.appendChild(doc.createElement('strophe'));
+    } else {
+      doc = document.implementation.createDocument('jabber:client', 'strophe', null);
+    }
+
+    return doc;
+  },
+
+  /** Function: xmlGenerator
+   *  Get the DOM document to generate elements.
+   *
+   *  Returns:
+   *    The currently used DOM document.
+   */
+  xmlGenerator: function xmlGenerator() {
+    if (!Strophe._xmlGenerator) {
+      Strophe._xmlGenerator = Strophe._makeGenerator();
+    }
+
+    return Strophe._xmlGenerator;
+  },
+
+  /** PrivateFunction: _getIEXmlDom
+   *  Gets IE xml doc object
+   *
+   *  Returns:
+   *    A Microsoft XML DOM Object
+   *  See Also:
+   *    http://msdn.microsoft.com/en-us/library/ms757837%28VS.85%29.aspx
+   */
+  _getIEXmlDom: function _getIEXmlDom() {
+    var doc = null;
+    var docStrings = ["Msxml2.DOMDocument.6.0", "Msxml2.DOMDocument.5.0", "Msxml2.DOMDocument.4.0", "MSXML2.DOMDocument.3.0", "MSXML2.DOMDocument", "MSXML.DOMDocument", "Microsoft.XMLDOM"];
+
+    for (var d = 0; d < docStrings.length; d++) {
+      if (doc === null) {
+        try {
+          doc = new ActiveXObject(docStrings[d]);
+        } catch (e) {
+          doc = null;
+        }
+      } else {
+        break;
+      }
+    }
+
+    return doc;
+  },
+
+  /** Function: xmlElement
+   *  Create an XML DOM element.
+   *
+   *  This function creates an XML DOM element correctly across all
+   *  implementations. Note that these are not HTML DOM elements, which
+   *  aren't appropriate for XMPP stanzas.
+   *
+   *  Parameters:
+   *    (String) name - The name for the element.
+   *    (Array|Object) attrs - An optional array or object containing
+   *      key/value pairs to use as element attributes. The object should
+   *      be in the format {'key': 'value'} or {key: 'value'}. The array
+   *      should have the format [['key1', 'value1'], ['key2', 'value2']].
+   *    (String) text - The text child data for the element.
+   *
+   *  Returns:
+   *    A new XML DOM element.
+   */
+  xmlElement: function xmlElement(name) {
+    if (!name) {
+      return null;
+    }
+
+    var node = Strophe.xmlGenerator().createElement(name); // FIXME: this should throw errors if args are the wrong type or
+    // there are more than two optional args
+
+    for (var a = 1; a < arguments.length; a++) {
+      var arg = arguments[a];
+
+      if (!arg) {
+        continue;
+      }
+
+      if (typeof arg === "string" || typeof arg === "number") {
+        node.appendChild(Strophe.xmlTextNode(arg));
+      } else if (_typeof(arg) === "object" && typeof arg.sort === "function") {
+        for (var i = 0; i < arg.length; i++) {
+          var attr = arg[i];
+
+          if (_typeof(attr) === "object" && typeof attr.sort === "function" && attr[1] !== undefined && attr[1] !== null) {
+            node.setAttribute(attr[0], attr[1]);
+          }
+        }
+      } else if (_typeof(arg) === "object") {
+        for (var k in arg) {
+          if (Object.prototype.hasOwnProperty.call(arg, k) && arg[k] !== undefined && arg[k] !== null) {
+            node.setAttribute(k, arg[k]);
+          }
+        }
+      }
+    }
+
+    return node;
+  },
+
+  /*  Function: xmlescape
+   *  Excapes invalid xml characters.
+   *
+   *  Parameters:
+   *     (String) text - text to escape.
+   *
+   *  Returns:
+   *      Escaped text.
+   */
+  xmlescape: function xmlescape(text) {
+    text = text.replace(/\&/g, "&amp;");
+    text = text.replace(/</g, "&lt;");
+    text = text.replace(/>/g, "&gt;");
+    text = text.replace(/'/g, "&apos;");
+    text = text.replace(/"/g, "&quot;");
+    return text;
+  },
+
+  /*  Function: xmlunescape
+  *  Unexcapes invalid xml characters.
+  *
+  *  Parameters:
+  *     (String) text - text to unescape.
+  *
+  *  Returns:
+  *      Unescaped text.
+  */
+  xmlunescape: function xmlunescape(text) {
+    text = text.replace(/\&amp;/g, "&");
+    text = text.replace(/&lt;/g, "<");
+    text = text.replace(/&gt;/g, ">");
+    text = text.replace(/&apos;/g, "'");
+    text = text.replace(/&quot;/g, "\"");
+    return text;
+  },
+
+  /** Function: xmlTextNode
+   *  Creates an XML DOM text node.
+   *
+   *  Provides a cross implementation version of document.createTextNode.
+   *
+   *  Parameters:
+   *    (String) text - The content of the text node.
+   *
+   *  Returns:
+   *    A new XML DOM text node.
+   */
+  xmlTextNode: function xmlTextNode(text) {
+    return Strophe.xmlGenerator().createTextNode(text);
+  },
+
+  /** Function: xmlHtmlNode
+   *  Creates an XML DOM html node.
+   *
+   *  Parameters:
+   *    (String) html - The content of the html node.
+   *
+   *  Returns:
+   *    A new XML DOM text node.
+   */
+  xmlHtmlNode: function xmlHtmlNode(html) {
+    var node; //ensure text is escaped
+
+    if (DOMParser) {
+      var parser = new DOMParser();
+      node = parser.parseFromString(html, "text/xml");
+    } else {
+      node = new ActiveXObject("Microsoft.XMLDOM");
+      node.async = "false";
+      node.loadXML(html);
+    }
+
+    return node;
+  },
+
+  /** Function: getText
+   *  Get the concatenation of all text children of an element.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - A DOM element.
+   *
+   *  Returns:
+   *    A String with the concatenated text of all text element children.
+   */
+  getText: function getText(elem) {
+    if (!elem) {
+      return null;
+    }
+
+    var str = "";
+
+    if (elem.childNodes.length === 0 && elem.nodeType === Strophe.ElementType.TEXT) {
+      str += elem.nodeValue;
+    }
+
+    for (var i = 0; i < elem.childNodes.length; i++) {
+      if (elem.childNodes[i].nodeType === Strophe.ElementType.TEXT) {
+        str += elem.childNodes[i].nodeValue;
+      }
+    }
+
+    return Strophe.xmlescape(str);
+  },
+
+  /** Function: copyElement
+   *  Copy an XML DOM element.
+   *
+   *  This function copies a DOM element and all its descendants and returns
+   *  the new copy.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - A DOM element.
+   *
+   *  Returns:
+   *    A new, copied DOM element tree.
+   */
+  copyElement: function copyElement(elem) {
+    var el;
+
+    if (elem.nodeType === Strophe.ElementType.NORMAL) {
+      el = Strophe.xmlElement(elem.tagName);
+
+      for (var i = 0; i < elem.attributes.length; i++) {
+        el.setAttribute(elem.attributes[i].nodeName, elem.attributes[i].value);
+      }
+
+      for (var _i = 0; _i < elem.childNodes.length; _i++) {
+        el.appendChild(Strophe.copyElement(elem.childNodes[_i]));
+      }
+    } else if (elem.nodeType === Strophe.ElementType.TEXT) {
+      el = Strophe.xmlGenerator().createTextNode(elem.nodeValue);
+    }
+
+    return el;
+  },
+
+  /** Function: createHtml
+   *  Copy an HTML DOM element into an XML DOM.
+   *
+   *  This function copies a DOM element and all its descendants and returns
+   *  the new copy.
+   *
+   *  Parameters:
+   *    (HTMLElement) elem - A DOM element.
+   *
+   *  Returns:
+   *    A new, copied DOM element tree.
+   */
+  createHtml: function createHtml(elem) {
+    var el;
+
+    if (elem.nodeType === Strophe.ElementType.NORMAL) {
+      var tag = elem.nodeName.toLowerCase(); // XHTML tags must be lower case.
+
+      if (Strophe.XHTML.validTag(tag)) {
+        try {
+          el = Strophe.xmlElement(tag);
+
+          for (var i = 0; i < Strophe.XHTML.attributes[tag].length; i++) {
+            var attribute = Strophe.XHTML.attributes[tag][i];
+            var value = elem.getAttribute(attribute);
+
+            if (typeof value === 'undefined' || value === null || value === '' || value === false || value === 0) {
+              continue;
+            }
+
+            if (attribute === 'style' && _typeof(value) === 'object' && typeof value.cssText !== 'undefined') {
+              value = value.cssText; // we're dealing with IE, need to get CSS out
+            } // filter out invalid css styles
+
+
+            if (attribute === 'style') {
+              var css = [];
+              var cssAttrs = value.split(';');
+
+              for (var j = 0; j < cssAttrs.length; j++) {
+                var attr = cssAttrs[j].split(':');
+                var cssName = attr[0].replace(/^\s*/, "").replace(/\s*$/, "").toLowerCase();
+
+                if (Strophe.XHTML.validCSS(cssName)) {
+                  var cssValue = attr[1].replace(/^\s*/, "").replace(/\s*$/, "");
+                  css.push(cssName + ': ' + cssValue);
+                }
+              }
+
+              if (css.length > 0) {
+                value = css.join('; ');
+                el.setAttribute(attribute, value);
+              }
+            } else {
+              el.setAttribute(attribute, value);
+            }
+          }
+
+          for (var _i2 = 0; _i2 < elem.childNodes.length; _i2++) {
+            el.appendChild(Strophe.createHtml(elem.childNodes[_i2]));
+          }
+        } catch (e) {
+          // invalid elements
+          el = Strophe.xmlTextNode('');
+        }
+      } else {
+        el = Strophe.xmlGenerator().createDocumentFragment();
+
+        for (var _i3 = 0; _i3 < elem.childNodes.length; _i3++) {
+          el.appendChild(Strophe.createHtml(elem.childNodes[_i3]));
+        }
+      }
+    } else if (elem.nodeType === Strophe.ElementType.FRAGMENT) {
+      el = Strophe.xmlGenerator().createDocumentFragment();
+
+      for (var _i4 = 0; _i4 < elem.childNodes.length; _i4++) {
+        el.appendChild(Strophe.createHtml(elem.childNodes[_i4]));
+      }
+    } else if (elem.nodeType === Strophe.ElementType.TEXT) {
+      el = Strophe.xmlTextNode(elem.nodeValue);
+    }
+
+    return el;
+  },
+
+  /** Function: escapeNode
+   *  Escape the node part (also called local part) of a JID.
+   *
+   *  Parameters:
+   *    (String) node - A node (or local part).
+   *
+   *  Returns:
+   *    An escaped node (or local part).
+   */
+  escapeNode: function escapeNode(node) {
+    if (typeof node !== "string") {
+      return node;
+    }
+
+    return node.replace(/^\s+|\s+$/g, '').replace(/\\/g, "\\5c").replace(/ /g, "\\20").replace(/\"/g, "\\22").replace(/\&/g, "\\26").replace(/\'/g, "\\27").replace(/\//g, "\\2f").replace(/:/g, "\\3a").replace(/</g, "\\3c").replace(/>/g, "\\3e").replace(/@/g, "\\40");
+  },
+
+  /** Function: unescapeNode
+   *  Unescape a node part (also called local part) of a JID.
+   *
+   *  Parameters:
+   *    (String) node - A node (or local part).
+   *
+   *  Returns:
+   *    An unescaped node (or local part).
+   */
+  unescapeNode: function unescapeNode(node) {
+    if (typeof node !== "string") {
+      return node;
+    }
+
+    return node.replace(/\\20/g, " ").replace(/\\22/g, '"').replace(/\\26/g, "&").replace(/\\27/g, "'").replace(/\\2f/g, "/").replace(/\\3a/g, ":").replace(/\\3c/g, "<").replace(/\\3e/g, ">").replace(/\\40/g, "@").replace(/\\5c/g, "\\");
+  },
+
+  /** Function: getNodeFromJid
+   *  Get the node portion of a JID String.
+   *
+   *  Parameters:
+   *    (String) jid - A JID.
+   *
+   *  Returns:
+   *    A String containing the node.
+   */
+  getNodeFromJid: function getNodeFromJid(jid) {
+    if (jid.indexOf("@") < 0) {
+      return null;
+    }
+
+    return jid.split("@")[0];
+  },
+
+  /** Function: getDomainFromJid
+   *  Get the domain portion of a JID String.
+   *
+   *  Parameters:
+   *    (String) jid - A JID.
+   *
+   *  Returns:
+   *    A String containing the domain.
+   */
+  getDomainFromJid: function getDomainFromJid(jid) {
+    var bare = Strophe.getBareJidFromJid(jid);
+
+    if (bare.indexOf("@") < 0) {
+      return bare;
+    } else {
+      var parts = bare.split("@");
+      parts.splice(0, 1);
+      return parts.join('@');
+    }
+  },
+
+  /** Function: getResourceFromJid
+   *  Get the resource portion of a JID String.
+   *
+   *  Parameters:
+   *    (String) jid - A JID.
+   *
+   *  Returns:
+   *    A String containing the resource.
+   */
+  getResourceFromJid: function getResourceFromJid(jid) {
+    var s = jid.split("/");
+
+    if (s.length < 2) {
+      return null;
+    }
+
+    s.splice(0, 1);
+    return s.join('/');
+  },
+
+  /** Function: getBareJidFromJid
+   *  Get the bare JID from a JID String.
+   *
+   *  Parameters:
+   *    (String) jid - A JID.
+   *
+   *  Returns:
+   *    A String containing the bare JID.
+   */
+  getBareJidFromJid: function getBareJidFromJid(jid) {
+    return jid ? jid.split("/")[0] : null;
+  },
+
+  /** PrivateFunction: _handleError
+   *  _Private_ function that properly logs an error to the console
+   */
+  _handleError: function _handleError(e) {
+    if (typeof e.stack !== "undefined") {
+      Strophe.fatal(e.stack);
+    }
+
+    if (e.sourceURL) {
+      Strophe.fatal("error: " + this.handler + " " + e.sourceURL + ":" + e.line + " - " + e.name + ": " + e.message);
+    } else if (e.fileName) {
+      Strophe.fatal("error: " + this.handler + " " + e.fileName + ":" + e.lineNumber + " - " + e.name + ": " + e.message);
+    } else {
+      Strophe.fatal("error: " + e.message);
+    }
+  },
+
+  /** Function: log
+   *  User overrideable logging function.
+   *
+   *  This function is called whenever the Strophe library calls any
+   *  of the logging functions.  The default implementation of this
+   *  function logs only fatal errors.  If client code wishes to handle the logging
+   *  messages, it should override this with
+   *  > Strophe.log = function (level, msg) {
+   *  >   (user code here)
+   *  > };
+   *
+   *  Please note that data sent and received over the wire is logged
+   *  via Strophe.Connection.rawInput() and Strophe.Connection.rawOutput().
+   *
+   *  The different levels and their meanings are
+   *
+   *    DEBUG - Messages useful for debugging purposes.
+   *    INFO - Informational messages.  This is mostly information like
+   *      'disconnect was called' or 'SASL auth succeeded'.
+   *    WARN - Warnings about potential problems.  This is mostly used
+   *      to report transient connection errors like request timeouts.
+   *    ERROR - Some error occurred.
+   *    FATAL - A non-recoverable fatal error occurred.
+   *
+   *  Parameters:
+   *    (Integer) level - The log level of the log message.  This will
+   *      be one of the values in Strophe.LogLevel.
+   *    (String) msg - The log message.
+   */
+  log: function log(level, msg) {
+    if (level === this.LogLevel.FATAL && _typeof(window.console) === 'object' && typeof window.console.error === 'function') {
+      window.console.error(msg);
+    }
+  },
+
+  /** Function: debug
+   *  Log a message at the Strophe.LogLevel.DEBUG level.
+   *
+   *  Parameters:
+   *    (String) msg - The log message.
+   */
+  debug: function debug(msg) {
+    this.log(this.LogLevel.DEBUG, msg);
+  },
+
+  /** Function: info
+   *  Log a message at the Strophe.LogLevel.INFO level.
+   *
+   *  Parameters:
+   *    (String) msg - The log message.
+   */
+  info: function info(msg) {
+    this.log(this.LogLevel.INFO, msg);
+  },
+
+  /** Function: warn
+   *  Log a message at the Strophe.LogLevel.WARN level.
+   *
+   *  Parameters:
+   *    (String) msg - The log message.
+   */
+  warn: function warn(msg) {
+    this.log(this.LogLevel.WARN, msg);
+  },
+
+  /** Function: error
+   *  Log a message at the Strophe.LogLevel.ERROR level.
+   *
+   *  Parameters:
+   *    (String) msg - The log message.
+   */
+  error: function error(msg) {
+    this.log(this.LogLevel.ERROR, msg);
+  },
+
+  /** Function: fatal
+   *  Log a message at the Strophe.LogLevel.FATAL level.
+   *
+   *  Parameters:
+   *    (String) msg - The log message.
+   */
+  fatal: function fatal(msg) {
+    this.log(this.LogLevel.FATAL, msg);
+  },
+
+  /** Function: serialize
+   *  Render a DOM element and all descendants to a String.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - A DOM element.
+   *
+   *  Returns:
+   *    The serialized element tree as a String.
+   */
+  serialize: function serialize(elem) {
+    if (!elem) {
+      return null;
+    }
+
+    if (typeof elem.tree === "function") {
+      elem = elem.tree();
+    }
+
+    var names = _toConsumableArray(Array(elem.attributes.length).keys()).map(function (i) {
+      return elem.attributes[i].nodeName;
+    });
+
+    names.sort();
+    var result = names.reduce(function (a, n) {
+      return "".concat(a, " ").concat(n, "=\"").concat(Strophe.xmlescape(elem.attributes.getNamedItem(n).value), "\"");
+    }, "<".concat(elem.nodeName));
+
+    if (elem.childNodes.length > 0) {
+      result += ">";
+
+      for (var i = 0; i < elem.childNodes.length; i++) {
+        var child = elem.childNodes[i];
+
+        switch (child.nodeType) {
+          case Strophe.ElementType.NORMAL:
+            // normal element, so recurse
+            result += Strophe.serialize(child);
+            break;
+
+          case Strophe.ElementType.TEXT:
+            // text element to escape values
+            result += Strophe.xmlescape(child.nodeValue);
+            break;
+
+          case Strophe.ElementType.CDATA:
+            // cdata section so don't escape values
+            result += "<![CDATA[" + child.nodeValue + "]]>";
+        }
+      }
+
+      result += "</" + elem.nodeName + ">";
+    } else {
+      result += "/>";
+    }
+
+    return result;
+  },
+
+  /** PrivateVariable: _requestId
+   *  _Private_ variable that keeps track of the request ids for
+   *  connections.
+   */
+  _requestId: 0,
+
+  /** PrivateVariable: Strophe.connectionPlugins
+   *  _Private_ variable Used to store plugin names that need
+   *  initialization on Strophe.Connection construction.
+   */
+  _connectionPlugins: {},
+
+  /** Function: addConnectionPlugin
+   *  Extends the Strophe.Connection object with the given plugin.
+   *
+   *  Parameters:
+   *    (String) name - The name of the extension.
+   *    (Object) ptype - The plugin's prototype.
+   */
+  addConnectionPlugin: function addConnectionPlugin(name, ptype) {
+    Strophe._connectionPlugins[name] = ptype;
+  }
+};
+/** Class: Strophe.Builder
+ *  XML DOM builder.
+ *
+ *  This object provides an interface similar to JQuery but for building
+ *  DOM elements easily and rapidly.  All the functions except for toString()
+ *  and tree() return the object, so calls can be chained.  Here's an
+ *  example using the $iq() builder helper.
+ *  > $iq({to: 'you', from: 'me', type: 'get', id: '1'})
+ *  >     .c('query', {xmlns: 'strophe:example'})
+ *  >     .c('example')
+ *  >     .toString()
+ *
+ *  The above generates this XML fragment
+ *  > <iq to='you' from='me' type='get' id='1'>
+ *  >   <query xmlns='strophe:example'>
+ *  >     <example/>
+ *  >   </query>
+ *  > </iq>
+ *  The corresponding DOM manipulations to get a similar fragment would be
+ *  a lot more tedious and probably involve several helper variables.
+ *
+ *  Since adding children makes new operations operate on the child, up()
+ *  is provided to traverse up the tree.  To add two children, do
+ *  > builder.c('child1', ...).up().c('child2', ...)
+ *  The next operation on the Builder will be relative to the second child.
+ */
+
+/** Constructor: Strophe.Builder
+ *  Create a Strophe.Builder object.
+ *
+ *  The attributes should be passed in object notation.  For example
+ *  > let b = new Builder('message', {to: 'you', from: 'me'});
+ *  or
+ *  > let b = new Builder('messsage', {'xml:lang': 'en'});
+ *
+ *  Parameters:
+ *    (String) name - The name of the root element.
+ *    (Object) attrs - The attributes for the root element in object notation.
+ *
+ *  Returns:
+ *    A new Strophe.Builder.
+ */
+
+Strophe.Builder = function (name, attrs) {
+  // Set correct namespace for jabber:client elements
+  if (name === "presence" || name === "message" || name === "iq") {
+    if (attrs && !attrs.xmlns) {
+      attrs.xmlns = Strophe.NS.CLIENT;
+    } else if (!attrs) {
+      attrs = {
+        xmlns: Strophe.NS.CLIENT
+      };
+    }
+  } // Holds the tree being built.
+
+
+  this.nodeTree = Strophe.xmlElement(name, attrs); // Points to the current operation node.
+
+  this.node = this.nodeTree;
+};
+
+Strophe.Builder.prototype = {
+  /** Function: tree
+   *  Return the DOM tree.
+   *
+   *  This function returns the current DOM tree as an element object.  This
+   *  is suitable for passing to functions like Strophe.Connection.send().
+   *
+   *  Returns:
+   *    The DOM tree as a element object.
+   */
+  tree: function tree() {
+    return this.nodeTree;
+  },
+
+  /** Function: toString
+   *  Serialize the DOM tree to a String.
+   *
+   *  This function returns a string serialization of the current DOM
+   *  tree.  It is often used internally to pass data to a
+   *  Strophe.Request object.
+   *
+   *  Returns:
+   *    The serialized DOM tree in a String.
+   */
+  toString: function toString() {
+    return Strophe.serialize(this.nodeTree);
+  },
+
+  /** Function: up
+   *  Make the current parent element the new current element.
+   *
+   *  This function is often used after c() to traverse back up the tree.
+   *  For example, to add two children to the same element
+   *  > builder.c('child1', {}).up().c('child2', {});
+   *
+   *  Returns:
+   *    The Stophe.Builder object.
+   */
+  up: function up() {
+    this.node = this.node.parentNode;
+    return this;
+  },
+
+  /** Function: root
+   *  Make the root element the new current element.
+   *
+   *  When at a deeply nested element in the tree, this function can be used
+   *  to jump back to the root of the tree, instead of having to repeatedly
+   *  call up().
+   *
+   *  Returns:
+   *    The Stophe.Builder object.
+   */
+  root: function root() {
+    this.node = this.nodeTree;
+    return this;
+  },
+
+  /** Function: attrs
+   *  Add or modify attributes of the current element.
+   *
+   *  The attributes should be passed in object notation.  This function
+   *  does not move the current element pointer.
+   *
+   *  Parameters:
+   *    (Object) moreattrs - The attributes to add/modify in object notation.
+   *
+   *  Returns:
+   *    The Strophe.Builder object.
+   */
+  attrs: function attrs(moreattrs) {
+    for (var k in moreattrs) {
+      if (Object.prototype.hasOwnProperty.call(moreattrs, k)) {
+        if (moreattrs[k] === undefined) {
+          this.node.removeAttribute(k);
+        } else {
+          this.node.setAttribute(k, moreattrs[k]);
+        }
+      }
+    }
+
+    return this;
+  },
+
+  /** Function: c
+   *  Add a child to the current element and make it the new current
+   *  element.
+   *
+   *  This function moves the current element pointer to the child,
+   *  unless text is provided.  If you need to add another child, it
+   *  is necessary to use up() to go back to the parent in the tree.
+   *
+   *  Parameters:
+   *    (String) name - The name of the child.
+   *    (Object) attrs - The attributes of the child in object notation.
+   *    (String) text - The text to add to the child.
+   *
+   *  Returns:
+   *    The Strophe.Builder object.
+   */
+  c: function c(name, attrs, text) {
+    var child = Strophe.xmlElement(name, attrs, text);
+    this.node.appendChild(child);
+
+    if (typeof text !== "string" && typeof text !== "number") {
+      this.node = child;
+    }
+
+    return this;
+  },
+
+  /** Function: cnode
+   *  Add a child to the current element and make it the new current
+   *  element.
+   *
+   *  This function is the same as c() except that instead of using a
+   *  name and an attributes object to create the child it uses an
+   *  existing DOM element object.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - A DOM element.
+   *
+   *  Returns:
+   *    The Strophe.Builder object.
+   */
+  cnode: function cnode(elem) {
+    var impNode;
+    var xmlGen = Strophe.xmlGenerator();
+
+    try {
+      impNode = xmlGen.importNode !== undefined;
+    } catch (e) {
+      impNode = false;
+    }
+
+    var newElem = impNode ? xmlGen.importNode(elem, true) : Strophe.copyElement(elem);
+    this.node.appendChild(newElem);
+    this.node = newElem;
+    return this;
+  },
+
+  /** Function: t
+   *  Add a child text element.
+   *
+   *  This *does not* make the child the new current element since there
+   *  are no children of text elements.
+   *
+   *  Parameters:
+   *    (String) text - The text data to append to the current element.
+   *
+   *  Returns:
+   *    The Strophe.Builder object.
+   */
+  t: function t(text) {
+    var child = Strophe.xmlTextNode(text);
+    this.node.appendChild(child);
+    return this;
+  },
+
+  /** Function: h
+   *  Replace current element contents with the HTML passed in.
+   *
+   *  This *does not* make the child the new current element
+   *
+   *  Parameters:
+   *    (String) html - The html to insert as contents of current element.
+   *
+   *  Returns:
+   *    The Strophe.Builder object.
+   */
+  h: function h(html) {
+    var fragment = document.createElement('body'); // force the browser to try and fix any invalid HTML tags
+
+    fragment.innerHTML = html; // copy cleaned html into an xml dom
+
+    var xhtml = Strophe.createHtml(fragment);
+
+    while (xhtml.childNodes.length > 0) {
+      this.node.appendChild(xhtml.childNodes[0]);
+    }
+
+    return this;
+  }
+};
+/** PrivateClass: Strophe.Handler
+ *  _Private_ helper class for managing stanza handlers.
+ *
+ *  A Strophe.Handler encapsulates a user provided callback function to be
+ *  executed when matching stanzas are received by the connection.
+ *  Handlers can be either one-off or persistant depending on their
+ *  return value. Returning true will cause a Handler to remain active, and
+ *  returning false will remove the Handler.
+ *
+ *  Users will not use Strophe.Handler objects directly, but instead they
+ *  will use Strophe.Connection.addHandler() and
+ *  Strophe.Connection.deleteHandler().
+ */
+
+/** PrivateConstructor: Strophe.Handler
+ *  Create and initialize a new Strophe.Handler.
+ *
+ *  Parameters:
+ *    (Function) handler - A function to be executed when the handler is run.
+ *    (String) ns - The namespace to match.
+ *    (String) name - The element name to match.
+ *    (String) type - The element type to match.
+ *    (String) id - The element id attribute to match.
+ *    (String) from - The element from attribute to match.
+ *    (Object) options - Handler options
+ *
+ *  Returns:
+ *    A new Strophe.Handler object.
+ */
+
+Strophe.Handler = function (handler, ns, name, type, id, from, options) {
+  this.handler = handler;
+  this.ns = ns;
+  this.name = name;
+  this.type = type;
+  this.id = id;
+  this.options = options || {
+    'matchBareFromJid': false,
+    'ignoreNamespaceFragment': false
+  }; // BBB: Maintain backward compatibility with old `matchBare` option
+
+  if (this.options.matchBare) {
+    Strophe.warn('The "matchBare" option is deprecated, use "matchBareFromJid" instead.');
+    this.options.matchBareFromJid = this.options.matchBare;
+    delete this.options.matchBare;
+  }
+
+  if (this.options.matchBareFromJid) {
+    this.from = from ? Strophe.getBareJidFromJid(from) : null;
+  } else {
+    this.from = from;
+  } // whether the handler is a user handler or a system handler
+
+
+  this.user = true;
+};
+
+Strophe.Handler.prototype = {
+  /** PrivateFunction: getNamespace
+   *  Returns the XML namespace attribute on an element.
+   *  If `ignoreNamespaceFragment` was passed in for this handler, then the
+   *  URL fragment will be stripped.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - The XML element with the namespace.
+   *
+   *  Returns:
+   *    The namespace, with optionally the fragment stripped.
+   */
+  getNamespace: function getNamespace(elem) {
+    var elNamespace = elem.getAttribute("xmlns");
+
+    if (elNamespace && this.options.ignoreNamespaceFragment) {
+      elNamespace = elNamespace.split('#')[0];
+    }
+
+    return elNamespace;
+  },
+
+  /** PrivateFunction: namespaceMatch
+   *  Tests if a stanza matches the namespace set for this Strophe.Handler.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - The XML element to test.
+   *
+   *  Returns:
+   *    true if the stanza matches and false otherwise.
+   */
+  namespaceMatch: function namespaceMatch(elem) {
+    var _this = this;
+
+    var nsMatch = false;
+
+    if (!this.ns) {
+      return true;
+    } else {
+      Strophe.forEachChild(elem, null, function (elem) {
+        if (_this.getNamespace(elem) === _this.ns) {
+          nsMatch = true;
+        }
+      });
+      return nsMatch || this.getNamespace(elem) === this.ns;
+    }
+  },
+
+  /** PrivateFunction: isMatch
+   *  Tests if a stanza matches the Strophe.Handler.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - The XML element to test.
+   *
+   *  Returns:
+   *    true if the stanza matches and false otherwise.
+   */
+  isMatch: function isMatch(elem) {
+    var from = elem.getAttribute('from');
+
+    if (this.options.matchBareFromJid) {
+      from = Strophe.getBareJidFromJid(from);
+    }
+
+    var elem_type = elem.getAttribute("type");
+
+    if (this.namespaceMatch(elem) && (!this.name || Strophe.isTagEqual(elem, this.name)) && (!this.type || (Array.isArray(this.type) ? this.type.indexOf(elem_type) !== -1 : elem_type === this.type)) && (!this.id || elem.getAttribute("id") === this.id) && (!this.from || from === this.from)) {
+      return true;
+    }
+
+    return false;
+  },
+
+  /** PrivateFunction: run
+   *  Run the callback on a matching stanza.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - The DOM element that triggered the
+   *      Strophe.Handler.
+   *
+   *  Returns:
+   *    A boolean indicating if the handler should remain active.
+   */
+  run: function run(elem) {
+    var result = null;
+
+    try {
+      result = this.handler(elem);
+    } catch (e) {
+      Strophe._handleError(e);
+
+      throw e;
+    }
+
+    return result;
+  },
+
+  /** PrivateFunction: toString
+   *  Get a String representation of the Strophe.Handler object.
+   *
+   *  Returns:
+   *    A String.
+   */
+  toString: function toString() {
+    return "{Handler: " + this.handler + "(" + this.name + "," + this.id + "," + this.ns + ")}";
+  }
+};
+/** PrivateClass: Strophe.TimedHandler
+ *  _Private_ helper class for managing timed handlers.
+ *
+ *  A Strophe.TimedHandler encapsulates a user provided callback that
+ *  should be called after a certain period of time or at regular
+ *  intervals.  The return value of the callback determines whether the
+ *  Strophe.TimedHandler will continue to fire.
+ *
+ *  Users will not use Strophe.TimedHandler objects directly, but instead
+ *  they will use Strophe.Connection.addTimedHandler() and
+ *  Strophe.Connection.deleteTimedHandler().
+ */
+
+/** PrivateConstructor: Strophe.TimedHandler
+ *  Create and initialize a new Strophe.TimedHandler object.
+ *
+ *  Parameters:
+ *    (Integer) period - The number of milliseconds to wait before the
+ *      handler is called.
+ *    (Function) handler - The callback to run when the handler fires.  This
+ *      function should take no arguments.
+ *
+ *  Returns:
+ *    A new Strophe.TimedHandler object.
+ */
+
+Strophe.TimedHandler = function (period, handler) {
+  this.period = period;
+  this.handler = handler;
+  this.lastCalled = new Date().getTime();
+  this.user = true;
+};
+
+Strophe.TimedHandler.prototype = {
+  /** PrivateFunction: run
+   *  Run the callback for the Strophe.TimedHandler.
+   *
+   *  Returns:
+   *    true if the Strophe.TimedHandler should be called again, and false
+   *      otherwise.
+   */
+  run: function run() {
+    this.lastCalled = new Date().getTime();
+    return this.handler();
+  },
+
+  /** PrivateFunction: reset
+   *  Reset the last called time for the Strophe.TimedHandler.
+   */
+  reset: function reset() {
+    this.lastCalled = new Date().getTime();
+  },
+
+  /** PrivateFunction: toString
+   *  Get a string representation of the Strophe.TimedHandler object.
+   *
+   *  Returns:
+   *    The string representation.
+   */
+  toString: function toString() {
+    return "{TimedHandler: " + this.handler + "(" + this.period + ")}";
+  }
+};
+/** Class: Strophe.Connection
+ *  XMPP Connection manager.
+ *
+ *  This class is the main part of Strophe.  It manages a BOSH or websocket
+ *  connection to an XMPP server and dispatches events to the user callbacks
+ *  as data arrives. It supports SASL PLAIN, SASL DIGEST-MD5, SASL SCRAM-SHA1
+ *  and legacy authentication.
+ *
+ *  After creating a Strophe.Connection object, the user will typically
+ *  call connect() with a user supplied callback to handle connection level
+ *  events like authentication failure, disconnection, or connection
+ *  complete.
+ *
+ *  The user will also have several event handlers defined by using
+ *  addHandler() and addTimedHandler().  These will allow the user code to
+ *  respond to interesting stanzas or do something periodically with the
+ *  connection. These handlers will be active once authentication is
+ *  finished.
+ *
+ *  To send data to the connection, use send().
+ */
+
+/** Constructor: Strophe.Connection
+ *  Create and initialize a Strophe.Connection object.
+ *
+ *  The transport-protocol for this connection will be chosen automatically
+ *  based on the given service parameter. URLs starting with "ws://" or
+ *  "wss://" will use WebSockets, URLs starting with "http://", "https://"
+ *  or without a protocol will use BOSH.
+ *
+ *  To make Strophe connect to the current host you can leave out the protocol
+ *  and host part and just pass the path, e.g.
+ *
+ *  > let conn = new Strophe.Connection("/http-bind/");
+ *
+ *  Options common to both Websocket and BOSH:
+ *  ------------------------------------------
+ *
+ *  cookies:
+ *
+ *  The *cookies* option allows you to pass in cookies to be added to the
+ *  document. These cookies will then be included in the BOSH XMLHttpRequest
+ *  or in the websocket connection.
+ *
+ *  The passed in value must be a map of cookie names and string values.
+ *
+ *  > { "myCookie": {
+ *  >     "value": "1234",
+ *  >     "domain": ".example.org",
+ *  >     "path": "/",
+ *  >     "expires": expirationDate
+ *  >     }
+ *  > }
+ *
+ *  Note that cookies can't be set in this way for other domains (i.e. cross-domain).
+ *  Those cookies need to be set under those domains, for example they can be
+ *  set server-side by making a XHR call to that domain to ask it to set any
+ *  necessary cookies.
+ *
+ *  mechanisms:
+ *
+ *  The *mechanisms* option allows you to specify the SASL mechanisms that this
+ *  instance of Strophe.Connection (and therefore your XMPP client) will
+ *  support.
+ *
+ *  The value must be an array of objects with Strophe.SASLMechanism
+ *  prototypes.
+ *
+ *  If nothing is specified, then the following mechanisms (and their
+ *  priorities) are registered:
+ *
+ *      SCRAM-SHA1 - 70
+ *      DIGEST-MD5 - 60
+ *      PLAIN - 50
+ *      OAUTH-BEARER - 40
+ *      OAUTH-2 - 30
+ *      ANONYMOUS - 20
+ *      EXTERNAL - 10
+ *
+ *  WebSocket options:
+ *  ------------------
+ *
+ *  If you want to connect to the current host with a WebSocket connection you
+ *  can tell Strophe to use WebSockets through a "protocol" attribute in the
+ *  optional options parameter. Valid values are "ws" for WebSocket and "wss"
+ *  for Secure WebSocket.
+ *  So to connect to "wss://CURRENT_HOSTNAME/xmpp-websocket" you would call
+ *
+ *  > let conn = new Strophe.Connection("/xmpp-websocket/", {protocol: "wss"});
+ *
+ *  Note that relative URLs _NOT_ starting with a "/" will also include the path
+ *  of the current site.
+ *
+ *  Also because downgrading security is not permitted by browsers, when using
+ *  relative URLs both BOSH and WebSocket connections will use their secure
+ *  variants if the current connection to the site is also secure (https).
+ *
+ *  BOSH options:
+ *  -------------
+ *
+ *  By adding "sync" to the options, you can control if requests will
+ *  be made synchronously or not. The default behaviour is asynchronous.
+ *  If you want to make requests synchronous, make "sync" evaluate to true.
+ *  > let conn = new Strophe.Connection("/http-bind/", {sync: true});
+ *
+ *  You can also toggle this on an already established connection.
+ *  > conn.options.sync = true;
+ *
+ *  The *customHeaders* option can be used to provide custom HTTP headers to be
+ *  included in the XMLHttpRequests made.
+ *
+ *  The *keepalive* option can be used to instruct Strophe to maintain the
+ *  current BOSH session across interruptions such as webpage reloads.
+ *
+ *  It will do this by caching the sessions tokens in sessionStorage, and when
+ *  "restore" is called it will check whether there are cached tokens with
+ *  which it can resume an existing session.
+ *
+ *  The *withCredentials* option should receive a Boolean value and is used to
+ *  indicate wether cookies should be included in ajax requests (by default
+ *  they're not).
+ *  Set this value to true if you are connecting to a BOSH service
+ *  and for some reason need to send cookies to it.
+ *  In order for this to work cross-domain, the server must also enable
+ *  credentials by setting the Access-Control-Allow-Credentials response header
+ *  to "true". For most usecases however this setting should be false (which
+ *  is the default).
+ *  Additionally, when using Access-Control-Allow-Credentials, the
+ *  Access-Control-Allow-Origin header can't be set to the wildcard "*", but
+ *  instead must be restricted to actual domains.
+ *
+ *  The *contentType* option can be set to change the default Content-Type
+ *  of "text/xml; charset=utf-8", which can be useful to reduce the amount of
+ *  CORS preflight requests that are sent to the server.
+ *
+ *  Parameters:
+ *    (String) service - The BOSH or WebSocket service URL.
+ *    (Object) options - A hash of configuration options
+ *
+ *  Returns:
+ *    A new Strophe.Connection object.
+ */
+
+Strophe.Connection = function (service, options) {
+  var _this2 = this;
+
+  // The service URL
+  this.service = service; // Configuration options
+
+  this.options = options || {};
+  var proto = this.options.protocol || ""; // Select protocal based on service or options
+
+  if (service.indexOf("ws:") === 0 || service.indexOf("wss:") === 0 || proto.indexOf("ws") === 0) {
+    this._proto = new Strophe.Websocket(this);
+  } else {
+    this._proto = new Strophe.Bosh(this);
+  }
+  /* The connected JID. */
+
+
+  this.jid = "";
+  /* the JIDs domain */
+
+  this.domain = null;
+  /* stream:features */
+
+  this.features = null; // SASL
+
+  this._sasl_data = {};
+  this.do_session = false;
+  this.do_bind = false; // handler lists
+
+  this.timedHandlers = [];
+  this.handlers = [];
+  this.removeTimeds = [];
+  this.removeHandlers = [];
+  this.addTimeds = [];
+  this.addHandlers = [];
+  this.protocolErrorHandlers = {
+    'HTTP': {},
+    'websocket': {}
+  };
+  this._idleTimeout = null;
+  this._disconnectTimeout = null;
+  this.authenticated = false;
+  this.connected = false;
+  this.disconnecting = false;
+  this.do_authentication = true;
+  this.paused = false;
+  this.restored = false;
+  this._data = [];
+  this._uniqueId = 0;
+  this._sasl_success_handler = null;
+  this._sasl_failure_handler = null;
+  this._sasl_challenge_handler = null; // Max retries before disconnecting
+
+  this.maxRetries = 5; // Call onIdle callback every 1/10th of a second
+
+  this._idleTimeout = setTimeout(function () {
+    return _this2._onIdle();
+  }, 100);
+  utils__WEBPACK_IMPORTED_MODULE_2__["default"].addCookies(this.options.cookies);
+  this.registerSASLMechanisms(this.options.mechanisms); // initialize plugins
+
+  for (var k in Strophe._connectionPlugins) {
+    if (Object.prototype.hasOwnProperty.call(Strophe._connectionPlugins, k)) {
+      var F = function F() {};
+
+      F.prototype = Strophe._connectionPlugins[k];
+      this[k] = new F();
+      this[k].init(this);
+    }
+  }
+};
+
+Strophe.Connection.prototype = {
+  /** Function: reset
+   *  Reset the connection.
+   *
+   *  This function should be called after a connection is disconnected
+   *  before that connection is reused.
+   */
+  reset: function reset() {
+    this._proto._reset(); // SASL
+
+
+    this.do_session = false;
+    this.do_bind = false; // handler lists
+
+    this.timedHandlers = [];
+    this.handlers = [];
+    this.removeTimeds = [];
+    this.removeHandlers = [];
+    this.addTimeds = [];
+    this.addHandlers = [];
+    this.authenticated = false;
+    this.connected = false;
+    this.disconnecting = false;
+    this.restored = false;
+    this._data = [];
+    this._requests = [];
+    this._uniqueId = 0;
+  },
+
+  /** Function: pause
+   *  Pause the request manager.
+   *
+   *  This will prevent Strophe from sending any more requests to the
+   *  server.  This is very useful for temporarily pausing
+   *  BOSH-Connections while a lot of send() calls are happening quickly.
+   *  This causes Strophe to send the data in a single request, saving
+   *  many request trips.
+   */
+  pause: function pause() {
+    this.paused = true;
+  },
+
+  /** Function: resume
+   *  Resume the request manager.
+   *
+   *  This resumes after pause() has been called.
+   */
+  resume: function resume() {
+    this.paused = false;
+  },
+
+  /** Function: getUniqueId
+   *  Generate a unique ID for use in <iq/> elements.
+   *
+   *  All <iq/> stanzas are required to have unique id attributes.  This
+   *  function makes creating these easy.  Each connection instance has
+   *  a counter which starts from zero, and the value of this counter
+   *  plus a colon followed by the suffix becomes the unique id. If no
+   *  suffix is supplied, the counter is used as the unique id.
+   *
+   *  Suffixes are used to make debugging easier when reading the stream
+   *  data, and their use is recommended.  The counter resets to 0 for
+   *  every new connection for the same reason.  For connections to the
+   *  same server that authenticate the same way, all the ids should be
+   *  the same, which makes it easy to see changes.  This is useful for
+   *  automated testing as well.
+   *
+   *  Parameters:
+   *    (String) suffix - A optional suffix to append to the id.
+   *
+   *  Returns:
+   *    A unique string to be used for the id attribute.
+   */
+  getUniqueId: function getUniqueId(suffix) {
+    var uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+      var r = Math.random() * 16 | 0,
+          v = c === 'x' ? r : r & 0x3 | 0x8;
+      return v.toString(16);
+    });
+
+    if (typeof suffix === "string" || typeof suffix === "number") {
+      return uuid + ":" + suffix;
+    } else {
+      return uuid + "";
+    }
+  },
+
+  /** Function: addProtocolErrorHandler
+   *  Register a handler function for when a protocol (websocker or HTTP)
+   *  error occurs.
+   *
+   *  NOTE: Currently only HTTP errors for BOSH requests are handled.
+   *  Patches that handle websocket errors would be very welcome.
+   *
+   *  Parameters:
+   *    (String) protocol - 'HTTP' or 'websocket'
+   *    (Integer) status_code - Error status code (e.g 500, 400 or 404)
+   *    (Function) callback - Function that will fire on Http error
+   *
+   *  Example:
+   *  function onError(err_code){
+   *    //do stuff
+   *  }
+   *
+   *  let conn = Strophe.connect('http://example.com/http-bind');
+   *  conn.addProtocolErrorHandler('HTTP', 500, onError);
+   *  // Triggers HTTP 500 error and onError handler will be called
+   *  conn.connect('user_jid@incorrect_jabber_host', 'secret', onConnect);
+   */
+  addProtocolErrorHandler: function addProtocolErrorHandler(protocol, status_code, callback) {
+    this.protocolErrorHandlers[protocol][status_code] = callback;
+  },
+
+  /** Function: connect
+   *  Starts the connection process.
+   *
+   *  As the connection process proceeds, the user supplied callback will
+   *  be triggered multiple times with status updates.  The callback
+   *  should take two arguments - the status code and the error condition.
+   *
+   *  The status code will be one of the values in the Strophe.Status
+   *  constants.  The error condition will be one of the conditions
+   *  defined in RFC 3920 or the condition 'strophe-parsererror'.
+   *
+   *  The Parameters _wait_, _hold_ and _route_ are optional and only relevant
+   *  for BOSH connections. Please see XEP 124 for a more detailed explanation
+   *  of the optional parameters.
+   *
+   *  Parameters:
+   *    (String) jid - The user's JID.  This may be a bare JID,
+   *      or a full JID.  If a node is not supplied, SASL OAUTHBEARER or
+   *      SASL ANONYMOUS authentication will be attempted (OAUTHBEARER will
+   *      process the provided password value as an access token).
+   *    (String) pass - The user's password.
+   *    (Function) callback - The connect callback function.
+   *    (Integer) wait - The optional HTTPBIND wait value.  This is the
+   *      time the server will wait before returning an empty result for
+   *      a request.  The default setting of 60 seconds is recommended.
+   *    (Integer) hold - The optional HTTPBIND hold value.  This is the
+   *      number of connections the server will hold at one time.  This
+   *      should almost always be set to 1 (the default).
+   *    (String) route - The optional route value.
+   *    (String) authcid - The optional alternative authentication identity
+   *      (username) if intending to impersonate another user.
+   *      When using the SASL-EXTERNAL authentication mechanism, for example
+   *      with client certificates, then the authcid value is used to
+   *      determine whether an authorization JID (authzid) should be sent to
+   *      the server. The authzid should not be sent to the server if the
+   *      authzid and authcid are the same. So to prevent it from being sent
+   *      (for example when the JID is already contained in the client
+   *      certificate), set authcid to that same JID. See XEP-178 for more
+   *      details.
+   */
+  connect: function connect(jid, pass, callback, wait, hold, route, authcid) {
+    this.jid = jid;
+    /** Variable: authzid
+     *  Authorization identity.
+     */
+
+    this.authzid = Strophe.getBareJidFromJid(this.jid);
+    /** Variable: authcid
+     *  Authentication identity (User name).
+     */
+
+    this.authcid = authcid || Strophe.getNodeFromJid(this.jid);
+    /** Variable: pass
+     *  Authentication identity (User password).
+     */
+
+    this.pass = pass;
+    /** Variable: servtype
+     *  Digest MD5 compatibility.
+     */
+
+    this.servtype = "xmpp";
+    this.connect_callback = callback;
+    this.disconnecting = false;
+    this.connected = false;
+    this.authenticated = false;
+    this.restored = false; // parse jid for domain
+
+    this.domain = Strophe.getDomainFromJid(this.jid);
+
+    this._changeConnectStatus(Strophe.Status.CONNECTING, null);
+
+    this._proto._connect(wait, hold, route);
+  },
+
+  /** Function: attach
+   *  Attach to an already created and authenticated BOSH session.
+   *
+   *  This function is provided to allow Strophe to attach to BOSH
+   *  sessions which have been created externally, perhaps by a Web
+   *  application.  This is often used to support auto-login type features
+   *  without putting user credentials into the page.
+   *
+   *  Parameters:
+   *    (String) jid - The full JID that is bound by the session.
+   *    (String) sid - The SID of the BOSH session.
+   *    (String) rid - The current RID of the BOSH session.  This RID
+   *      will be used by the next request.
+   *    (Function) callback The connect callback function.
+   *    (Integer) wait - The optional HTTPBIND wait value.  This is the
+   *      time the server will wait before returning an empty result for
+   *      a request.  The default setting of 60 seconds is recommended.
+   *      Other settings will require tweaks to the Strophe.TIMEOUT value.
+   *    (Integer) hold - The optional HTTPBIND hold value.  This is the
+   *      number of connections the server will hold at one time.  This
+   *      should almost always be set to 1 (the default).
+   *    (Integer) wind - The optional HTTBIND window value.  This is the
+   *      allowed range of request ids that are valid.  The default is 5.
+   */
+  attach: function attach(jid, sid, rid, callback, wait, hold, wind) {
+    if (this._proto instanceof Strophe.Bosh) {
+      this._proto._attach(jid, sid, rid, callback, wait, hold, wind);
+    } else {
+      var error = new Error('The "attach" method can only be used with a BOSH connection.');
+      error.name = 'StropheSessionError';
+      throw error;
+    }
+  },
+
+  /** Function: restore
+   *  Attempt to restore a cached BOSH session.
+   *
+   *  This function is only useful in conjunction with providing the
+   *  "keepalive":true option when instantiating a new Strophe.Connection.
+   *
+   *  When "keepalive" is set to true, Strophe will cache the BOSH tokens
+   *  RID (Request ID) and SID (Session ID) and then when this function is
+   *  called, it will attempt to restore the session from those cached
+   *  tokens.
+   *
+   *  This function must therefore be called instead of connect or attach.
+   *
+   *  For an example on how to use it, please see examples/restore.js
+   *
+   *  Parameters:
+   *    (String) jid - The user's JID.  This may be a bare JID or a full JID.
+   *    (Function) callback - The connect callback function.
+   *    (Integer) wait - The optional HTTPBIND wait value.  This is the
+   *      time the server will wait before returning an empty result for
+   *      a request.  The default setting of 60 seconds is recommended.
+   *    (Integer) hold - The optional HTTPBIND hold value.  This is the
+   *      number of connections the server will hold at one time.  This
+   *      should almost always be set to 1 (the default).
+   *    (Integer) wind - The optional HTTBIND window value.  This is the
+   *      allowed range of request ids that are valid.  The default is 5.
+   */
+  restore: function restore(jid, callback, wait, hold, wind) {
+    if (this._sessionCachingSupported()) {
+      this._proto._restore(jid, callback, wait, hold, wind);
+    } else {
+      var error = new Error('The "restore" method can only be used with a BOSH connection.');
+      error.name = 'StropheSessionError';
+      throw error;
+    }
+  },
+
+  /** PrivateFunction: _sessionCachingSupported
+   * Checks whether sessionStorage and JSON are supported and whether we're
+   * using BOSH.
+   */
+  _sessionCachingSupported: function _sessionCachingSupported() {
+    if (this._proto instanceof Strophe.Bosh) {
+      if (!JSON) {
+        return false;
+      }
+
+      try {
+        sessionStorage.setItem('_strophe_', '_strophe_');
+        sessionStorage.removeItem('_strophe_');
+      } catch (e) {
+        return false;
+      }
+
+      return true;
+    }
+
+    return false;
+  },
+
+  /** Function: xmlInput
+   *  User overrideable function that receives XML data coming into the
+   *  connection.
+   *
+   *  The default function does nothing.  User code can override this with
+   *  > Strophe.Connection.xmlInput = function (elem) {
+   *  >   (user code)
+   *  > };
+   *
+   *  Due to limitations of current Browsers' XML-Parsers the opening and closing
+   *  <stream> tag for WebSocket-Connoctions will be passed as selfclosing here.
+   *
+   *  BOSH-Connections will have all stanzas wrapped in a <body> tag. See
+   *  <Strophe.Bosh.strip> if you want to strip this tag.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - The XML data received by the connection.
+   */
+
+  /* jshint unused:false */
+  xmlInput: function xmlInput(elem) {
+    return;
+  },
+
+  /* jshint unused:true */
+
+  /** Function: xmlOutput
+   *  User overrideable function that receives XML data sent to the
+   *  connection.
+   *
+   *  The default function does nothing.  User code can override this with
+   *  > Strophe.Connection.xmlOutput = function (elem) {
+   *  >   (user code)
+   *  > };
+   *
+   *  Due to limitations of current Browsers' XML-Parsers the opening and closing
+   *  <stream> tag for WebSocket-Connoctions will be passed as selfclosing here.
+   *
+   *  BOSH-Connections will have all stanzas wrapped in a <body> tag. See
+   *  <Strophe.Bosh.strip> if you want to strip this tag.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - The XMLdata sent by the connection.
+   */
+
+  /* jshint unused:false */
+  xmlOutput: function xmlOutput(elem) {
+    return;
+  },
+
+  /* jshint unused:true */
+
+  /** Function: rawInput
+   *  User overrideable function that receives raw data coming into the
+   *  connection.
+   *
+   *  The default function does nothing.  User code can override this with
+   *  > Strophe.Connection.rawInput = function (data) {
+   *  >   (user code)
+   *  > };
+   *
+   *  Parameters:
+   *    (String) data - The data received by the connection.
+   */
+
+  /* jshint unused:false */
+  rawInput: function rawInput(data) {
+    return;
+  },
+
+  /* jshint unused:true */
+
+  /** Function: rawOutput
+   *  User overrideable function that receives raw data sent to the
+   *  connection.
+   *
+   *  The default function does nothing.  User code can override this with
+   *  > Strophe.Connection.rawOutput = function (data) {
+   *  >   (user code)
+   *  > };
+   *
+   *  Parameters:
+   *    (String) data - The data sent by the connection.
+   */
+
+  /* jshint unused:false */
+  rawOutput: function rawOutput(data) {
+    return;
+  },
+
+  /* jshint unused:true */
+
+  /** Function: nextValidRid
+   *  User overrideable function that receives the new valid rid.
+   *
+   *  The default function does nothing. User code can override this with
+   *  > Strophe.Connection.nextValidRid = function (rid) {
+   *  >    (user code)
+   *  > };
+   *
+   *  Parameters:
+   *    (Number) rid - The next valid rid
+   */
+
+  /* jshint unused:false */
+  nextValidRid: function nextValidRid(rid) {
+    return;
+  },
+
+  /* jshint unused:true */
+
+  /** Function: send
+   *  Send a stanza.
+   *
+   *  This function is called to push data onto the send queue to
+   *  go out over the wire.  Whenever a request is sent to the BOSH
+   *  server, all pending data is sent and the queue is flushed.
+   *
+   *  Parameters:
+   *    (XMLElement |
+   *     [XMLElement] |
+   *     Strophe.Builder) elem - The stanza to send.
+   */
+  send: function send(elem) {
+    if (elem === null) {
+      return;
+    }
+
+    if (typeof elem.sort === "function") {
+      for (var i = 0; i < elem.length; i++) {
+        this._queueData(elem[i]);
+      }
+    } else if (typeof elem.tree === "function") {
+      this._queueData(elem.tree());
+    } else {
+      this._queueData(elem);
+    }
+
+    this._proto._send();
+  },
+
+  /** Function: flush
+   *  Immediately send any pending outgoing data.
+   *
+   *  Normally send() queues outgoing data until the next idle period
+   *  (100ms), which optimizes network use in the common cases when
+   *  several send()s are called in succession. flush() can be used to
+   *  immediately send all pending data.
+   */
+  flush: function flush() {
+    // cancel the pending idle period and run the idle function
+    // immediately
+    clearTimeout(this._idleTimeout);
+
+    this._onIdle();
+  },
+
+  /** Function: sendPresence
+   *  Helper function to send presence stanzas. The main benefit is for
+   *  sending presence stanzas for which you expect a responding presence
+   *  stanza with the same id (for example when leaving a chat room).
+   *
+   *  Parameters:
+   *    (XMLElement) elem - The stanza to send.
+   *    (Function) callback - The callback function for a successful request.
+   *    (Function) errback - The callback function for a failed or timed
+   *      out request.  On timeout, the stanza will be null.
+   *    (Integer) timeout - The time specified in milliseconds for a
+   *      timeout to occur.
+   *
+   *  Returns:
+   *    The id used to send the presence.
+   */
+  sendPresence: function sendPresence(elem, callback, errback, timeout) {
+    var _this3 = this;
+
+    var timeoutHandler = null;
+
+    if (typeof elem.tree === "function") {
+      elem = elem.tree();
+    }
+
+    var id = elem.getAttribute('id');
+
+    if (!id) {
+      // inject id if not found
+      id = this.getUniqueId("sendPresence");
+      elem.setAttribute("id", id);
+    }
+
+    if (typeof callback === "function" || typeof errback === "function") {
+      var handler = this.addHandler(function (stanza) {
+        // remove timeout handler if there is one
+        if (timeoutHandler) {
+          _this3.deleteTimedHandler(timeoutHandler);
+        }
+
+        if (stanza.getAttribute('type') === 'error') {
+          if (errback) {
+            errback(stanza);
+          }
+        } else if (callback) {
+          callback(stanza);
+        }
+      }, null, 'presence', null, id); // if timeout specified, set up a timeout handler.
+
+      if (timeout) {
+        timeoutHandler = this.addTimedHandler(timeout, function () {
+          // get rid of normal handler
+          _this3.deleteHandler(handler); // call errback on timeout with null stanza
+
+
+          if (errback) {
+            errback(null);
+          }
+
+          return false;
+        });
+      }
+    }
+
+    this.send(elem);
+    return id;
+  },
+
+  /** Function: sendIQ
+   *  Helper function to send IQ stanzas.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - The stanza to send.
+   *    (Function) callback - The callback function for a successful request.
+   *    (Function) errback - The callback function for a failed or timed
+   *      out request.  On timeout, the stanza will be null.
+   *    (Integer) timeout - The time specified in milliseconds for a
+   *      timeout to occur.
+   *
+   *  Returns:
+   *    The id used to send the IQ.
+  */
+  sendIQ: function sendIQ(elem, callback, errback, timeout) {
+    var _this4 = this;
+
+    var timeoutHandler = null;
+
+    if (typeof elem.tree === "function") {
+      elem = elem.tree();
+    }
+
+    var id = elem.getAttribute('id');
+
+    if (!id) {
+      // inject id if not found
+      id = this.getUniqueId("sendIQ");
+      elem.setAttribute("id", id);
+    }
+
+    if (typeof callback === "function" || typeof errback === "function") {
+      var handler = this.addHandler(function (stanza) {
+        // remove timeout handler if there is one
+        if (timeoutHandler) {
+          _this4.deleteTimedHandler(timeoutHandler);
+        }
+
+        var iqtype = stanza.getAttribute('type');
+
+        if (iqtype === 'result') {
+          if (callback) {
+            callback(stanza);
+          }
+        } else if (iqtype === 'error') {
+          if (errback) {
+            errback(stanza);
+          }
+        } else {
+          var error = new Error("Got bad IQ type of ".concat(iqtype));
+          error.name = "StropheError";
+          throw error;
+        }
+      }, null, 'iq', ['error', 'result'], id); // if timeout specified, set up a timeout handler.
+
+      if (timeout) {
+        timeoutHandler = this.addTimedHandler(timeout, function () {
+          // get rid of normal handler
+          _this4.deleteHandler(handler); // call errback on timeout with null stanza
+
+
+          if (errback) {
+            errback(null);
+          }
+
+          return false;
+        });
+      }
+    }
+
+    this.send(elem);
+    return id;
+  },
+
+  /** PrivateFunction: _queueData
+   *  Queue outgoing data for later sending.  Also ensures that the data
+   *  is a DOMElement.
+   */
+  _queueData: function _queueData(element) {
+    if (element === null || !element.tagName || !element.childNodes) {
+      var error = new Error("Cannot queue non-DOMElement.");
+      error.name = "StropheError";
+      throw error;
+    }
+
+    this._data.push(element);
+  },
+
+  /** PrivateFunction: _sendRestart
+   *  Send an xmpp:restart stanza.
+   */
+  _sendRestart: function _sendRestart() {
+    var _this5 = this;
+
+    this._data.push("restart");
+
+    this._proto._sendRestart();
+
+    this._idleTimeout = setTimeout(function () {
+      return _this5._onIdle();
+    }, 100);
+  },
+
+  /** Function: addTimedHandler
+   *  Add a timed handler to the connection.
+   *
+   *  This function adds a timed handler.  The provided handler will
+   *  be called every period milliseconds until it returns false,
+   *  the connection is terminated, or the handler is removed.  Handlers
+   *  that wish to continue being invoked should return true.
+   *
+   *  Because of method binding it is necessary to save the result of
+   *  this function if you wish to remove a handler with
+   *  deleteTimedHandler().
+   *
+   *  Note that user handlers are not active until authentication is
+   *  successful.
+   *
+   *  Parameters:
+   *    (Integer) period - The period of the handler.
+   *    (Function) handler - The callback function.
+   *
+   *  Returns:
+   *    A reference to the handler that can be used to remove it.
+   */
+  addTimedHandler: function addTimedHandler(period, handler) {
+    var thand = new Strophe.TimedHandler(period, handler);
+    this.addTimeds.push(thand);
+    return thand;
+  },
+
+  /** Function: deleteTimedHandler
+   *  Delete a timed handler for a connection.
+   *
+   *  This function removes a timed handler from the connection.  The
+   *  handRef parameter is *not* the function passed to addTimedHandler(),
+   *  but is the reference returned from addTimedHandler().
+   *
+   *  Parameters:
+   *    (Strophe.TimedHandler) handRef - The handler reference.
+   */
+  deleteTimedHandler: function deleteTimedHandler(handRef) {
+    // this must be done in the Idle loop so that we don't change
+    // the handlers during iteration
+    this.removeTimeds.push(handRef);
+  },
+
+  /** Function: addHandler
+   *  Add a stanza handler for the connection.
+   *
+   *  This function adds a stanza handler to the connection.  The
+   *  handler callback will be called for any stanza that matches
+   *  the parameters.  Note that if multiple parameters are supplied,
+   *  they must all match for the handler to be invoked.
+   *
+   *  The handler will receive the stanza that triggered it as its argument.
+   *  *The handler should return true if it is to be invoked again;
+   *  returning false will remove the handler after it returns.*
+   *
+   *  As a convenience, the ns parameters applies to the top level element
+   *  and also any of its immediate children.  This is primarily to make
+   *  matching /iq/query elements easy.
+   *
+   *  Options
+   *  ~~~~~~~
+   *  With the options argument, you can specify boolean flags that affect how
+   *  matches are being done.
+   *
+   *  Currently two flags exist:
+   *
+   *  - matchBareFromJid:
+   *      When set to true, the from parameter and the
+   *      from attribute on the stanza will be matched as bare JIDs instead
+   *      of full JIDs. To use this, pass {matchBareFromJid: true} as the
+   *      value of options. The default value for matchBareFromJid is false.
+   *
+   *  - ignoreNamespaceFragment:
+   *      When set to true, a fragment specified on the stanza's namespace
+   *      URL will be ignored when it's matched with the one configured for
+   *      the handler.
+   *
+   *      This means that if you register like this:
+   *      >   connection.addHandler(
+   *      >       handler,
+   *      >       'http://jabber.org/protocol/muc',
+   *      >       null, null, null, null,
+   *      >       {'ignoreNamespaceFragment': true}
+   *      >   );
+   *
+   *      Then a stanza with XML namespace of
+   *      'http://jabber.org/protocol/muc#user' will also be matched. If
+   *      'ignoreNamespaceFragment' is false, then only stanzas with
+   *      'http://jabber.org/protocol/muc' will be matched.
+   *
+   *  Deleting the handler
+   *  ~~~~~~~~~~~~~~~~~~~~
+   *  The return value should be saved if you wish to remove the handler
+   *  with deleteHandler().
+   *
+   *  Parameters:
+   *    (Function) handler - The user callback.
+   *    (String) ns - The namespace to match.
+   *    (String) name - The stanza name to match.
+   *    (String|Array) type - The stanza type (or types if an array) to match.
+   *    (String) id - The stanza id attribute to match.
+   *    (String) from - The stanza from attribute to match.
+   *    (String) options - The handler options
+   *
+   *  Returns:
+   *    A reference to the handler that can be used to remove it.
+   */
+  addHandler: function addHandler(handler, ns, name, type, id, from, options) {
+    var hand = new Strophe.Handler(handler, ns, name, type, id, from, options);
+    this.addHandlers.push(hand);
+    return hand;
+  },
+
+  /** Function: deleteHandler
+   *  Delete a stanza handler for a connection.
+   *
+   *  This function removes a stanza handler from the connection.  The
+   *  handRef parameter is *not* the function passed to addHandler(),
+   *  but is the reference returned from addHandler().
+   *
+   *  Parameters:
+   *    (Strophe.Handler) handRef - The handler reference.
+   */
+  deleteHandler: function deleteHandler(handRef) {
+    // this must be done in the Idle loop so that we don't change
+    // the handlers during iteration
+    this.removeHandlers.push(handRef); // If a handler is being deleted while it is being added,
+    // prevent it from getting added
+
+    var i = this.addHandlers.indexOf(handRef);
+
+    if (i >= 0) {
+      this.addHandlers.splice(i, 1);
+    }
+  },
+
+  /** Function: registerSASLMechanisms
+   *
+   * Register the SASL mechanisms which will be supported by this instance of
+   * Strophe.Connection (i.e. which this XMPP client will support).
+   *
+   *  Parameters:
+   *    (Array) mechanisms - Array of objects with Strophe.SASLMechanism prototypes
+   *
+   */
+  registerSASLMechanisms: function registerSASLMechanisms(mechanisms) {
+    this.mechanisms = {};
+    mechanisms = mechanisms || [Strophe.SASLAnonymous, Strophe.SASLExternal, Strophe.SASLMD5, Strophe.SASLOAuthBearer, Strophe.SASLXOAuth2, Strophe.SASLPlain, Strophe.SASLSHA1];
+    mechanisms.forEach(this.registerSASLMechanism.bind(this));
+  },
+
+  /** Function: registerSASLMechanism
+   *
+   * Register a single SASL mechanism, to be supported by this client.
+   *
+   *  Parameters:
+   *    (Object) mechanism - Object with a Strophe.SASLMechanism prototype
+   *
+   */
+  registerSASLMechanism: function registerSASLMechanism(mechanism) {
+    this.mechanisms[mechanism.prototype.name] = mechanism;
+  },
+
+  /** Function: disconnect
+   *  Start the graceful disconnection process.
+   *
+   *  This function starts the disconnection process.  This process starts
+   *  by sending unavailable presence and sending BOSH body of type
+   *  terminate.  A timeout handler makes sure that disconnection happens
+   *  even if the BOSH server does not respond.
+   *  If the Connection object isn't connected, at least tries to abort all pending requests
+   *  so the connection object won't generate successful requests (which were already opened).
+   *
+   *  The user supplied connection callback will be notified of the
+   *  progress as this process happens.
+   *
+   *  Parameters:
+   *    (String) reason - The reason the disconnect is occuring.
+   */
+  disconnect: function disconnect(reason) {
+    this._changeConnectStatus(Strophe.Status.DISCONNECTING, reason);
+
+    Strophe.info("Disconnect was called because: " + reason);
+
+    if (this.connected) {
+      var pres = false;
+      this.disconnecting = true;
+
+      if (this.authenticated) {
+        pres = $pres({
+          'xmlns': Strophe.NS.CLIENT,
+          'type': 'unavailable'
+        });
+      } // setup timeout handler
+
+
+      this._disconnectTimeout = this._addSysTimedHandler(3000, this._onDisconnectTimeout.bind(this));
+
+      this._proto._disconnect(pres);
+    } else {
+      Strophe.info("Disconnect was called before Strophe connected to the server");
+
+      this._proto._abortAllRequests();
+
+      this._doDisconnect();
+    }
+  },
+
+  /** PrivateFunction: _changeConnectStatus
+   *  _Private_ helper function that makes sure plugins and the user's
+   *  callback are notified of connection status changes.
+   *
+   *  Parameters:
+   *    (Integer) status - the new connection status, one of the values
+   *      in Strophe.Status
+   *    (String) condition - the error condition or null
+   *    (XMLElement) elem - The triggering stanza.
+   */
+  _changeConnectStatus: function _changeConnectStatus(status, condition, elem) {
+    // notify all plugins listening for status changes
+    for (var k in Strophe._connectionPlugins) {
+      if (Object.prototype.hasOwnProperty.call(Strophe._connectionPlugins, k)) {
+        var plugin = this[k];
+
+        if (plugin.statusChanged) {
+          try {
+            plugin.statusChanged(status, condition);
+          } catch (err) {
+            Strophe.error("".concat(k, " plugin caused an exception changing status: ").concat(err));
+          }
+        }
+      }
+    } // notify the user's callback
+
+
+    if (this.connect_callback) {
+      try {
+        this.connect_callback(status, condition, elem);
+      } catch (e) {
+        Strophe._handleError(e);
+
+        Strophe.error("User connection callback caused an exception: ".concat(e));
+      }
+    }
+  },
+
+  /** PrivateFunction: _doDisconnect
+   *  _Private_ function to disconnect.
+   *
+   *  This is the last piece of the disconnection logic.  This resets the
+   *  connection and alerts the user's connection callback.
+   */
+  _doDisconnect: function _doDisconnect(condition) {
+    if (typeof this._idleTimeout === "number") {
+      clearTimeout(this._idleTimeout);
+    } // Cancel Disconnect Timeout
+
+
+    if (this._disconnectTimeout !== null) {
+      this.deleteTimedHandler(this._disconnectTimeout);
+      this._disconnectTimeout = null;
+    }
+
+    Strophe.info("_doDisconnect was called");
+
+    this._proto._doDisconnect();
+
+    this.authenticated = false;
+    this.disconnecting = false;
+    this.restored = false; // delete handlers
+
+    this.handlers = [];
+    this.timedHandlers = [];
+    this.removeTimeds = [];
+    this.removeHandlers = [];
+    this.addTimeds = [];
+    this.addHandlers = []; // tell the parent we disconnected
+
+    this._changeConnectStatus(Strophe.Status.DISCONNECTED, condition);
+
+    this.connected = false;
+  },
+
+  /** PrivateFunction: _dataRecv
+   *  _Private_ handler to processes incoming data from the the connection.
+   *
+   *  Except for _connect_cb handling the initial connection request,
+   *  this function handles the incoming data for all requests.  This
+   *  function also fires stanza handlers that match each incoming
+   *  stanza.
+   *
+   *  Parameters:
+   *    (Strophe.Request) req - The request that has data ready.
+   *    (string) req - The stanza a raw string (optiona).
+   */
+  _dataRecv: function _dataRecv(req, raw) {
+    var _this6 = this;
+
+    Strophe.info("_dataRecv called");
+
+    var elem = this._proto._reqToData(req);
+
+    if (elem === null) {
+      return;
+    }
+
+    if (this.xmlInput !== Strophe.Connection.prototype.xmlInput) {
+      if (elem.nodeName === this._proto.strip && elem.childNodes.length) {
+        this.xmlInput(elem.childNodes[0]);
+      } else {
+        this.xmlInput(elem);
+      }
+    }
+
+    if (this.rawInput !== Strophe.Connection.prototype.rawInput) {
+      if (raw) {
+        this.rawInput(raw);
+      } else {
+        this.rawInput(Strophe.serialize(elem));
+      }
+    } // remove handlers scheduled for deletion
+
+
+    while (this.removeHandlers.length > 0) {
+      var hand = this.removeHandlers.pop();
+      var i = this.handlers.indexOf(hand);
+
+      if (i >= 0) {
+        this.handlers.splice(i, 1);
+      }
+    } // add handlers scheduled for addition
+
+
+    while (this.addHandlers.length > 0) {
+      this.handlers.push(this.addHandlers.pop());
+    } // handle graceful disconnect
+
+
+    if (this.disconnecting && this._proto._emptyQueue()) {
+      this._doDisconnect();
+
+      return;
+    }
+
+    var type = elem.getAttribute("type");
+
+    if (type !== null && type === "terminate") {
+      // Don't process stanzas that come in after disconnect
+      if (this.disconnecting) {
+        return;
+      } // an error occurred
+
+
+      var cond = elem.getAttribute("condition");
+      var conflict = elem.getElementsByTagName("conflict");
+
+      if (cond !== null) {
+        if (cond === "remote-stream-error" && conflict.length > 0) {
+          cond = "conflict";
+        }
+
+        this._changeConnectStatus(Strophe.Status.CONNFAIL, cond);
+      } else {
+        this._changeConnectStatus(Strophe.Status.CONNFAIL, Strophe.ErrorCondition.UNKOWN_REASON);
+      }
+
+      this._doDisconnect(cond);
+
+      return;
+    } // send each incoming stanza through the handler chain
+
+
+    Strophe.forEachChild(elem, null, function (child) {
+      // process handlers
+      var newList = _this6.handlers;
+      _this6.handlers = [];
+
+      for (var _i5 = 0; _i5 < newList.length; _i5++) {
+        var _hand = newList[_i5]; // encapsulate 'handler.run' not to lose the whole handler list if
+        // one of the handlers throws an exception
+
+        try {
+          if (_hand.isMatch(child) && (_this6.authenticated || !_hand.user)) {
+            if (_hand.run(child)) {
+              _this6.handlers.push(_hand);
+            }
+          } else {
+            _this6.handlers.push(_hand);
+          }
+        } catch (e) {
+          // if the handler throws an exception, we consider it as false
+          Strophe.warn('Removing Strophe handlers due to uncaught exception: ' + e.message);
+        }
+      }
+    });
+  },
+
+  /** Attribute: mechanisms
+   *  SASL Mechanisms available for Connection.
+   */
+  mechanisms: {},
+
+  /** PrivateFunction: _connect_cb
+   *  _Private_ handler for initial connection request.
+   *
+   *  This handler is used to process the initial connection request
+   *  response from the BOSH server. It is used to set up authentication
+   *  handlers and start the authentication process.
+   *
+   *  SASL authentication will be attempted if available, otherwise
+   *  the code will fall back to legacy authentication.
+   *
+   *  Parameters:
+   *    (Strophe.Request) req - The current request.
+   *    (Function) _callback - low level (xmpp) connect callback function.
+   *      Useful for plugins with their own xmpp connect callback (when they
+   *      want to do something special).
+   */
+  _connect_cb: function _connect_cb(req, _callback, raw) {
+    Strophe.info("_connect_cb was called");
+    this.connected = true;
+    var bodyWrap;
+
+    try {
+      bodyWrap = this._proto._reqToData(req);
+    } catch (e) {
+      if (e.name !== Strophe.ErrorCondition.BAD_FORMAT) {
+        throw e;
+      }
+
+      this._changeConnectStatus(Strophe.Status.CONNFAIL, Strophe.ErrorCondition.BAD_FORMAT);
+
+      this._doDisconnect(Strophe.ErrorCondition.BAD_FORMAT);
+    }
+
+    if (!bodyWrap) {
+      return;
+    }
+
+    if (this.xmlInput !== Strophe.Connection.prototype.xmlInput) {
+      if (bodyWrap.nodeName === this._proto.strip && bodyWrap.childNodes.length) {
+        this.xmlInput(bodyWrap.childNodes[0]);
+      } else {
+        this.xmlInput(bodyWrap);
+      }
+    }
+
+    if (this.rawInput !== Strophe.Connection.prototype.rawInput) {
+      if (raw) {
+        this.rawInput(raw);
+      } else {
+        this.rawInput(Strophe.serialize(bodyWrap));
+      }
+    }
+
+    var conncheck = this._proto._connect_cb(bodyWrap);
+
+    if (conncheck === Strophe.Status.CONNFAIL) {
+      return;
+    } // Check for the stream:features tag
+
+
+    var hasFeatures;
+
+    if (bodyWrap.getElementsByTagNameNS) {
+      hasFeatures = bodyWrap.getElementsByTagNameNS(Strophe.NS.STREAM, "features").length > 0;
+    } else {
+      hasFeatures = bodyWrap.getElementsByTagName("stream:features").length > 0 || bodyWrap.getElementsByTagName("features").length > 0;
+    }
+
+    if (!hasFeatures) {
+      this._proto._no_auth_received(_callback);
+
+      return;
+    }
+
+    var matched = [];
+    var mechanisms = bodyWrap.getElementsByTagName("mechanism");
+
+    if (mechanisms.length > 0) {
+      for (var i = 0; i < mechanisms.length; i++) {
+        var mech = Strophe.getText(mechanisms[i]);
+        if (this.mechanisms[mech]) matched.push(this.mechanisms[mech]);
+      }
+    }
+
+    if (matched.length === 0) {
+      if (bodyWrap.getElementsByTagName("auth").length === 0) {
+        // There are no matching SASL mechanisms and also no legacy
+        // auth available.
+        this._proto._no_auth_received(_callback);
+
+        return;
+      }
+    }
+
+    if (this.do_authentication !== false) {
+      this.authenticate(matched);
+    }
+  },
+
+  /** Function: sortMechanismsByPriority
+   *
+   *  Sorts an array of objects with prototype SASLMechanism according to
+   *  their priorities.
+   *
+   *  Parameters:
+   *    (Array) mechanisms - Array of SASL mechanisms.
+   *
+   */
+  sortMechanismsByPriority: function sortMechanismsByPriority(mechanisms) {
+    // Sorting mechanisms according to priority.
+    for (var i = 0; i < mechanisms.length - 1; ++i) {
+      var higher = i;
+
+      for (var j = i + 1; j < mechanisms.length; ++j) {
+        if (mechanisms[j].prototype.priority > mechanisms[higher].prototype.priority) {
+          higher = j;
+        }
+      }
+
+      if (higher !== i) {
+        var swap = mechanisms[i];
+        mechanisms[i] = mechanisms[higher];
+        mechanisms[higher] = swap;
+      }
+    }
+
+    return mechanisms;
+  },
+
+  /** PrivateFunction: _attemptSASLAuth
+   *
+   *  Iterate through an array of SASL mechanisms and attempt authentication
+   *  with the highest priority (enabled) mechanism.
+   *
+   *  Parameters:
+   *    (Array) mechanisms - Array of SASL mechanisms.
+   *
+   *  Returns:
+   *    (Boolean) mechanism_found - true or false, depending on whether a
+   *          valid SASL mechanism was found with which authentication could be
+   *          started.
+   */
+  _attemptSASLAuth: function _attemptSASLAuth(mechanisms) {
+    mechanisms = this.sortMechanismsByPriority(mechanisms || []);
+    var mechanism_found = false;
+
+    for (var i = 0; i < mechanisms.length; ++i) {
+      if (!mechanisms[i].prototype.test(this)) {
+        continue;
+      }
+
+      this._sasl_success_handler = this._addSysHandler(this._sasl_success_cb.bind(this), null, "success", null, null);
+      this._sasl_failure_handler = this._addSysHandler(this._sasl_failure_cb.bind(this), null, "failure", null, null);
+      this._sasl_challenge_handler = this._addSysHandler(this._sasl_challenge_cb.bind(this), null, "challenge", null, null);
+      this._sasl_mechanism = new mechanisms[i]();
+
+      this._sasl_mechanism.onStart(this);
+
+      var request_auth_exchange = $build("auth", {
+        'xmlns': Strophe.NS.SASL,
+        'mechanism': this._sasl_mechanism.name
+      });
+
+      if (this._sasl_mechanism.isClientFirst) {
+        var response = this._sasl_mechanism.onChallenge(this, null);
+
+        request_auth_exchange.t(btoa(response));
+      }
+
+      this.send(request_auth_exchange.tree());
+      mechanism_found = true;
+      break;
+    }
+
+    return mechanism_found;
+  },
+
+  /** PrivateFunction: _attemptLegacyAuth
+   *
+   *  Attempt legacy (i.e. non-SASL) authentication.
+   *
+   */
+  _attemptLegacyAuth: function _attemptLegacyAuth() {
+    if (Strophe.getNodeFromJid(this.jid) === null) {
+      // we don't have a node, which is required for non-anonymous
+      // client connections
+      this._changeConnectStatus(Strophe.Status.CONNFAIL, Strophe.ErrorCondition.MISSING_JID_NODE);
+
+      this.disconnect(Strophe.ErrorCondition.MISSING_JID_NODE);
+    } else {
+      // Fall back to legacy authentication
+      this._changeConnectStatus(Strophe.Status.AUTHENTICATING, null);
+
+      this._addSysHandler(this._auth1_cb.bind(this), null, null, null, "_auth_1");
+
+      this.send($iq({
+        'type': "get",
+        'to': this.domain,
+        'id': "_auth_1"
+      }).c("query", {
+        xmlns: Strophe.NS.AUTH
+      }).c("username", {}).t(Strophe.getNodeFromJid(this.jid)).tree());
+    }
+  },
+
+  /** Function: authenticate
+   * Set up authentication
+   *
+   *  Continues the initial connection request by setting up authentication
+   *  handlers and starting the authentication process.
+   *
+   *  SASL authentication will be attempted if available, otherwise
+   *  the code will fall back to legacy authentication.
+   *
+   *  Parameters:
+   *    (Array) matched - Array of SASL mechanisms supported.
+   *
+   */
+  authenticate: function authenticate(matched) {
+    if (!this._attemptSASLAuth(matched)) {
+      this._attemptLegacyAuth();
+    }
+  },
+
+  /** PrivateFunction: _sasl_challenge_cb
+   *  _Private_ handler for the SASL challenge
+   *
+   */
+  _sasl_challenge_cb: function _sasl_challenge_cb(elem) {
+    var challenge = atob(Strophe.getText(elem));
+
+    var response = this._sasl_mechanism.onChallenge(this, challenge);
+
+    var stanza = $build('response', {
+      'xmlns': Strophe.NS.SASL
+    });
+
+    if (response !== "") {
+      stanza.t(btoa(response));
+    }
+
+    this.send(stanza.tree());
+    return true;
+  },
+
+  /** PrivateFunction: _auth1_cb
+   *  _Private_ handler for legacy authentication.
+   *
+   *  This handler is called in response to the initial <iq type='get'/>
+   *  for legacy authentication.  It builds an authentication <iq/> and
+   *  sends it, creating a handler (calling back to _auth2_cb()) to
+   *  handle the result
+   *
+   *  Parameters:
+   *    (XMLElement) elem - The stanza that triggered the callback.
+   *
+   *  Returns:
+   *    false to remove the handler.
+   */
+
+  /* jshint unused:false */
+  _auth1_cb: function _auth1_cb(elem) {
+    // build plaintext auth iq
+    var iq = $iq({
+      type: "set",
+      id: "_auth_2"
+    }).c('query', {
+      xmlns: Strophe.NS.AUTH
+    }).c('username', {}).t(Strophe.getNodeFromJid(this.jid)).up().c('password').t(this.pass);
+
+    if (!Strophe.getResourceFromJid(this.jid)) {
+      // since the user has not supplied a resource, we pick
+      // a default one here.  unlike other auth methods, the server
+      // cannot do this for us.
+      this.jid = Strophe.getBareJidFromJid(this.jid) + '/strophe';
+    }
+
+    iq.up().c('resource', {}).t(Strophe.getResourceFromJid(this.jid));
+
+    this._addSysHandler(this._auth2_cb.bind(this), null, null, null, "_auth_2");
+
+    this.send(iq.tree());
+    return false;
+  },
+
+  /* jshint unused:true */
+
+  /** PrivateFunction: _sasl_success_cb
+   *  _Private_ handler for succesful SASL authentication.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - The matching stanza.
+   *
+   *  Returns:
+   *    false to remove the handler.
+   */
+  _sasl_success_cb: function _sasl_success_cb(elem) {
+    var _this7 = this;
+
+    if (this._sasl_data["server-signature"]) {
+      var serverSignature;
+      var success = atob(Strophe.getText(elem));
+      var attribMatch = /([a-z]+)=([^,]+)(,|$)/;
+      var matches = success.match(attribMatch);
+
+      if (matches[1] === "v") {
+        serverSignature = matches[2];
+      }
+
+      if (serverSignature !== this._sasl_data["server-signature"]) {
+        // remove old handlers
+        this.deleteHandler(this._sasl_failure_handler);
+        this._sasl_failure_handler = null;
+
+        if (this._sasl_challenge_handler) {
+          this.deleteHandler(this._sasl_challenge_handler);
+          this._sasl_challenge_handler = null;
+        }
+
+        this._sasl_data = {};
+        return this._sasl_failure_cb(null);
+      }
+    }
+
+    Strophe.info("SASL authentication succeeded.");
+
+    if (this._sasl_mechanism) {
+      this._sasl_mechanism.onSuccess();
+    } // remove old handlers
+
+
+    this.deleteHandler(this._sasl_failure_handler);
+    this._sasl_failure_handler = null;
+
+    if (this._sasl_challenge_handler) {
+      this.deleteHandler(this._sasl_challenge_handler);
+      this._sasl_challenge_handler = null;
+    }
+
+    var streamfeature_handlers = [];
+
+    var wrapper = function wrapper(handlers, elem) {
+      while (handlers.length) {
+        _this7.deleteHandler(handlers.pop());
+      }
+
+      _this7._sasl_auth1_cb(elem);
+
+      return false;
+    };
+
+    streamfeature_handlers.push(this._addSysHandler(function (elem) {
+      return wrapper(streamfeature_handlers, elem);
+    }, null, "stream:features", null, null));
+    streamfeature_handlers.push(this._addSysHandler(function (elem) {
+      return wrapper(streamfeature_handlers, elem);
+    }, Strophe.NS.STREAM, "features", null, null)); // we must send an xmpp:restart now
+
+    this._sendRestart();
+
+    return false;
+  },
+
+  /** PrivateFunction: _sasl_auth1_cb
+   *  _Private_ handler to start stream binding.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - The matching stanza.
+   *
+   *  Returns:
+   *    false to remove the handler.
+   */
+  _sasl_auth1_cb: function _sasl_auth1_cb(elem) {
+    // save stream:features for future usage
+    this.features = elem;
+
+    for (var i = 0; i < elem.childNodes.length; i++) {
+      var child = elem.childNodes[i];
+
+      if (child.nodeName === 'bind') {
+        this.do_bind = true;
+      }
+
+      if (child.nodeName === 'session') {
+        this.do_session = true;
+      }
+    }
+
+    if (!this.do_bind) {
+      this._changeConnectStatus(Strophe.Status.AUTHFAIL, null);
+
+      return false;
+    } else {
+      this._addSysHandler(this._sasl_bind_cb.bind(this), null, null, null, "_bind_auth_2");
+
+      var resource = Strophe.getResourceFromJid(this.jid);
+
+      if (resource) {
+        this.send($iq({
+          type: "set",
+          id: "_bind_auth_2"
+        }).c('bind', {
+          xmlns: Strophe.NS.BIND
+        }).c('resource', {}).t(resource).tree());
+      } else {
+        this.send($iq({
+          type: "set",
+          id: "_bind_auth_2"
+        }).c('bind', {
+          xmlns: Strophe.NS.BIND
+        }).tree());
+      }
+    }
+
+    return false;
+  },
+
+  /** PrivateFunction: _sasl_bind_cb
+   *  _Private_ handler for binding result and session start.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - The matching stanza.
+   *
+   *  Returns:
+   *    false to remove the handler.
+   */
+  _sasl_bind_cb: function _sasl_bind_cb(elem) {
+    if (elem.getAttribute("type") === "error") {
+      Strophe.info("SASL binding failed.");
+      var conflict = elem.getElementsByTagName("conflict");
+      var condition;
+
+      if (conflict.length > 0) {
+        condition = Strophe.ErrorCondition.CONFLICT;
+      }
+
+      this._changeConnectStatus(Strophe.Status.AUTHFAIL, condition, elem);
+
+      return false;
+    } // TODO - need to grab errors
+
+
+    var bind = elem.getElementsByTagName("bind");
+
+    if (bind.length > 0) {
+      var jidNode = bind[0].getElementsByTagName("jid");
+
+      if (jidNode.length > 0) {
+        this.jid = Strophe.getText(jidNode[0]);
+
+        if (this.do_session) {
+          this._addSysHandler(this._sasl_session_cb.bind(this), null, null, null, "_session_auth_2");
+
+          this.send($iq({
+            type: "set",
+            id: "_session_auth_2"
+          }).c('session', {
+            xmlns: Strophe.NS.SESSION
+          }).tree());
+        } else {
+          this.authenticated = true;
+
+          this._changeConnectStatus(Strophe.Status.CONNECTED, null);
+        }
+      }
+    } else {
+      Strophe.info("SASL binding failed.");
+
+      this._changeConnectStatus(Strophe.Status.AUTHFAIL, null, elem);
+
+      return false;
+    }
+  },
+
+  /** PrivateFunction: _sasl_session_cb
+   *  _Private_ handler to finish successful SASL connection.
+   *
+   *  This sets Connection.authenticated to true on success, which
+   *  starts the processing of user handlers.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - The matching stanza.
+   *
+   *  Returns:
+   *    false to remove the handler.
+   */
+  _sasl_session_cb: function _sasl_session_cb(elem) {
+    if (elem.getAttribute("type") === "result") {
+      this.authenticated = true;
+
+      this._changeConnectStatus(Strophe.Status.CONNECTED, null);
+    } else if (elem.getAttribute("type") === "error") {
+      Strophe.info("Session creation failed.");
+
+      this._changeConnectStatus(Strophe.Status.AUTHFAIL, null, elem);
+
+      return false;
+    }
+
+    return false;
+  },
+
+  /** PrivateFunction: _sasl_failure_cb
+   *  _Private_ handler for SASL authentication failure.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - The matching stanza.
+   *
+   *  Returns:
+   *    false to remove the handler.
+   */
+
+  /* jshint unused:false */
+  _sasl_failure_cb: function _sasl_failure_cb(elem) {
+    // delete unneeded handlers
+    if (this._sasl_success_handler) {
+      this.deleteHandler(this._sasl_success_handler);
+      this._sasl_success_handler = null;
+    }
+
+    if (this._sasl_challenge_handler) {
+      this.deleteHandler(this._sasl_challenge_handler);
+      this._sasl_challenge_handler = null;
+    }
+
+    if (this._sasl_mechanism) this._sasl_mechanism.onFailure();
+
+    this._changeConnectStatus(Strophe.Status.AUTHFAIL, null, elem);
+
+    return false;
+  },
+
+  /* jshint unused:true */
+
+  /** PrivateFunction: _auth2_cb
+   *  _Private_ handler to finish legacy authentication.
+   *
+   *  This handler is called when the result from the jabber:iq:auth
+   *  <iq/> stanza is returned.
+   *
+   *  Parameters:
+   *    (XMLElement) elem - The stanza that triggered the callback.
+   *
+   *  Returns:
+   *    false to remove the handler.
+   */
+  _auth2_cb: function _auth2_cb(elem) {
+    if (elem.getAttribute("type") === "result") {
+      this.authenticated = true;
+
+      this._changeConnectStatus(Strophe.Status.CONNECTED, null);
+    } else if (elem.getAttribute("type") === "error") {
+      this._changeConnectStatus(Strophe.Status.AUTHFAIL, null, elem);
+
+      this.disconnect('authentication failed');
+    }
+
+    return false;
+  },
+
+  /** PrivateFunction: _addSysTimedHandler
+   *  _Private_ function to add a system level timed handler.
+   *
+   *  This function is used to add a Strophe.TimedHandler for the
+   *  library code.  System timed handlers are allowed to run before
+   *  authentication is complete.
+   *
+   *  Parameters:
+   *    (Integer) period - The period of the handler.
+   *    (Function) handler - The callback function.
+   */
+  _addSysTimedHandler: function _addSysTimedHandler(period, handler) {
+    var thand = new Strophe.TimedHandler(period, handler);
+    thand.user = false;
+    this.addTimeds.push(thand);
+    return thand;
+  },
+
+  /** PrivateFunction: _addSysHandler
+   *  _Private_ function to add a system level stanza handler.
+   *
+   *  This function is used to add a Strophe.Handler for the
+   *  library code.  System stanza handlers are allowed to run before
+   *  authentication is complete.
+   *
+   *  Parameters:
+   *    (Function) handler - The callback function.
+   *    (String) ns - The namespace to match.
+   *    (String) name - The stanza name to match.
+   *    (String) type - The stanza type attribute to match.
+   *    (String) id - The stanza id attribute to match.
+   */
+  _addSysHandler: function _addSysHandler(handler, ns, name, type, id) {
+    var hand = new Strophe.Handler(handler, ns, name, type, id);
+    hand.user = false;
+    this.addHandlers.push(hand);
+    return hand;
+  },
+
+  /** PrivateFunction: _onDisconnectTimeout
+   *  _Private_ timeout handler for handling non-graceful disconnection.
+   *
+   *  If the graceful disconnect process does not complete within the
+   *  time allotted, this handler finishes the disconnect anyway.
+   *
+   *  Returns:
+   *    false to remove the handler.
+   */
+  _onDisconnectTimeout: function _onDisconnectTimeout() {
+    Strophe.info("_onDisconnectTimeout was called");
+
+    this._changeConnectStatus(Strophe.Status.CONNTIMEOUT, null);
+
+    this._proto._onDisconnectTimeout(); // actually disconnect
+
+
+    this._doDisconnect();
+
+    return false;
+  },
+
+  /** PrivateFunction: _onIdle
+   *  _Private_ handler to process events during idle cycle.
+   *
+   *  This handler is called every 100ms to fire timed handlers that
+   *  are ready and keep poll requests going.
+   */
+  _onIdle: function _onIdle() {
+    var _this8 = this;
+
+    // add timed handlers scheduled for addition
+    // NOTE: we add before remove in the case a timed handler is
+    // added and then deleted before the next _onIdle() call.
+    while (this.addTimeds.length > 0) {
+      this.timedHandlers.push(this.addTimeds.pop());
+    } // remove timed handlers that have been scheduled for deletion
+
+
+    while (this.removeTimeds.length > 0) {
+      var thand = this.removeTimeds.pop();
+      var i = this.timedHandlers.indexOf(thand);
+
+      if (i >= 0) {
+        this.timedHandlers.splice(i, 1);
+      }
+    } // call ready timed handlers
+
+
+    var now = new Date().getTime();
+    var newList = [];
+
+    for (var _i6 = 0; _i6 < this.timedHandlers.length; _i6++) {
+      var _thand = this.timedHandlers[_i6];
+
+      if (this.authenticated || !_thand.user) {
+        var since = _thand.lastCalled + _thand.period;
+
+        if (since - now <= 0) {
+          if (_thand.run()) {
+            newList.push(_thand);
+          }
+        } else {
+          newList.push(_thand);
+        }
+      }
+    }
+
+    this.timedHandlers = newList;
+    clearTimeout(this._idleTimeout);
+
+    this._proto._onIdle(); // reactivate the timer only if connected
+
+
+    if (this.connected) {
+      this._idleTimeout = setTimeout(function () {
+        return _this8._onIdle();
+      }, 100);
+    }
+  }
+};
+/** Class: Strophe.SASLMechanism
+ *
+ *  encapsulates SASL authentication mechanisms.
+ *
+ *  User code may override the priority for each mechanism or disable it completely.
+ *  See <priority> for information about changing priority and <test> for informatian on
+ *  how to disable a mechanism.
+ *
+ *  By default, all mechanisms are enabled and the priorities are
+ *
+ *      OAUTHBEARER - 60
+ *      SCRAM-SHA1 - 50
+ *      DIGEST-MD5 - 40
+ *      PLAIN - 30
+ *      ANONYMOUS - 20
+ *      EXTERNAL - 10
+ *
+ *  See: Strophe.Connection.addSupportedSASLMechanisms
+ */
+
+/**
+ * PrivateConstructor: Strophe.SASLMechanism
+ * SASL auth mechanism abstraction.
+ *
+ *  Parameters:
+ *    (String) name - SASL Mechanism name.
+ *    (Boolean) isClientFirst - If client should send response first without challenge.
+ *    (Number) priority - Priority.
+ *
+ *  Returns:
+ *    A new Strophe.SASLMechanism object.
+ */
+
+Strophe.SASLMechanism = function (name, isClientFirst, priority) {
+  /** PrivateVariable: name
+   *  Mechanism name.
+   */
+  this.name = name;
+  /** PrivateVariable: isClientFirst
+   *  If client sends response without initial server challenge.
+   */
+
+  this.isClientFirst = isClientFirst;
+  /** Variable: priority
+   *  Determines which <SASLMechanism> is chosen for authentication (Higher is better).
+   *  Users may override this to prioritize mechanisms differently.
+   *
+   *  In the default configuration the priorities are
+   *
+   *  SCRAM-SHA1 - 40
+   *  DIGEST-MD5 - 30
+   *  Plain - 20
+   *
+   *  Example: (This will cause Strophe to choose the mechanism that the server sent first)
+   *
+   *  > Strophe.SASLMD5.priority = Strophe.SASLSHA1.priority;
+   *
+   *  See <SASL mechanisms> for a list of available mechanisms.
+   *
+   */
+
+  this.priority = priority;
+};
+
+Strophe.SASLMechanism.prototype = {
+  /**
+   *  Function: test
+   *  Checks if mechanism able to run.
+   *  To disable a mechanism, make this return false;
+   *
+   *  To disable plain authentication run
+   *  > Strophe.SASLPlain.test = function() {
+   *  >   return false;
+   *  > }
+   *
+   *  See <SASL mechanisms> for a list of available mechanisms.
+   *
+   *  Parameters:
+   *    (Strophe.Connection) connection - Target Connection.
+   *
+   *  Returns:
+   *    (Boolean) If mechanism was able to run.
+   */
+
+  /* jshint unused:false */
+  test: function test(connection) {
+    return true;
+  },
+
+  /* jshint unused:true */
+
+  /** PrivateFunction: onStart
+   *  Called before starting mechanism on some connection.
+   *
+   *  Parameters:
+   *    (Strophe.Connection) connection - Target Connection.
+   */
+  onStart: function onStart(connection) {
+    this._connection = connection;
+  },
+
+  /** PrivateFunction: onChallenge
+   *  Called by protocol implementation on incoming challenge. If client is
+   *  first (isClientFirst === true) challenge will be null on the first call.
+   *
+   *  Parameters:
+   *    (Strophe.Connection) connection - Target Connection.
+   *    (String) challenge - current challenge to handle.
+   *
+   *  Returns:
+   *    (String) Mechanism response.
+   */
+
+  /* jshint unused:false */
+  onChallenge: function onChallenge(connection, challenge) {
+    throw new Error("You should implement challenge handling!");
+  },
+
+  /* jshint unused:true */
+
+  /** PrivateFunction: onFailure
+   *  Protocol informs mechanism implementation about SASL failure.
+   */
+  onFailure: function onFailure() {
+    this._connection = null;
+  },
+
+  /** PrivateFunction: onSuccess
+   *  Protocol informs mechanism implementation about SASL success.
+   */
+  onSuccess: function onSuccess() {
+    this._connection = null;
+  }
+};
+/** Constants: SASL mechanisms
+ *  Available authentication mechanisms
+ *
+ *  Strophe.SASLAnonymous - SASL ANONYMOUS authentication.
+ *  Strophe.SASLPlain - SASL PLAIN authentication.
+ *  Strophe.SASLMD5 - SASL DIGEST-MD5 authentication
+ *  Strophe.SASLSHA1 - SASL SCRAM-SHA1 authentication
+ *  Strophe.SASLOAuthBearer - SASL OAuth Bearer authentication
+ *  Strophe.SASLExternal - SASL EXTERNAL authentication
+ *  Strophe.SASLXOAuth2 - SASL X-OAuth2 authentication
+ */
+// Building SASL callbacks
+
+/** PrivateConstructor: SASLAnonymous
+ *  SASL ANONYMOUS authentication.
+ */
+
+Strophe.SASLAnonymous = function () {};
+
+Strophe.SASLAnonymous.prototype = new Strophe.SASLMechanism("ANONYMOUS", false, 20);
+
+Strophe.SASLAnonymous.prototype.test = function (connection) {
+  return connection.authcid === null;
+};
+/** PrivateConstructor: SASLPlain
+ *  SASL PLAIN authentication.
+ */
+
+
+Strophe.SASLPlain = function () {};
+
+Strophe.SASLPlain.prototype = new Strophe.SASLMechanism("PLAIN", true, 50);
+
+Strophe.SASLPlain.prototype.test = function (connection) {
+  return connection.authcid !== null;
+};
+
+Strophe.SASLPlain.prototype.onChallenge = function (connection) {
+  var auth_str = connection.authzid;
+  auth_str = auth_str + "\0";
+  auth_str = auth_str + connection.authcid;
+  auth_str = auth_str + "\0";
+  auth_str = auth_str + connection.pass;
+  return utils__WEBPACK_IMPORTED_MODULE_2__["default"].utf16to8(auth_str);
+};
+/** PrivateConstructor: SASLSHA1
+ *  SASL SCRAM SHA 1 authentication.
+ */
+
+
+Strophe.SASLSHA1 = function () {};
+
+Strophe.SASLSHA1.prototype = new Strophe.SASLMechanism("SCRAM-SHA-1", true, 70);
+
+Strophe.SASLSHA1.prototype.test = function (connection) {
+  return connection.authcid !== null;
+};
+
+Strophe.SASLSHA1.prototype.onChallenge = function (connection, challenge, test_cnonce) {
+  var cnonce = test_cnonce || md5__WEBPACK_IMPORTED_MODULE_0__["default"].hexdigest(Math.random() * 1234567890);
+  var auth_str = "n=" + utils__WEBPACK_IMPORTED_MODULE_2__["default"].utf16to8(connection.authcid);
+  auth_str += ",r=";
+  auth_str += cnonce;
+  connection._sasl_data.cnonce = cnonce;
+  connection._sasl_data["client-first-message-bare"] = auth_str;
+  auth_str = "n,," + auth_str;
+
+  this.onChallenge = function (connection, challenge) {
+    var nonce, salt, iter, Hi, U, U_old, i, k;
+    var responseText = "c=biws,";
+    var authMessage = "".concat(connection._sasl_data["client-first-message-bare"], ",").concat(challenge, ",");
+    var cnonce = connection._sasl_data.cnonce;
+    var attribMatch = /([a-z]+)=([^,]+)(,|$)/;
+
+    while (challenge.match(attribMatch)) {
+      var matches = challenge.match(attribMatch);
+      challenge = challenge.replace(matches[0], "");
+
+      switch (matches[1]) {
+        case "r":
+          nonce = matches[2];
+          break;
+
+        case "s":
+          salt = matches[2];
+          break;
+
+        case "i":
+          iter = matches[2];
+          break;
+      }
+    }
+
+    if (nonce.substr(0, cnonce.length) !== cnonce) {
+      connection._sasl_data = {};
+      return connection._sasl_failure_cb();
+    }
+
+    responseText += "r=" + nonce;
+    authMessage += responseText;
+    salt = atob(salt);
+    salt += "\x00\x00\x00\x01";
+    var pass = utils__WEBPACK_IMPORTED_MODULE_2__["default"].utf16to8(connection.pass);
+    Hi = U_old = sha1__WEBPACK_IMPORTED_MODULE_1__["default"].core_hmac_sha1(pass, salt);
+
+    for (i = 1; i < iter; i++) {
+      U = sha1__WEBPACK_IMPORTED_MODULE_1__["default"].core_hmac_sha1(pass, sha1__WEBPACK_IMPORTED_MODULE_1__["default"].binb2str(U_old));
+
+      for (k = 0; k < 5; k++) {
+        Hi[k] ^= U[k];
+      }
+
+      U_old = U;
+    }
+
+    Hi = sha1__WEBPACK_IMPORTED_MODULE_1__["default"].binb2str(Hi);
+    var clientKey = sha1__WEBPACK_IMPORTED_MODULE_1__["default"].core_hmac_sha1(Hi, "Client Key");
+    var serverKey = sha1__WEBPACK_IMPORTED_MODULE_1__["default"].str_hmac_sha1(Hi, "Server Key");
+    var clientSignature = sha1__WEBPACK_IMPORTED_MODULE_1__["default"].core_hmac_sha1(sha1__WEBPACK_IMPORTED_MODULE_1__["default"].str_sha1(sha1__WEBPACK_IMPORTED_MODULE_1__["default"].binb2str(clientKey)), authMessage);
+    connection._sasl_data["server-signature"] = sha1__WEBPACK_IMPORTED_MODULE_1__["default"].b64_hmac_sha1(serverKey, authMessage);
+
+    for (k = 0; k < 5; k++) {
+      clientKey[k] ^= clientSignature[k];
+    }
+
+    responseText += ",p=" + btoa(sha1__WEBPACK_IMPORTED_MODULE_1__["default"].binb2str(clientKey));
+    return responseText;
+  };
+
+  return auth_str;
+};
+/** PrivateConstructor: SASLMD5
+ *  SASL DIGEST MD5 authentication.
+ */
+
+
+Strophe.SASLMD5 = function () {};
+
+Strophe.SASLMD5.prototype = new Strophe.SASLMechanism("DIGEST-MD5", false, 60);
+
+Strophe.SASLMD5.prototype.test = function (connection) {
+  return connection.authcid !== null;
+};
+/** PrivateFunction: _quote
+ *  _Private_ utility function to backslash escape and quote strings.
+ *
+ *  Parameters:
+ *    (String) str - The string to be quoted.
+ *
+ *  Returns:
+ *    quoted string
+ */
+
+
+Strophe.SASLMD5.prototype._quote = function (str) {
+  return '"' + str.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"'; //" end string workaround for emacs
+};
+
+Strophe.SASLMD5.prototype.onChallenge = function (connection, challenge, test_cnonce) {
+  var attribMatch = /([a-z]+)=("[^"]+"|[^,"]+)(?:,|$)/;
+  var cnonce = test_cnonce || md5__WEBPACK_IMPORTED_MODULE_0__["default"].hexdigest("" + Math.random() * 1234567890);
+  var realm = "";
+  var host = null;
+  var nonce = "";
+  var qop = "";
+
+  while (challenge.match(attribMatch)) {
+    var matches = challenge.match(attribMatch);
+    challenge = challenge.replace(matches[0], "");
+    matches[2] = matches[2].replace(/^"(.+)"$/, "$1");
+
+    switch (matches[1]) {
+      case "realm":
+        realm = matches[2];
+        break;
+
+      case "nonce":
+        nonce = matches[2];
+        break;
+
+      case "qop":
+        qop = matches[2];
+        break;
+
+      case "host":
+        host = matches[2];
+        break;
+    }
+  }
+
+  var digest_uri = connection.servtype + "/" + connection.domain;
+
+  if (host !== null) {
+    digest_uri = digest_uri + "/" + host;
+  }
+
+  var cred = utils__WEBPACK_IMPORTED_MODULE_2__["default"].utf16to8(connection.authcid + ":" + realm + ":" + this._connection.pass);
+  var A1 = md5__WEBPACK_IMPORTED_MODULE_0__["default"].hash(cred) + ":" + nonce + ":" + cnonce;
+  var A2 = 'AUTHENTICATE:' + digest_uri;
+  var responseText = "";
+  responseText += 'charset=utf-8,';
+  responseText += 'username=' + this._quote(utils__WEBPACK_IMPORTED_MODULE_2__["default"].utf16to8(connection.authcid)) + ',';
+  responseText += 'realm=' + this._quote(realm) + ',';
+  responseText += 'nonce=' + this._quote(nonce) + ',';
+  responseText += 'nc=00000001,';
+  responseText += 'cnonce=' + this._quote(cnonce) + ',';
+  responseText += 'digest-uri=' + this._quote(digest_uri) + ',';
+  responseText += 'response=' + md5__WEBPACK_IMPORTED_MODULE_0__["default"].hexdigest(md5__WEBPACK_IMPORTED_MODULE_0__["default"].hexdigest(A1) + ":" + nonce + ":00000001:" + cnonce + ":auth:" + md5__WEBPACK_IMPORTED_MODULE_0__["default"].hexdigest(A2)) + ",";
+  responseText += 'qop=auth';
+
+  this.onChallenge = function () {
+    return "";
+  };
+
+  return responseText;
+};
+/** PrivateConstructor: SASLOAuthBearer
+ *  SASL OAuth Bearer authentication.
+ */
+
+
+Strophe.SASLOAuthBearer = function () {};
+
+Strophe.SASLOAuthBearer.prototype = new Strophe.SASLMechanism("OAUTHBEARER", true, 40);
+
+Strophe.SASLOAuthBearer.prototype.test = function (connection) {
+  return connection.pass !== null;
+};
+
+Strophe.SASLOAuthBearer.prototype.onChallenge = function (connection) {
+  var auth_str = 'n,';
+
+  if (connection.authcid !== null) {
+    auth_str = auth_str + 'a=' + connection.authzid;
+  }
+
+  auth_str = auth_str + ',';
+  auth_str = auth_str + "\x01";
+  auth_str = auth_str + 'auth=Bearer ';
+  auth_str = auth_str + connection.pass;
+  auth_str = auth_str + "\x01";
+  auth_str = auth_str + "\x01";
+  return utils__WEBPACK_IMPORTED_MODULE_2__["default"].utf16to8(auth_str);
+};
+/** PrivateConstructor: SASLExternal
+ *  SASL EXTERNAL authentication.
+ *
+ *  The EXTERNAL mechanism allows a client to request the server to use
+ *  credentials established by means external to the mechanism to
+ *  authenticate the client. The external means may be, for instance,
+ *  TLS services.
+ */
+
+
+Strophe.SASLExternal = function () {};
+
+Strophe.SASLExternal.prototype = new Strophe.SASLMechanism("EXTERNAL", true, 10);
+
+Strophe.SASLExternal.prototype.onChallenge = function (connection) {
+  /** According to XEP-178, an authzid SHOULD NOT be presented when the
+   * authcid contained or implied in the client certificate is the JID (i.e.
+   * authzid) with which the user wants to log in as.
+   *
+   * To NOT send the authzid, the user should therefore set the authcid equal
+   * to the JID when instantiating a new Strophe.Connection object.
+   */
+  return connection.authcid === connection.authzid ? '' : connection.authzid;
+};
+/** PrivateConstructor: SASLXOAuth2
+ *  SASL X-OAuth2 authentication.
+ */
+
+
+Strophe.SASLXOAuth2 = function () {};
+
+Strophe.SASLXOAuth2.prototype = new Strophe.SASLMechanism("X-OAUTH2", true, 30);
+
+Strophe.SASLXOAuth2.prototype.test = function (connection) {
+  return connection.pass !== null;
+};
+
+Strophe.SASLXOAuth2.prototype.onChallenge = function (connection) {
+  var auth_str = "\0";
+
+  if (connection.authcid !== null) {
+    auth_str = auth_str + connection.authzid;
+  }
+
+  auth_str = auth_str + "\0";
+  auth_str = auth_str + connection.pass;
+  return utils__WEBPACK_IMPORTED_MODULE_2__["default"].utf16to8(auth_str);
+};
+
+
+/* harmony default export */ __webpack_exports__["default"] = ({
+  'Strophe': Strophe,
+  '$build': $build,
+  '$iq': $iq,
+  '$msg': $msg,
+  '$pres': $pres,
+  'SHA1': sha1__WEBPACK_IMPORTED_MODULE_1__["default"],
+  'MD5': md5__WEBPACK_IMPORTED_MODULE_0__["default"],
+  'b64_hmac_sha1': sha1__WEBPACK_IMPORTED_MODULE_1__["default"].b64_hmac_sha1,
+  'b64_sha1': sha1__WEBPACK_IMPORTED_MODULE_1__["default"].b64_sha1,
+  'str_hmac_sha1': sha1__WEBPACK_IMPORTED_MODULE_1__["default"].str_hmac_sha1,
+  'str_sha1': sha1__WEBPACK_IMPORTED_MODULE_1__["default"].str_sha1
+});
+
+/***/ }),
+
+/***/ "./src/md5.js":
+/*!********************!*\
+  !*** ./src/md5.js ***!
+  \********************/
+/*! exports provided: default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return MD5; });
+/*
+ * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
+ * Digest Algorithm, as defined in RFC 1321.
+ * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for more info.
+ */
+
+/*
+ * Everything that isn't used by Strophe has been stripped here!
+ */
+
+/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+var safe_add = function safe_add(x, y) {
+  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return msw << 16 | lsw & 0xFFFF;
+};
+/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+
+
+var bit_rol = function bit_rol(num, cnt) {
+  return num << cnt | num >>> 32 - cnt;
+};
+/*
+ * Convert a string to an array of little-endian words
+ */
+
+
+var str2binl = function str2binl(str) {
+  var bin = [];
+
+  for (var i = 0; i < str.length * 8; i += 8) {
+    bin[i >> 5] |= (str.charCodeAt(i / 8) & 255) << i % 32;
+  }
+
+  return bin;
+};
+/*
+ * Convert an array of little-endian words to a string
+ */
+
+
+var binl2str = function binl2str(bin) {
+  var str = "";
+
+  for (var i = 0; i < bin.length * 32; i += 8) {
+    str += String.fromCharCode(bin[i >> 5] >>> i % 32 & 255);
+  }
+
+  return str;
+};
+/*
+ * Convert an array of little-endian words to a hex string.
+ */
+
+
+var binl2hex = function binl2hex(binarray) {
+  var hex_tab = "0123456789abcdef";
+  var str = "";
+
+  for (var i = 0; i < binarray.length * 4; i++) {
+    str += hex_tab.charAt(binarray[i >> 2] >> i % 4 * 8 + 4 & 0xF) + hex_tab.charAt(binarray[i >> 2] >> i % 4 * 8 & 0xF);
+  }
+
+  return str;
+};
+/*
+ * These functions implement the four basic operations the algorithm uses.
+ */
+
+
+var md5_cmn = function md5_cmn(q, a, b, x, s, t) {
+  return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s), b);
+};
+
+var md5_ff = function md5_ff(a, b, c, d, x, s, t) {
+  return md5_cmn(b & c | ~b & d, a, b, x, s, t);
+};
+
+var md5_gg = function md5_gg(a, b, c, d, x, s, t) {
+  return md5_cmn(b & d | c & ~d, a, b, x, s, t);
+};
+
+var md5_hh = function md5_hh(a, b, c, d, x, s, t) {
+  return md5_cmn(b ^ c ^ d, a, b, x, s, t);
+};
+
+var md5_ii = function md5_ii(a, b, c, d, x, s, t) {
+  return md5_cmn(c ^ (b | ~d), a, b, x, s, t);
+};
+/*
+ * Calculate the MD5 of an array of little-endian words, and a bit length
+ */
+
+
+var core_md5 = function core_md5(x, len) {
+  /* append padding */
+  x[len >> 5] |= 0x80 << len % 32;
+  x[(len + 64 >>> 9 << 4) + 14] = len;
+  var a = 1732584193;
+  var b = -271733879;
+  var c = -1732584194;
+  var d = 271733878;
+  var olda, oldb, oldc, oldd;
+
+  for (var i = 0; i < x.length; i += 16) {
+    olda = a;
+    oldb = b;
+    oldc = c;
+    oldd = d;
+    a = md5_ff(a, b, c, d, x[i + 0], 7, -680876936);
+    d = md5_ff(d, a, b, c, x[i + 1], 12, -389564586);
+    c = md5_ff(c, d, a, b, x[i + 2], 17, 606105819);
+    b = md5_ff(b, c, d, a, x[i + 3], 22, -1044525330);
+    a = md5_ff(a, b, c, d, x[i + 4], 7, -176418897);
+    d = md5_ff(d, a, b, c, x[i + 5], 12, 1200080426);
+    c = md5_ff(c, d, a, b, x[i + 6], 17, -1473231341);
+    b = md5_ff(b, c, d, a, x[i + 7], 22, -45705983);
+    a = md5_ff(a, b, c, d, x[i + 8], 7, 1770035416);
+    d = md5_ff(d, a, b, c, x[i + 9], 12, -1958414417);
+    c = md5_ff(c, d, a, b, x[i + 10], 17, -42063);
+    b = md5_ff(b, c, d, a, x[i + 11], 22, -1990404162);
+    a = md5_ff(a, b, c, d, x[i + 12], 7, 1804603682);
+    d = md5_ff(d, a, b, c, x[i + 13], 12, -40341101);
+    c = md5_ff(c, d, a, b, x[i + 14], 17, -1502002290);
+    b = md5_ff(b, c, d, a, x[i + 15], 22, 1236535329);
+    a = md5_gg(a, b, c, d, x[i + 1], 5, -165796510);
+    d = md5_gg(d, a, b, c, x[i + 6], 9, -1069501632);
+    c = md5_gg(c, d, a, b, x[i + 11], 14, 643717713);
+    b = md5_gg(b, c, d, a, x[i + 0], 20, -373897302);
+    a = md5_gg(a, b, c, d, x[i + 5], 5, -701558691);
+    d = md5_gg(d, a, b, c, x[i + 10], 9, 38016083);
+    c = md5_gg(c, d, a, b, x[i + 15], 14, -660478335);
+    b = md5_gg(b, c, d, a, x[i + 4], 20, -405537848);
+    a = md5_gg(a, b, c, d, x[i + 9], 5, 568446438);
+    d = md5_gg(d, a, b, c, x[i + 14], 9, -1019803690);
+    c = md5_gg(c, d, a, b, x[i + 3], 14, -187363961);
+    b = md5_gg(b, c, d, a, x[i + 8], 20, 1163531501);
+    a = md5_gg(a, b, c, d, x[i + 13], 5, -1444681467);
+    d = md5_gg(d, a, b, c, x[i + 2], 9, -51403784);
+    c = md5_gg(c, d, a, b, x[i + 7], 14, 1735328473);
+    b = md5_gg(b, c, d, a, x[i + 12], 20, -1926607734);
+    a = md5_hh(a, b, c, d, x[i + 5], 4, -378558);
+    d = md5_hh(d, a, b, c, x[i + 8], 11, -2022574463);
+    c = md5_hh(c, d, a, b, x[i + 11], 16, 1839030562);
+    b = md5_hh(b, c, d, a, x[i + 14], 23, -35309556);
+    a = md5_hh(a, b, c, d, x[i + 1], 4, -1530992060);
+    d = md5_hh(d, a, b, c, x[i + 4], 11, 1272893353);
+    c = md5_hh(c, d, a, b, x[i + 7], 16, -155497632);
+    b = md5_hh(b, c, d, a, x[i + 10], 23, -1094730640);
+    a = md5_hh(a, b, c, d, x[i + 13], 4, 681279174);
+    d = md5_hh(d, a, b, c, x[i + 0], 11, -358537222);
+    c = md5_hh(c, d, a, b, x[i + 3], 16, -722521979);
+    b = md5_hh(b, c, d, a, x[i + 6], 23, 76029189);
+    a = md5_hh(a, b, c, d, x[i + 9], 4, -640364487);
+    d = md5_hh(d, a, b, c, x[i + 12], 11, -421815835);
+    c = md5_hh(c, d, a, b, x[i + 15], 16, 530742520);
+    b = md5_hh(b, c, d, a, x[i + 2], 23, -995338651);
+    a = md5_ii(a, b, c, d, x[i + 0], 6, -198630844);
+    d = md5_ii(d, a, b, c, x[i + 7], 10, 1126891415);
+    c = md5_ii(c, d, a, b, x[i + 14], 15, -1416354905);
+    b = md5_ii(b, c, d, a, x[i + 5], 21, -57434055);
+    a = md5_ii(a, b, c, d, x[i + 12], 6, 1700485571);
+    d = md5_ii(d, a, b, c, x[i + 3], 10, -1894986606);
+    c = md5_ii(c, d, a, b, x[i + 10], 15, -1051523);
+    b = md5_ii(b, c, d, a, x[i + 1], 21, -2054922799);
+    a = md5_ii(a, b, c, d, x[i + 8], 6, 1873313359);
+    d = md5_ii(d, a, b, c, x[i + 15], 10, -30611744);
+    c = md5_ii(c, d, a, b, x[i + 6], 15, -1560198380);
+    b = md5_ii(b, c, d, a, x[i + 13], 21, 1309151649);
+    a = md5_ii(a, b, c, d, x[i + 4], 6, -145523070);
+    d = md5_ii(d, a, b, c, x[i + 11], 10, -1120210379);
+    c = md5_ii(c, d, a, b, x[i + 2], 15, 718787259);
+    b = md5_ii(b, c, d, a, x[i + 9], 21, -343485551);
+    a = safe_add(a, olda);
+    b = safe_add(b, oldb);
+    c = safe_add(c, oldc);
+    d = safe_add(d, oldd);
+  }
+
+  return [a, b, c, d];
+};
+/*
+ * These are the functions you'll usually want to call.
+ * They take string arguments and return either hex or base-64 encoded
+ * strings.
+ */
+
+
+var MD5 = {
+  hexdigest: function hexdigest(s) {
+    return binl2hex(core_md5(str2binl(s), s.length * 8));
+  },
+  hash: function hash(s) {
+    return binl2str(core_md5(str2binl(s), s.length * 8));
+  }
+};
+
+
+/***/ }),
+
+/***/ "./src/sha1.js":
+/*!*********************!*\
+  !*** ./src/sha1.js ***!
+  \*********************/
+/*! exports provided: default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return SHA1; });
+/*
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
+ * in FIPS PUB 180-1
+ * Version 2.1a Copyright Paul Johnston 2000 - 2002.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for details.
+ */
+
+/* jshint undef: true, unused: true:, noarg: true, latedef: false */
+
+/* global define */
+
+/* Some functions and variables have been stripped for use with Strophe */
+
+/*
+ * Calculate the SHA-1 of an array of big-endian words, and a bit length
+ */
+function core_sha1(x, len) {
+  /* append padding */
+  x[len >> 5] |= 0x80 << 24 - len % 32;
+  x[(len + 64 >> 9 << 4) + 15] = len;
+  var w = new Array(80);
+  var a = 1732584193;
+  var b = -271733879;
+  var c = -1732584194;
+  var d = 271733878;
+  var e = -1009589776;
+  var i, j, t, olda, oldb, oldc, oldd, olde;
+
+  for (i = 0; i < x.length; i += 16) {
+    olda = a;
+    oldb = b;
+    oldc = c;
+    oldd = d;
+    olde = e;
+
+    for (j = 0; j < 80; j++) {
+      if (j < 16) {
+        w[j] = x[i + j];
+      } else {
+        w[j] = rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
+      }
+
+      t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)), safe_add(safe_add(e, w[j]), sha1_kt(j)));
+      e = d;
+      d = c;
+      c = rol(b, 30);
+      b = a;
+      a = t;
+    }
+
+    a = safe_add(a, olda);
+    b = safe_add(b, oldb);
+    c = safe_add(c, oldc);
+    d = safe_add(d, oldd);
+    e = safe_add(e, olde);
+  }
+
+  return [a, b, c, d, e];
+}
+/*
+ * Perform the appropriate triplet combination function for the current
+ * iteration
+ */
+
+
+function sha1_ft(t, b, c, d) {
+  if (t < 20) {
+    return b & c | ~b & d;
+  }
+
+  if (t < 40) {
+    return b ^ c ^ d;
+  }
+
+  if (t < 60) {
+    return b & c | b & d | c & d;
+  }
+
+  return b ^ c ^ d;
+}
+/*
+ * Determine the appropriate additive constant for the current iteration
+ */
+
+
+function sha1_kt(t) {
+  return t < 20 ? 1518500249 : t < 40 ? 1859775393 : t < 60 ? -1894007588 : -899497514;
+}
+/*
+ * Calculate the HMAC-SHA1 of a key and some data
+ */
+
+
+function core_hmac_sha1(key, data) {
+  var bkey = str2binb(key);
+
+  if (bkey.length > 16) {
+    bkey = core_sha1(bkey, key.length * 8);
+  }
+
+  var ipad = new Array(16),
+      opad = new Array(16);
+
+  for (var i = 0; i < 16; i++) {
+    ipad[i] = bkey[i] ^ 0x36363636;
+    opad[i] = bkey[i] ^ 0x5C5C5C5C;
+  }
+
+  var hash = core_sha1(ipad.concat(str2binb(data)), 512 + data.length * 8);
+  return core_sha1(opad.concat(hash), 512 + 160);
+}
+/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+
+
+function safe_add(x, y) {
+  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return msw << 16 | lsw & 0xFFFF;
+}
+/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+
+
+function rol(num, cnt) {
+  return num << cnt | num >>> 32 - cnt;
+}
+/*
+ * Convert an 8-bit or 16-bit string to an array of big-endian words
+ * In 8-bit function, characters >255 have their hi-byte silently ignored.
+ */
+
+
+function str2binb(str) {
+  var bin = [];
+  var mask = 255;
+
+  for (var i = 0; i < str.length * 8; i += 8) {
+    bin[i >> 5] |= (str.charCodeAt(i / 8) & mask) << 24 - i % 32;
+  }
+
+  return bin;
+}
+/*
+ * Convert an array of big-endian words to a base-64 string
+ */
+
+
+function binb2b64(binarray) {
+  var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  var str = "";
+  var triplet, j;
+
+  for (var i = 0; i < binarray.length * 4; i += 3) {
+    triplet = (binarray[i >> 2] >> 8 * (3 - i % 4) & 0xFF) << 16 | (binarray[i + 1 >> 2] >> 8 * (3 - (i + 1) % 4) & 0xFF) << 8 | binarray[i + 2 >> 2] >> 8 * (3 - (i + 2) % 4) & 0xFF;
+
+    for (j = 0; j < 4; j++) {
+      if (i * 8 + j * 6 > binarray.length * 32) {
+        str += "=";
+      } else {
+        str += tab.charAt(triplet >> 6 * (3 - j) & 0x3F);
+      }
+    }
+  }
+
+  return str;
+}
+/*
+ * Convert an array of big-endian words to a string
+ */
+
+
+function binb2str(bin) {
+  var str = "";
+  var mask = 255;
+
+  for (var i = 0; i < bin.length * 32; i += 8) {
+    str += String.fromCharCode(bin[i >> 5] >>> 24 - i % 32 & mask);
+  }
+
+  return str;
+}
+/*
+ * These are the functions you'll usually want to call
+ * They take string arguments and return either hex or base-64 encoded strings
+ */
+
+
+var SHA1 = {
+  b64_hmac_sha1: function b64_hmac_sha1(key, data) {
+    return binb2b64(core_hmac_sha1(key, data));
+  },
+  b64_sha1: function b64_sha1(s) {
+    return binb2b64(core_sha1(str2binb(s), s.length * 8));
+  },
+  binb2str: binb2str,
+  core_hmac_sha1: core_hmac_sha1,
+  str_hmac_sha1: function str_hmac_sha1(key, data) {
+    return binb2str(core_hmac_sha1(key, data));
+  },
+  str_sha1: function str_sha1(s) {
+    return binb2str(core_sha1(str2binb(s), s.length * 8));
+  }
+};
+
+
+/***/ }),
+
+/***/ "./src/strophe.js":
+/*!************************!*\
+  !*** ./src/strophe.js ***!
+  \************************/
+/*! exports provided: default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* WEBPACK VAR INJECTION */(function(global) {/* harmony import */ var core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core */ "./src/core.js");
+/* harmony import */ var bosh__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! bosh */ "./src/bosh.js");
+/* harmony import */ var websocket__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! websocket */ "./src/websocket.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "default", function() { return core__WEBPACK_IMPORTED_MODULE_0__["default"]; });
+
+/*global global*/
+
+
+
+global.Strophe = core__WEBPACK_IMPORTED_MODULE_0__["default"].Strophe;
+global.$build = core__WEBPACK_IMPORTED_MODULE_0__["default"].$build;
+global.$iq = core__WEBPACK_IMPORTED_MODULE_0__["default"].$iq;
+global.$msg = core__WEBPACK_IMPORTED_MODULE_0__["default"].$msg;
+global.$pres = core__WEBPACK_IMPORTED_MODULE_0__["default"].$pres;
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../node_modules/webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js")))
+
+/***/ }),
+
+/***/ "./src/utils.js":
+/*!**********************!*\
+  !*** ./src/utils.js ***!
+  \**********************/
+/*! exports provided: default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return utils; });
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var utils = {
+  utf16to8: function utf16to8(str) {
+    var i, c;
+    var out = "";
+    var len = str.length;
+
+    for (i = 0; i < len; i++) {
+      c = str.charCodeAt(i);
+
+      if (c >= 0x0000 && c <= 0x007F) {
+        out += str.charAt(i);
+      } else if (c > 0x07FF) {
+        out += String.fromCharCode(0xE0 | c >> 12 & 0x0F);
+        out += String.fromCharCode(0x80 | c >> 6 & 0x3F);
+        out += String.fromCharCode(0x80 | c >> 0 & 0x3F);
+      } else {
+        out += String.fromCharCode(0xC0 | c >> 6 & 0x1F);
+        out += String.fromCharCode(0x80 | c >> 0 & 0x3F);
+      }
+    }
+
+    return out;
+  },
+  addCookies: function addCookies(cookies) {
+    /* Parameters:
+     *  (Object) cookies - either a map of cookie names
+     *    to string values or to maps of cookie values.
+     *
+     * For example:
+     * { "myCookie": "1234" }
+     *
+     * or:
+     * { "myCookie": {
+     *      "value": "1234",
+     *      "domain": ".example.org",
+     *      "path": "/",
+     *      "expires": expirationDate
+     *      }
+     *  }
+     *
+     *  These values get passed to Strophe.Connection via
+     *   options.cookies
+     */
+    cookies = cookies || {};
+
+    for (var cookieName in cookies) {
+      if (Object.prototype.hasOwnProperty.call(cookies, cookieName)) {
+        var expires = '';
+        var domain = '';
+        var path = '';
+        var cookieObj = cookies[cookieName];
+        var isObj = _typeof(cookieObj) === "object";
+        var cookieValue = escape(unescape(isObj ? cookieObj.value : cookieObj));
+
+        if (isObj) {
+          expires = cookieObj.expires ? ";expires=" + cookieObj.expires : '';
+          domain = cookieObj.domain ? ";domain=" + cookieObj.domain : '';
+          path = cookieObj.path ? ";path=" + cookieObj.path : '';
+        }
+
+        document.cookie = cookieName + '=' + cookieValue + expires + domain + path;
+      }
+    }
+  }
+};
+
+
+/***/ }),
+
+/***/ "./src/websocket.js":
+/*!**************************!*\
+  !*** ./src/websocket.js ***!
+  \**************************/
+/*! no exports provided */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core */ "./src/core.js");
+/*
+    This program is distributed under the terms of the MIT license.
+    Please see the LICENSE file for details.
+
+    Copyright 2006-2008, OGG, LLC
+*/
+
+/* global window, clearTimeout, WebSocket, DOMParser */
+
+var Strophe = core__WEBPACK_IMPORTED_MODULE_0__["default"].Strophe;
+var $build = core__WEBPACK_IMPORTED_MODULE_0__["default"].$build;
+/** Class: Strophe.WebSocket
+ *  _Private_ helper class that handles WebSocket Connections
+ *
+ *  The Strophe.WebSocket class is used internally by Strophe.Connection
+ *  to encapsulate WebSocket sessions. It is not meant to be used from user's code.
+ */
+
+/** File: websocket.js
+ *  A JavaScript library to enable XMPP over Websocket in Strophejs.
+ *
+ *  This file implements XMPP over WebSockets for Strophejs.
+ *  If a Connection is established with a Websocket url (ws://...)
+ *  Strophe will use WebSockets.
+ *  For more information on XMPP-over-WebSocket see RFC 7395:
+ *  http://tools.ietf.org/html/rfc7395
+ *
+ *  WebSocket support implemented by Andreas Guth (andreas.guth@rwth-aachen.de)
+ */
+
+/** PrivateConstructor: Strophe.Websocket
+ *  Create and initialize a Strophe.WebSocket object.
+ *  Currently only sets the connection Object.
+ *
+ *  Parameters:
+ *    (Strophe.Connection) connection - The Strophe.Connection that will use WebSockets.
+ *
+ *  Returns:
+ *    A new Strophe.WebSocket object.
+ */
+
+Strophe.Websocket = function (connection) {
+  this._conn = connection;
+  this.strip = "wrapper";
+  var service = connection.service;
+
+  if (service.indexOf("ws:") !== 0 && service.indexOf("wss:") !== 0) {
+    // If the service is not an absolute URL, assume it is a path and put the absolute
+    // URL together from options, current URL and the path.
+    var new_service = "";
+
+    if (connection.options.protocol === "ws" && window.location.protocol !== "https:") {
+      new_service += "ws";
+    } else {
+      new_service += "wss";
+    }
+
+    new_service += "://" + window.location.host;
+
+    if (service.indexOf("/") !== 0) {
+      new_service += window.location.pathname + service;
+    } else {
+      new_service += service;
+    }
+
+    connection.service = new_service;
+  }
+};
+
+Strophe.Websocket.prototype = {
+  /** PrivateFunction: _buildStream
+   *  _Private_ helper function to generate the <stream> start tag for WebSockets
+   *
+   *  Returns:
+   *    A Strophe.Builder with a <stream> element.
+   */
+  _buildStream: function _buildStream() {
+    return $build("open", {
+      "xmlns": Strophe.NS.FRAMING,
+      "to": this._conn.domain,
+      "version": '1.0'
+    });
+  },
+
+  /** PrivateFunction: _check_streamerror
+   * _Private_ checks a message for stream:error
+   *
+   *  Parameters:
+   *    (Strophe.Request) bodyWrap - The received stanza.
+   *    connectstatus - The ConnectStatus that will be set on error.
+   *  Returns:
+   *     true if there was a streamerror, false otherwise.
+   */
+  _check_streamerror: function _check_streamerror(bodyWrap, connectstatus) {
+    var errors;
+
+    if (bodyWrap.getElementsByTagNameNS) {
+      errors = bodyWrap.getElementsByTagNameNS(Strophe.NS.STREAM, "error");
+    } else {
+      errors = bodyWrap.getElementsByTagName("stream:error");
+    }
+
+    if (errors.length === 0) {
+      return false;
+    }
+
+    var error = errors[0];
+    var condition = "";
+    var text = "";
+    var ns = "urn:ietf:params:xml:ns:xmpp-streams";
+
+    for (var i = 0; i < error.childNodes.length; i++) {
+      var e = error.childNodes[i];
+
+      if (e.getAttribute("xmlns") !== ns) {
+        break;
+      }
+
+      if (e.nodeName === "text") {
+        text = e.textContent;
+      } else {
+        condition = e.nodeName;
+      }
+    }
+
+    var errorString = "WebSocket stream error: ";
+
+    if (condition) {
+      errorString += condition;
+    } else {
+      errorString += "unknown";
+    }
+
+    if (text) {
+      errorString += " - " + text;
+    }
+
+    Strophe.error(errorString); // close the connection on stream_error
+
+    this._conn._changeConnectStatus(connectstatus, condition);
+
+    this._conn._doDisconnect();
+
+    return true;
+  },
+
+  /** PrivateFunction: _reset
+   *  Reset the connection.
+   *
+   *  This function is called by the reset function of the Strophe Connection.
+   *  Is not needed by WebSockets.
+   */
+  _reset: function _reset() {
+    return;
+  },
+
+  /** PrivateFunction: _connect
+   *  _Private_ function called by Strophe.Connection.connect
+   *
+   *  Creates a WebSocket for a connection and assigns Callbacks to it.
+   *  Does nothing if there already is a WebSocket.
+   */
+  _connect: function _connect() {
+    // Ensure that there is no open WebSocket from a previous Connection.
+    this._closeSocket(); // Create the new WobSocket
+
+
+    this.socket = new WebSocket(this._conn.service, "xmpp");
+    this.socket.onopen = this._onOpen.bind(this);
+    this.socket.onerror = this._onError.bind(this);
+    this.socket.onclose = this._onClose.bind(this);
+    this.socket.onmessage = this._connect_cb_wrapper.bind(this);
+  },
+
+  /** PrivateFunction: _connect_cb
+   *  _Private_ function called by Strophe.Connection._connect_cb
+   *
+   * checks for stream:error
+   *
+   *  Parameters:
+   *    (Strophe.Request) bodyWrap - The received stanza.
+   */
+  _connect_cb: function _connect_cb(bodyWrap) {
+    var error = this._check_streamerror(bodyWrap, Strophe.Status.CONNFAIL);
+
+    if (error) {
+      return Strophe.Status.CONNFAIL;
+    }
+  },
+
+  /** PrivateFunction: _handleStreamStart
+   * _Private_ function that checks the opening <open /> tag for errors.
+   *
+   * Disconnects if there is an error and returns false, true otherwise.
+   *
+   *  Parameters:
+   *    (Node) message - Stanza containing the <open /> tag.
+   */
+  _handleStreamStart: function _handleStreamStart(message) {
+    var error = false; // Check for errors in the <open /> tag
+
+    var ns = message.getAttribute("xmlns");
+
+    if (typeof ns !== "string") {
+      error = "Missing xmlns in <open />";
+    } else if (ns !== Strophe.NS.FRAMING) {
+      error = "Wrong xmlns in <open />: " + ns;
+    }
+
+    var ver = message.getAttribute("version");
+
+    if (typeof ver !== "string") {
+      error = "Missing version in <open />";
+    } else if (ver !== "1.0") {
+      error = "Wrong version in <open />: " + ver;
+    }
+
+    if (error) {
+      this._conn._changeConnectStatus(Strophe.Status.CONNFAIL, error);
+
+      this._conn._doDisconnect();
+
+      return false;
+    }
+
+    return true;
+  },
+
+  /** PrivateFunction: _connect_cb_wrapper
+   * _Private_ function that handles the first connection messages.
+   *
+   * On receiving an opening stream tag this callback replaces itself with the real
+   * message handler. On receiving a stream error the connection is terminated.
+   */
+  _connect_cb_wrapper: function _connect_cb_wrapper(message) {
+    if (message.data.indexOf("<open ") === 0 || message.data.indexOf("<?xml") === 0) {
+      // Strip the XML Declaration, if there is one
+      var data = message.data.replace(/^(<\?.*?\?>\s*)*/, "");
+      if (data === '') return;
+      var streamStart = new DOMParser().parseFromString(data, "text/xml").documentElement;
+
+      this._conn.xmlInput(streamStart);
+
+      this._conn.rawInput(message.data); //_handleStreamSteart will check for XML errors and disconnect on error
+
+
+      if (this._handleStreamStart(streamStart)) {
+        //_connect_cb will check for stream:error and disconnect on error
+        this._connect_cb(streamStart);
+      }
+    } else if (message.data.indexOf("<close ") === 0) {
+      // <close xmlns="urn:ietf:params:xml:ns:xmpp-framing />
+      // Parse the raw string to an XML element
+      var parsedMessage = new DOMParser().parseFromString(message.data, "text/xml").documentElement; // Report this input to the raw and xml handlers
+
+      this._conn.xmlInput(parsedMessage);
+
+      this._conn.rawInput(message.data);
+
+      var see_uri = parsedMessage.getAttribute("see-other-uri");
+
+      if (see_uri) {
+        var service = this._conn.service; // Valid scenarios: WSS->WSS, WS->ANY
+
+        var isSecureRedirect = service.indexOf("wss:") >= 0 && see_uri.indexOf("wss:") >= 0 || service.indexOf("ws:") >= 0;
+
+        if (isSecureRedirect) {
+          this._conn._changeConnectStatus(Strophe.Status.REDIRECT, "Received see-other-uri, resetting connection");
+
+          this._conn.reset();
+
+          this._conn.service = see_uri;
+
+          this._connect();
+        }
+      } else {
+        this._conn._changeConnectStatus(Strophe.Status.CONNFAIL, "Received closing stream");
+
+        this._conn._doDisconnect();
+      }
+    } else {
+      var string = this._streamWrap(message.data);
+
+      var elem = new DOMParser().parseFromString(string, "text/xml").documentElement;
+      this.socket.onmessage = this._onMessage.bind(this);
+
+      this._conn._connect_cb(elem, null, message.data);
+    }
+  },
+
+  /** PrivateFunction: _disconnect
+   *  _Private_ function called by Strophe.Connection.disconnect
+   *
+   *  Disconnects and sends a last stanza if one is given
+   *
+   *  Parameters:
+   *    (Request) pres - This stanza will be sent before disconnecting.
+   */
+  _disconnect: function _disconnect(pres) {
+    if (this.socket && this.socket.readyState !== WebSocket.CLOSED) {
+      if (pres) {
+        this._conn.send(pres);
+      }
+
+      var close = $build("close", {
+        "xmlns": Strophe.NS.FRAMING
+      });
+
+      this._conn.xmlOutput(close.tree());
+
+      var closeString = Strophe.serialize(close);
+
+      this._conn.rawOutput(closeString);
+
+      try {
+        this.socket.send(closeString);
+      } catch (e) {
+        Strophe.info("Couldn't send <close /> tag.");
+      }
+    }
+
+    this._conn._doDisconnect();
+  },
+
+  /** PrivateFunction: _doDisconnect
+   *  _Private_ function to disconnect.
+   *
+   *  Just closes the Socket for WebSockets
+   */
+  _doDisconnect: function _doDisconnect() {
+    Strophe.info("WebSockets _doDisconnect was called");
+
+    this._closeSocket();
+  },
+
+  /** PrivateFunction _streamWrap
+   *  _Private_ helper function to wrap a stanza in a <stream> tag.
+   *  This is used so Strophe can process stanzas from WebSockets like BOSH
+   */
+  _streamWrap: function _streamWrap(stanza) {
+    return "<wrapper>" + stanza + '</wrapper>';
+  },
+
+  /** PrivateFunction: _closeSocket
+   *  _Private_ function to close the WebSocket.
+   *
+   *  Closes the socket if it is still open and deletes it
+   */
+  _closeSocket: function _closeSocket() {
+    if (this.socket) {
+      try {
+        this.socket.onerror = null;
+        this.socket.close();
+      } catch (e) {
+        Strophe.debug(e.message);
+      }
+    }
+
+    this.socket = null;
+  },
+
+  /** PrivateFunction: _emptyQueue
+   * _Private_ function to check if the message queue is empty.
+   *
+   *  Returns:
+   *    True, because WebSocket messages are send immediately after queueing.
+   */
+  _emptyQueue: function _emptyQueue() {
+    return true;
+  },
+
+  /** PrivateFunction: _onClose
+   * _Private_ function to handle websockets closing.
+   *
+   * Nothing to do here for WebSockets
+   */
+  _onClose: function _onClose(e) {
+    if (this._conn.connected && !this._conn.disconnecting) {
+      Strophe.error("Websocket closed unexpectedly");
+
+      this._conn._doDisconnect();
+    } else if (e && e.code === 1006 && !this._conn.connected && this.socket) {
+      // in case the onError callback was not called (Safari 10 does not
+      // call onerror when the initial connection fails) we need to
+      // dispatch a CONNFAIL status update to be consistent with the
+      // behavior on other browsers.
+      Strophe.error("Websocket closed unexcectedly");
+
+      this._conn._changeConnectStatus(Strophe.Status.CONNFAIL, "The WebSocket connection could not be established or was disconnected.");
+
+      this._conn._doDisconnect();
+    } else {
+      Strophe.info("Websocket closed");
+    }
+  },
+
+  /** PrivateFunction: _no_auth_received
+   *
+   * Called on stream start/restart when no stream:features
+   * has been received.
+   */
+  _no_auth_received: function _no_auth_received(callback) {
+    Strophe.error("Server did not offer a supported authentication mechanism");
+
+    this._changeConnectStatus(Strophe.Status.CONNFAIL, Strophe.ErrorCondition.NO_AUTH_MECH);
+
+    if (callback) {
+      callback.call(this._conn);
+    }
+
+    this._conn._doDisconnect();
+  },
+
+  /** PrivateFunction: _onDisconnectTimeout
+   *  _Private_ timeout handler for handling non-graceful disconnection.
+   *
+   *  This does nothing for WebSockets
+   */
+  _onDisconnectTimeout: function _onDisconnectTimeout() {},
+
+  /** PrivateFunction: _abortAllRequests
+   *  _Private_ helper function that makes sure all pending requests are aborted.
+   */
+  _abortAllRequests: function _abortAllRequests() {},
+
+  /** PrivateFunction: _onError
+   * _Private_ function to handle websockets errors.
+   *
+   * Parameters:
+   * (Object) error - The websocket error.
+   */
+  _onError: function _onError(error) {
+    Strophe.error("Websocket error " + error);
+
+    this._conn._changeConnectStatus(Strophe.Status.CONNFAIL, "The WebSocket connection could not be established or was disconnected.");
+
+    this._disconnect();
+  },
+
+  /** PrivateFunction: _onIdle
+   *  _Private_ function called by Strophe.Connection._onIdle
+   *
+   *  sends all queued stanzas
+   */
+  _onIdle: function _onIdle() {
+    var data = this._conn._data;
+
+    if (data.length > 0 && !this._conn.paused) {
+      for (var i = 0; i < data.length; i++) {
+        if (data[i] !== null) {
+          var stanza = void 0;
+
+          if (data[i] === "restart") {
+            stanza = this._buildStream().tree();
+          } else {
+            stanza = data[i];
+          }
+
+          var rawStanza = Strophe.serialize(stanza);
+
+          this._conn.xmlOutput(stanza);
+
+          this._conn.rawOutput(rawStanza);
+
+          this.socket.send(rawStanza);
+        }
+      }
+
+      this._conn._data = [];
+    }
+  },
+
+  /** PrivateFunction: _onMessage
+   * _Private_ function to handle websockets messages.
+   *
+   * This function parses each of the messages as if they are full documents.
+   * [TODO : We may actually want to use a SAX Push parser].
+   *
+   * Since all XMPP traffic starts with
+   *  <stream:stream version='1.0'
+   *                 xml:lang='en'
+   *                 xmlns='jabber:client'
+   *                 xmlns:stream='http://etherx.jabber.org/streams'
+   *                 id='3697395463'
+   *                 from='SERVER'>
+   *
+   * The first stanza will always fail to be parsed.
+   *
+   * Additionally, the seconds stanza will always be <stream:features> with
+   * the stream NS defined in the previous stanza, so we need to 'force'
+   * the inclusion of the NS in this stanza.
+   *
+   * Parameters:
+   * (string) message - The websocket message.
+   */
+  _onMessage: function _onMessage(message) {
+    var elem; // check for closing stream
+
+    var close = '<close xmlns="urn:ietf:params:xml:ns:xmpp-framing" />';
+
+    if (message.data === close) {
+      this._conn.rawInput(close);
+
+      this._conn.xmlInput(message);
+
+      if (!this._conn.disconnecting) {
+        this._conn._doDisconnect();
+      }
+
+      return;
+    } else if (message.data.search("<open ") === 0) {
+      // This handles stream restarts
+      elem = new DOMParser().parseFromString(message.data, "text/xml").documentElement;
+
+      if (!this._handleStreamStart(elem)) {
+        return;
+      }
+    } else {
+      var data = this._streamWrap(message.data);
+
+      elem = new DOMParser().parseFromString(data, "text/xml").documentElement;
+    }
+
+    if (this._check_streamerror(elem, Strophe.Status.ERROR)) {
+      return;
+    } //handle unavailable presence stanza before disconnecting
+
+
+    if (this._conn.disconnecting && elem.firstChild.nodeName === "presence" && elem.firstChild.getAttribute("type") === "unavailable") {
+      this._conn.xmlInput(elem);
+
+      this._conn.rawInput(Strophe.serialize(elem)); // if we are already disconnecting we will ignore the unavailable stanza and
+      // wait for the </stream:stream> tag before we close the connection
+
+
+      return;
+    }
+
+    this._conn._dataRecv(elem, message.data);
+  },
+
+  /** PrivateFunction: _onOpen
+   * _Private_ function to handle websockets connection setup.
+   *
+   * The opening stream tag is sent here.
+   */
+  _onOpen: function _onOpen() {
+    Strophe.info("Websocket open");
+
+    var start = this._buildStream();
+
+    this._conn.xmlOutput(start.tree());
+
+    var startString = Strophe.serialize(start);
+
+    this._conn.rawOutput(startString);
+
+    this.socket.send(startString);
+  },
+
+  /** PrivateFunction: _reqToData
+   * _Private_ function to get a stanza out of a request.
+   *
+   * WebSockets don't use requests, so the passed argument is just returned.
+   *
+   *  Parameters:
+   *    (Object) stanza - The stanza.
+   *
+   *  Returns:
+   *    The stanza that was passed.
+   */
+  _reqToData: function _reqToData(stanza) {
+    return stanza;
+  },
+
+  /** PrivateFunction: _send
+   *  _Private_ part of the Connection.send function for WebSocket
+   *
+   * Just flushes the messages that are in the queue
+   */
+  _send: function _send() {
+    this._conn.flush();
+  },
+
+  /** PrivateFunction: _sendRestart
+   *
+   *  Send an xmpp:restart stanza.
+   */
+  _sendRestart: function _sendRestart() {
+    clearTimeout(this._conn._idleTimeout);
+
+    this._conn._onIdle.bind(this._conn)();
+  }
+};
+
+/***/ })
+
+/******/ })["default"];
+});
+//# sourceMappingURL=strophe.js.map
\ No newline at end of file