Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

26 files changed, 8305 insertions, 0 deletions

diff --git a/comm/chat/protocols/xmpp/.eslintrc.js b/comm/chat/protocols/xmpp/.eslintrc.js
new file mode 100644
index 0000000000..66953c7e25
--- /dev/null
+++ b/comm/chat/protocols/xmpp/.eslintrc.js
@@ -0,0 +1,12 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.exports = {
+  rules: {
+    // The following rules will not be enabled currently.
+    complexity: "off",
+  },
+};
diff --git a/comm/chat/protocols/xmpp/components.conf b/comm/chat/protocols/xmpp/components.conf
new file mode 100644
index 0000000000..83943f1a34
--- /dev/null
+++ b/comm/chat/protocols/xmpp/components.conf
@@ -0,0 +1,15 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+Classes = [
+  {
+    'cid': '{dde786d1-6f59-43d0-9bc8-b505a757fb30}',
+    'contract_ids': ['@mozilla.org/chat/xmpp;1'],
+    'esModule': 'resource:///modules/xmpp.sys.mjs',
+    'constructor': 'XMPPProtocol',
+    'categories': {'im-protocol-plugin': 'prpl-jabber'},
+  },
+]
diff --git a/comm/chat/protocols/xmpp/icons/prpl-jabber-32.png b/comm/chat/protocols/xmpp/icons/prpl-jabber-32.png
new file mode 100644
index 0000000000..98897f75fb
--- /dev/null
+++ b/comm/chat/protocols/xmpp/icons/prpl-jabber-32.png
diff --git a/comm/chat/protocols/xmpp/icons/prpl-jabber-48.png b/comm/chat/protocols/xmpp/icons/prpl-jabber-48.png
new file mode 100644
index 0000000000..805820c565
--- /dev/null
+++ b/comm/chat/protocols/xmpp/icons/prpl-jabber-48.png
diff --git a/comm/chat/protocols/xmpp/icons/prpl-jabber.png b/comm/chat/protocols/xmpp/icons/prpl-jabber.png
new file mode 100644
index 0000000000..bb04c6e6df
--- /dev/null
+++ b/comm/chat/protocols/xmpp/icons/prpl-jabber.png
diff --git a/comm/chat/protocols/xmpp/jar.mn b/comm/chat/protocols/xmpp/jar.mn
new file mode 100644
index 0000000000..1f7ac54abc
--- /dev/null
+++ b/comm/chat/protocols/xmpp/jar.mn
@@ -0,0 +1,5 @@
+chat.jar:
+% skin prpl-jabber classic/1.0 %skin/classic/prpl/xmpp/
+	skin/classic/prpl/xmpp/icon32.png	(icons/prpl-jabber-32.png)
+	skin/classic/prpl/xmpp/icon48.png	(icons/prpl-jabber-48.png)
+	skin/classic/prpl/xmpp/icon.png	        (icons/prpl-jabber.png)
diff --git a/comm/chat/protocols/xmpp/lib/README.md b/comm/chat/protocols/xmpp/lib/README.md
new file mode 100644
index 0000000000..c813b5d070
--- /dev/null
+++ b/comm/chat/protocols/xmpp/lib/README.md
@@ -0,0 +1,6 @@
+This directory contains sax-js from https://github.com/isaacs/sax-js. Current version is v1.2.4.
+
+## Updating sax-js
+
+1. Download a release version from https://github.com/isaacs/sax-js.
+2. Copy `lib/sax.js` from the git repo to `sax/sax.js` in this directory.
diff --git a/comm/chat/protocols/xmpp/lib/moz.build b/comm/chat/protocols/xmpp/lib/moz.build
new file mode 100644
index 0000000000..b4f1787145
--- /dev/null
+++ b/comm/chat/protocols/xmpp/lib/moz.build
@@ -0,0 +1,8 @@
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+EXTRA_JS_MODULES.sax += [
+    "sax/sax.js",
+]
diff --git a/comm/chat/protocols/xmpp/lib/sax/LICENSE b/comm/chat/protocols/xmpp/lib/sax/LICENSE
new file mode 100644
index 0000000000..ccffa082c9
--- /dev/null
+++ b/comm/chat/protocols/xmpp/lib/sax/LICENSE
@@ -0,0 +1,41 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+====
+
+`String.fromCodePoint` by Mathias Bynens used according to terms of MIT
+License, as follows:
+
+    Copyright Mathias Bynens <https://mathiasbynens.be/>
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal in the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+
+    The above copyright notice and this permission notice shall be
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/comm/chat/protocols/xmpp/lib/sax/sax.js b/comm/chat/protocols/xmpp/lib/sax/sax.js
new file mode 100644
index 0000000000..564d8d4235
--- /dev/null
+++ b/comm/chat/protocols/xmpp/lib/sax/sax.js
@@ -0,0 +1,1648 @@
+/* This program is made available under an ISC-style license. */
+(function(sax) {
+  // wrapper for non-node envs
+  sax.parser = function(strict, opt) {
+    return new SAXParser(strict, opt);
+  };
+  sax.SAXParser = SAXParser;
+  sax.SAXStream = SAXStream;
+  sax.createStream = createStream;
+
+  // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns.
+  // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)),
+  // since that's the earliest that a buffer overrun could occur.  This way, checks are
+  // as rare as required, but as often as necessary to ensure never crossing this bound.
+  // Furthermore, buffers are only tested at most once per write(), so passing a very
+  // large string into write() might have undesirable effects, but this is manageable by
+  // the caller, so it is assumed to be safe.  Thus, a call to write() may, in the extreme
+  // edge case, result in creating at most one complete copy of the string passed in.
+  // Set to Infinity to have unlimited buffers.
+  sax.MAX_BUFFER_LENGTH = 64 * 1024;
+
+  var buffers = [
+    "comment",
+    "sgmlDecl",
+    "textNode",
+    "tagName",
+    "doctype",
+    "procInstName",
+    "procInstBody",
+    "entity",
+    "attribName",
+    "attribValue",
+    "cdata",
+    "script",
+  ];
+
+  sax.EVENTS = [
+    "text",
+    "processinginstruction",
+    "sgmldeclaration",
+    "doctype",
+    "comment",
+    "opentagstart",
+    "attribute",
+    "opentag",
+    "closetag",
+    "opencdata",
+    "cdata",
+    "closecdata",
+    "error",
+    "end",
+    "ready",
+    "script",
+    "opennamespace",
+    "closenamespace",
+  ];
+
+  function SAXParser(strict, opt) {
+    if (!(this instanceof SAXParser)) {
+      return new SAXParser(strict, opt);
+    }
+
+    var parser = this;
+    clearBuffers(parser);
+    parser.q = parser.c = "";
+    parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH;
+    parser.opt = opt || {};
+    parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags;
+    parser.looseCase = parser.opt.lowercase ? "toLowerCase" : "toUpperCase";
+    parser.tags = [];
+    parser.closed = parser.closedRoot = parser.sawRoot = false;
+    parser.tag = parser.error = null;
+    parser.strict = !!strict;
+    parser.noscript = !!(strict || parser.opt.noscript);
+    parser.state = S.BEGIN;
+    parser.strictEntities = parser.opt.strictEntities;
+    parser.ENTITIES = parser.strictEntities
+      ? Object.create(sax.XML_ENTITIES)
+      : Object.create(sax.ENTITIES);
+    parser.attribList = [];
+
+    // namespaces form a prototype chain.
+    // it always points at the current tag,
+    // which protos to its parent tag.
+    if (parser.opt.xmlns) {
+      parser.ns = Object.create(rootNS);
+    }
+
+    // mostly just for error reporting
+    parser.trackPosition = parser.opt.position !== false;
+    if (parser.trackPosition) {
+      parser.position = parser.line = parser.column = 0;
+    }
+    emit(parser, "onready");
+  }
+
+  if (!Object.create) {
+    Object.create = function(o) {
+      function F() {}
+      F.prototype = o;
+      var newf = new F();
+      return newf;
+    };
+  }
+
+  if (!Object.keys) {
+    Object.keys = function(o) {
+      var a = [];
+      for (var i in o) {
+        if (o.hasOwnProperty(i)) {
+          a.push(i);
+        }
+      }
+      return a;
+    };
+  }
+
+  function checkBufferLength(parser) {
+    var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10);
+    var maxActual = 0;
+    for (var i = 0, l = buffers.length; i < l; i++) {
+      var len = parser[buffers[i]].length;
+      if (len > maxAllowed) {
+        // Text/cdata nodes can get big, and since they're buffered,
+        // we can get here under normal conditions.
+        // Avoid issues by emitting the text node now,
+        // so at least it won't get any bigger.
+        switch (buffers[i]) {
+          case "textNode":
+            closeText(parser);
+            break;
+
+          case "cdata":
+            emitNode(parser, "oncdata", parser.cdata);
+            parser.cdata = "";
+            break;
+
+          case "script":
+            emitNode(parser, "onscript", parser.script);
+            parser.script = "";
+            break;
+
+          default:
+            error(parser, "Max buffer length exceeded: " + buffers[i]);
+        }
+      }
+      maxActual = Math.max(maxActual, len);
+    }
+    // schedule the next check for the earliest possible buffer overrun.
+    var m = sax.MAX_BUFFER_LENGTH - maxActual;
+    parser.bufferCheckPosition = m + parser.position;
+  }
+
+  function clearBuffers(parser) {
+    for (var i = 0, l = buffers.length; i < l; i++) {
+      parser[buffers[i]] = "";
+    }
+  }
+
+  function flushBuffers(parser) {
+    closeText(parser);
+    if (parser.cdata !== "") {
+      emitNode(parser, "oncdata", parser.cdata);
+      parser.cdata = "";
+    }
+    if (parser.script !== "") {
+      emitNode(parser, "onscript", parser.script);
+      parser.script = "";
+    }
+  }
+
+  SAXParser.prototype = {
+    end() {
+      end(this);
+    },
+    write,
+    resume() {
+      this.error = null;
+      return this;
+    },
+    close() {
+      return this.write(null);
+    },
+    flush() {
+      flushBuffers(this);
+    },
+  };
+
+  var Stream;
+  try {
+    Stream = require("stream").Stream;
+  } catch (ex) {
+    Stream = function() {};
+  }
+
+  var streamWraps = sax.EVENTS.filter(function(ev) {
+    return ev !== "error" && ev !== "end";
+  });
+
+  function createStream(strict, opt) {
+    return new SAXStream(strict, opt);
+  }
+
+  function SAXStream(strict, opt) {
+    if (!(this instanceof SAXStream)) {
+      return new SAXStream(strict, opt);
+    }
+
+    Stream.apply(this);
+
+    this._parser = new SAXParser(strict, opt);
+    this.writable = true;
+    this.readable = true;
+
+    var me = this;
+
+    this._parser.onend = function() {
+      me.emit("end");
+    };
+
+    this._parser.onerror = function(er) {
+      me.emit("error", er);
+
+      // if didn't throw, then means error was handled.
+      // go ahead and clear error, so we can write again.
+      me._parser.error = null;
+    };
+
+    this._decoder = null;
+
+    streamWraps.forEach(function(ev) {
+      Object.defineProperty(me, "on" + ev, {
+        get() {
+          return me._parser["on" + ev];
+        },
+        set(h) {
+          if (!h) {
+            me.removeAllListeners(ev);
+            me._parser["on" + ev] = h;
+            return h;
+          }
+          me.on(ev, h);
+        },
+        enumerable: true,
+        configurable: false,
+      });
+    });
+  }
+
+  SAXStream.prototype = Object.create(Stream.prototype, {
+    constructor: {
+      value: SAXStream,
+    },
+  });
+
+  SAXStream.prototype.write = function(data) {
+    if (
+      typeof Buffer === "function" &&
+      typeof Buffer.isBuffer === "function" &&
+      Buffer.isBuffer(data)
+    ) {
+      if (!this._decoder) {
+        var SD = require("string_decoder").StringDecoder;
+        this._decoder = new SD("utf8");
+      }
+      data = this._decoder.write(data);
+    }
+
+    this._parser.write(data.toString());
+    this.emit("data", data);
+    return true;
+  };
+
+  SAXStream.prototype.end = function(chunk) {
+    if (chunk && chunk.length) {
+      this.write(chunk);
+    }
+    this._parser.end();
+    return true;
+  };
+
+  SAXStream.prototype.on = function(ev, handler) {
+    var me = this;
+    if (!me._parser["on" + ev] && streamWraps.indexOf(ev) !== -1) {
+      me._parser["on" + ev] = function() {
+        var args =
+          arguments.length === 1
+            ? [arguments[0]]
+            : Array.apply(null, arguments);
+        args.splice(0, 0, ev);
+        me.emit.apply(me, args);
+      };
+    }
+
+    return Stream.prototype.on.call(me, ev, handler);
+  };
+
+  // this really needs to be replaced with character classes.
+  // XML allows all manner of ridiculous numbers and digits.
+  var CDATA = "[CDATA[";
+  var DOCTYPE = "DOCTYPE";
+  var XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+  var XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
+  var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE };
+
+  // http://www.w3.org/TR/REC-xml/#NT-NameStartChar
+  // This implementation works on strings, a single character at a time
+  // as such, it cannot ever support astral-plane characters (10000-EFFFF)
+  // without a significant breaking change to either this  parser, or the
+  // JavaScript language.  Implementation of an emoji-capable xml parser
+  // is left as an exercise for the reader.
+  var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
+
+  var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
+
+  var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
+  var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
+
+  function isWhitespace(c) {
+    return c === " " || c === "\n" || c === "\r" || c === "\t";
+  }
+
+  function isQuote(c) {
+    return c === '"' || c === "'";
+  }
+
+  function isAttribEnd(c) {
+    return c === ">" || isWhitespace(c);
+  }
+
+  function isMatch(regex, c) {
+    return regex.test(c);
+  }
+
+  function notMatch(regex, c) {
+    return !isMatch(regex, c);
+  }
+
+  var S = 0;
+  sax.STATE = {
+    BEGIN: S++, // leading byte order mark or whitespace
+    BEGIN_WHITESPACE: S++, // leading whitespace
+    TEXT: S++, // general stuff
+    TEXT_ENTITY: S++, // &amp and such.
+    OPEN_WAKA: S++, // <
+    SGML_DECL: S++, // <!BLARG
+    SGML_DECL_QUOTED: S++, // <!BLARG foo "bar
+    DOCTYPE: S++, // <!DOCTYPE
+    DOCTYPE_QUOTED: S++, // <!DOCTYPE "//blah
+    DOCTYPE_DTD: S++, // <!DOCTYPE "//blah" [ ...
+    DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE "//blah" [ "foo
+    COMMENT_STARTING: S++, // <!-
+    COMMENT: S++, // <!--
+    COMMENT_ENDING: S++, // <!-- blah -
+    COMMENT_ENDED: S++, // <!-- blah --
+    CDATA: S++, // <![CDATA[ something
+    CDATA_ENDING: S++, // ]
+    CDATA_ENDING_2: S++, // ]]
+    PROC_INST: S++, // <?hi
+    PROC_INST_BODY: S++, // <?hi there
+    PROC_INST_ENDING: S++, // <?hi "there" ?
+    OPEN_TAG: S++, // <strong
+    OPEN_TAG_SLASH: S++, // <strong /
+    ATTRIB: S++, // <a
+    ATTRIB_NAME: S++, // <a foo
+    ATTRIB_NAME_SAW_WHITE: S++, // <a foo _
+    ATTRIB_VALUE: S++, // <a foo=
+    ATTRIB_VALUE_QUOTED: S++, // <a foo="bar
+    ATTRIB_VALUE_CLOSED: S++, // <a foo="bar"
+    ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar
+    ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar="&quot;"
+    ATTRIB_VALUE_ENTITY_U: S++, // <foo bar=&quot
+    CLOSE_TAG: S++, // </a
+    CLOSE_TAG_SAW_WHITE: S++, // </a   >
+    SCRIPT: S++, // <script> ...
+    SCRIPT_ENDING: S++, // <script> ... <
+  };
+
+  sax.XML_ENTITIES = {
+    amp: "&",
+    gt: ">",
+    lt: "<",
+    quot: '"',
+    apos: "'",
+  };
+
+  sax.ENTITIES = {
+    amp: "&",
+    gt: ">",
+    lt: "<",
+    quot: '"',
+    apos: "'",
+    AElig: 198,
+    Aacute: 193,
+    Acirc: 194,
+    Agrave: 192,
+    Aring: 197,
+    Atilde: 195,
+    Auml: 196,
+    Ccedil: 199,
+    ETH: 208,
+    Eacute: 201,
+    Ecirc: 202,
+    Egrave: 200,
+    Euml: 203,
+    Iacute: 205,
+    Icirc: 206,
+    Igrave: 204,
+    Iuml: 207,
+    Ntilde: 209,
+    Oacute: 211,
+    Ocirc: 212,
+    Ograve: 210,
+    Oslash: 216,
+    Otilde: 213,
+    Ouml: 214,
+    THORN: 222,
+    Uacute: 218,
+    Ucirc: 219,
+    Ugrave: 217,
+    Uuml: 220,
+    Yacute: 221,
+    aacute: 225,
+    acirc: 226,
+    aelig: 230,
+    agrave: 224,
+    aring: 229,
+    atilde: 227,
+    auml: 228,
+    ccedil: 231,
+    eacute: 233,
+    ecirc: 234,
+    egrave: 232,
+    eth: 240,
+    euml: 235,
+    iacute: 237,
+    icirc: 238,
+    igrave: 236,
+    iuml: 239,
+    ntilde: 241,
+    oacute: 243,
+    ocirc: 244,
+    ograve: 242,
+    oslash: 248,
+    otilde: 245,
+    ouml: 246,
+    szlig: 223,
+    thorn: 254,
+    uacute: 250,
+    ucirc: 251,
+    ugrave: 249,
+    uuml: 252,
+    yacute: 253,
+    yuml: 255,
+    copy: 169,
+    reg: 174,
+    nbsp: 160,
+    iexcl: 161,
+    cent: 162,
+    pound: 163,
+    curren: 164,
+    yen: 165,
+    brvbar: 166,
+    sect: 167,
+    uml: 168,
+    ordf: 170,
+    laquo: 171,
+    not: 172,
+    shy: 173,
+    macr: 175,
+    deg: 176,
+    plusmn: 177,
+    sup1: 185,
+    sup2: 178,
+    sup3: 179,
+    acute: 180,
+    micro: 181,
+    para: 182,
+    middot: 183,
+    cedil: 184,
+    ordm: 186,
+    raquo: 187,
+    frac14: 188,
+    frac12: 189,
+    frac34: 190,
+    iquest: 191,
+    times: 215,
+    divide: 247,
+    OElig: 338,
+    oelig: 339,
+    Scaron: 352,
+    scaron: 353,
+    Yuml: 376,
+    fnof: 402,
+    circ: 710,
+    tilde: 732,
+    Alpha: 913,
+    Beta: 914,
+    Gamma: 915,
+    Delta: 916,
+    Epsilon: 917,
+    Zeta: 918,
+    Eta: 919,
+    Theta: 920,
+    Iota: 921,
+    Kappa: 922,
+    Lambda: 923,
+    Mu: 924,
+    Nu: 925,
+    Xi: 926,
+    Omicron: 927,
+    Pi: 928,
+    Rho: 929,
+    Sigma: 931,
+    Tau: 932,
+    Upsilon: 933,
+    Phi: 934,
+    Chi: 935,
+    Psi: 936,
+    Omega: 937,
+    alpha: 945,
+    beta: 946,
+    gamma: 947,
+    delta: 948,
+    epsilon: 949,
+    zeta: 950,
+    eta: 951,
+    theta: 952,
+    iota: 953,
+    kappa: 954,
+    lambda: 955,
+    mu: 956,
+    nu: 957,
+    xi: 958,
+    omicron: 959,
+    pi: 960,
+    rho: 961,
+    sigmaf: 962,
+    sigma: 963,
+    tau: 964,
+    upsilon: 965,
+    phi: 966,
+    chi: 967,
+    psi: 968,
+    omega: 969,
+    thetasym: 977,
+    upsih: 978,
+    piv: 982,
+    ensp: 8194,
+    emsp: 8195,
+    thinsp: 8201,
+    zwnj: 8204,
+    zwj: 8205,
+    lrm: 8206,
+    rlm: 8207,
+    ndash: 8211,
+    mdash: 8212,
+    lsquo: 8216,
+    rsquo: 8217,
+    sbquo: 8218,
+    ldquo: 8220,
+    rdquo: 8221,
+    bdquo: 8222,
+    dagger: 8224,
+    Dagger: 8225,
+    bull: 8226,
+    hellip: 8230,
+    permil: 8240,
+    prime: 8242,
+    Prime: 8243,
+    lsaquo: 8249,
+    rsaquo: 8250,
+    oline: 8254,
+    frasl: 8260,
+    euro: 8364,
+    image: 8465,
+    weierp: 8472,
+    real: 8476,
+    trade: 8482,
+    alefsym: 8501,
+    larr: 8592,
+    uarr: 8593,
+    rarr: 8594,
+    darr: 8595,
+    harr: 8596,
+    crarr: 8629,
+    lArr: 8656,
+    uArr: 8657,
+    rArr: 8658,
+    dArr: 8659,
+    hArr: 8660,
+    forall: 8704,
+    part: 8706,
+    exist: 8707,
+    empty: 8709,
+    nabla: 8711,
+    isin: 8712,
+    notin: 8713,
+    ni: 8715,
+    prod: 8719,
+    sum: 8721,
+    minus: 8722,
+    lowast: 8727,
+    radic: 8730,
+    prop: 8733,
+    infin: 8734,
+    ang: 8736,
+    and: 8743,
+    or: 8744,
+    cap: 8745,
+    cup: 8746,
+    int: 8747,
+    there4: 8756,
+    sim: 8764,
+    cong: 8773,
+    asymp: 8776,
+    ne: 8800,
+    equiv: 8801,
+    le: 8804,
+    ge: 8805,
+    sub: 8834,
+    sup: 8835,
+    nsub: 8836,
+    sube: 8838,
+    supe: 8839,
+    oplus: 8853,
+    otimes: 8855,
+    perp: 8869,
+    sdot: 8901,
+    lceil: 8968,
+    rceil: 8969,
+    lfloor: 8970,
+    rfloor: 8971,
+    lang: 9001,
+    rang: 9002,
+    loz: 9674,
+    spades: 9824,
+    clubs: 9827,
+    hearts: 9829,
+    diams: 9830,
+  };
+
+  Object.keys(sax.ENTITIES).forEach(function(key) {
+    var e = sax.ENTITIES[key];
+    var s = typeof e === "number" ? String.fromCharCode(e) : e;
+    sax.ENTITIES[key] = s;
+  });
+
+  for (var s in sax.STATE) {
+    sax.STATE[sax.STATE[s]] = s;
+  }
+
+  // shorthand
+  S = sax.STATE;
+
+  function emit(parser, event, data) {
+    parser[event] && parser[event](data);
+  }
+
+  function emitNode(parser, nodeType, data) {
+    if (parser.textNode) {
+      closeText(parser);
+    }
+    emit(parser, nodeType, data);
+  }
+
+  function closeText(parser) {
+    parser.textNode = textopts(parser.opt, parser.textNode);
+    if (parser.textNode) {
+      emit(parser, "ontext", parser.textNode);
+    }
+    parser.textNode = "";
+  }
+
+  function textopts(opt, text) {
+    if (opt.trim) {
+      text = text.trim();
+    }
+    if (opt.normalize) {
+      text = text.replace(/\s+/g, " ");
+    }
+    return text;
+  }
+
+  function error(parser, er) {
+    closeText(parser);
+    if (parser.trackPosition) {
+      er +=
+        "\nLine: " +
+        parser.line +
+        "\nColumn: " +
+        parser.column +
+        "\nChar: " +
+        parser.c;
+    }
+    er = new Error(er);
+    parser.error = er;
+    emit(parser, "onerror", er);
+    return parser;
+  }
+
+  function end(parser) {
+    if (parser.sawRoot && !parser.closedRoot) {
+      strictFail(parser, "Unclosed root tag");
+    }
+    if (
+      parser.state !== S.BEGIN &&
+      parser.state !== S.BEGIN_WHITESPACE &&
+      parser.state !== S.TEXT
+    ) {
+      error(parser, "Unexpected end");
+    }
+    closeText(parser);
+    parser.c = "";
+    parser.closed = true;
+    emit(parser, "onend");
+    SAXParser.call(parser, parser.strict, parser.opt);
+    return parser;
+  }
+
+  function strictFail(parser, message) {
+    if (typeof parser !== "object" || !(parser instanceof SAXParser)) {
+      throw new Error("bad call to strictFail");
+    }
+    if (parser.strict) {
+      error(parser, message);
+    }
+  }
+
+  function newTag(parser) {
+    if (!parser.strict) {
+      parser.tagName = parser.tagName[parser.looseCase]();
+    }
+    var parent = parser.tags[parser.tags.length - 1] || parser;
+    var tag = (parser.tag = { name: parser.tagName, attributes: {} });
+
+    // will be overridden if tag contails an xmlns="foo" or xmlns:foo="bar"
+    if (parser.opt.xmlns) {
+      tag.ns = parent.ns;
+    }
+    parser.attribList.length = 0;
+    emitNode(parser, "onopentagstart", tag);
+  }
+
+  function qname(name, attribute) {
+    var i = name.indexOf(":");
+    var qualName = i < 0 ? ["", name] : name.split(":");
+    var prefix = qualName[0];
+    var local = qualName[1];
+
+    // <x "xmlns"="http://foo">
+    if (attribute && name === "xmlns") {
+      prefix = "xmlns";
+      local = "";
+    }
+
+    return { prefix, local };
+  }
+
+  function attrib(parser) {
+    if (!parser.strict) {
+      parser.attribName = parser.attribName[parser.looseCase]();
+    }
+
+    if (
+      parser.attribList.indexOf(parser.attribName) !== -1 ||
+      parser.tag.attributes.hasOwnProperty(parser.attribName)
+    ) {
+      parser.attribName = parser.attribValue = "";
+      return;
+    }
+
+    if (parser.opt.xmlns) {
+      var qn = qname(parser.attribName, true);
+      var prefix = qn.prefix;
+      var local = qn.local;
+
+      if (prefix === "xmlns") {
+        // namespace binding attribute. push the binding into scope
+        if (local === "xml" && parser.attribValue !== XML_NAMESPACE) {
+          strictFail(
+            parser,
+            "xml: prefix must be bound to " +
+              XML_NAMESPACE +
+              "\n" +
+              "Actual: " +
+              parser.attribValue
+          );
+        } else if (
+          local === "xmlns" &&
+          parser.attribValue !== XMLNS_NAMESPACE
+        ) {
+          strictFail(
+            parser,
+            "xmlns: prefix must be bound to " +
+              XMLNS_NAMESPACE +
+              "\n" +
+              "Actual: " +
+              parser.attribValue
+          );
+        } else {
+          var tag = parser.tag;
+          var parent = parser.tags[parser.tags.length - 1] || parser;
+          if (tag.ns === parent.ns) {
+            tag.ns = Object.create(parent.ns);
+          }
+          tag.ns[local] = parser.attribValue;
+        }
+      }
+
+      // defer onattribute events until all attributes have been seen
+      // so any new bindings can take effect. preserve attribute order
+      // so deferred events can be emitted in document order
+      parser.attribList.push([parser.attribName, parser.attribValue]);
+    } else {
+      // in non-xmlns mode, we can emit the event right away
+      parser.tag.attributes[parser.attribName] = parser.attribValue;
+      emitNode(parser, "onattribute", {
+        name: parser.attribName,
+        value: parser.attribValue,
+      });
+    }
+
+    parser.attribName = parser.attribValue = "";
+  }
+
+  function openTag(parser, selfClosing) {
+    if (parser.opt.xmlns) {
+      // emit namespace binding events
+      var tag = parser.tag;
+
+      // add namespace info to tag
+      var qn = qname(parser.tagName);
+      tag.prefix = qn.prefix;
+      tag.local = qn.local;
+      tag.uri = tag.ns[qn.prefix] || "";
+
+      if (tag.prefix && !tag.uri) {
+        strictFail(
+          parser,
+          "Unbound namespace prefix: " + JSON.stringify(parser.tagName)
+        );
+        tag.uri = qn.prefix;
+      }
+
+      var parent = parser.tags[parser.tags.length - 1] || parser;
+      if (tag.ns && parent.ns !== tag.ns) {
+        Object.keys(tag.ns).forEach(function(p) {
+          emitNode(parser, "onopennamespace", {
+            prefix: p,
+            uri: tag.ns[p],
+          });
+        });
+      }
+
+      // handle deferred onattribute events
+      // Note: do not apply default ns to attributes:
+      //   http://www.w3.org/TR/REC-xml-names/#defaulting
+      for (var i = 0, l = parser.attribList.length; i < l; i++) {
+        var nv = parser.attribList[i];
+        var name = nv[0];
+        var value = nv[1];
+        var qualName = qname(name, true);
+        var prefix = qualName.prefix;
+        var local = qualName.local;
+        var uri = prefix === "" ? "" : tag.ns[prefix] || "";
+        var a = {
+          name,
+          value,
+          prefix,
+          local,
+          uri,
+        };
+
+        // if there's any attributes with an undefined namespace,
+        // then fail on them now.
+        if (prefix && prefix !== "xmlns" && !uri) {
+          strictFail(
+            parser,
+            "Unbound namespace prefix: " + JSON.stringify(prefix)
+          );
+          a.uri = prefix;
+        }
+        parser.tag.attributes[name] = a;
+        emitNode(parser, "onattribute", a);
+      }
+      parser.attribList.length = 0;
+    }
+
+    parser.tag.isSelfClosing = !!selfClosing;
+
+    // process the tag
+    parser.sawRoot = true;
+    parser.tags.push(parser.tag);
+    emitNode(parser, "onopentag", parser.tag);
+    if (!selfClosing) {
+      // special case for <script> in non-strict mode.
+      if (!parser.noscript && parser.tagName.toLowerCase() === "script") {
+        parser.state = S.SCRIPT;
+      } else {
+        parser.state = S.TEXT;
+      }
+      parser.tag = null;
+      parser.tagName = "";
+    }
+    parser.attribName = parser.attribValue = "";
+    parser.attribList.length = 0;
+  }
+
+  function closeTag(parser) {
+    if (!parser.tagName) {
+      strictFail(parser, "Weird empty close tag.");
+      parser.textNode += "</>";
+      parser.state = S.TEXT;
+      return;
+    }
+
+    if (parser.script) {
+      if (parser.tagName !== "script") {
+        parser.script += "</" + parser.tagName + ">";
+        parser.tagName = "";
+        parser.state = S.SCRIPT;
+        return;
+      }
+      emitNode(parser, "onscript", parser.script);
+      parser.script = "";
+    }
+
+    // first make sure that the closing tag actually exists.
+    // <a><b></c></b></a> will close everything, otherwise.
+    var t = parser.tags.length;
+    var tagName = parser.tagName;
+    if (!parser.strict) {
+      tagName = tagName[parser.looseCase]();
+    }
+    var closeTo = tagName;
+    while (t--) {
+      var close = parser.tags[t];
+      if (close.name !== closeTo) {
+        // fail the first time in strict mode
+        strictFail(parser, "Unexpected close tag");
+      } else {
+        break;
+      }
+    }
+
+    // didn't find it.  we already failed for strict, so just abort.
+    if (t < 0) {
+      strictFail(parser, "Unmatched closing tag: " + parser.tagName);
+      parser.textNode += "</" + parser.tagName + ">";
+      parser.state = S.TEXT;
+      return;
+    }
+    parser.tagName = tagName;
+    var s = parser.tags.length;
+    while (s-- > t) {
+      var tag = (parser.tag = parser.tags.pop());
+      parser.tagName = parser.tag.name;
+      emitNode(parser, "onclosetag", parser.tagName);
+
+      var x = {};
+      for (var i in tag.ns) {
+        x[i] = tag.ns[i];
+      }
+
+      var parent = parser.tags[parser.tags.length - 1] || parser;
+      if (parser.opt.xmlns && tag.ns !== parent.ns) {
+        // remove namespace bindings introduced by tag
+        Object.keys(tag.ns).forEach(function(p) {
+          var n = tag.ns[p];
+          emitNode(parser, "onclosenamespace", { prefix: p, uri: n });
+        });
+      }
+    }
+    if (t === 0) {
+      parser.closedRoot = true;
+    }
+    parser.tagName = parser.attribValue = parser.attribName = "";
+    parser.attribList.length = 0;
+    parser.state = S.TEXT;
+  }
+
+  function parseEntity(parser) {
+    var entity = parser.entity;
+    var entityLC = entity.toLowerCase();
+    var num;
+    var numStr = "";
+
+    if (parser.ENTITIES[entity]) {
+      return parser.ENTITIES[entity];
+    }
+    if (parser.ENTITIES[entityLC]) {
+      return parser.ENTITIES[entityLC];
+    }
+    entity = entityLC;
+    if (entity.charAt(0) === "#") {
+      if (entity.charAt(1) === "x") {
+        entity = entity.slice(2);
+        num = parseInt(entity, 16);
+        numStr = num.toString(16);
+      } else {
+        entity = entity.slice(1);
+        num = parseInt(entity, 10);
+        numStr = num.toString(10);
+      }
+    }
+    entity = entity.replace(/^0+/, "");
+    if (isNaN(num) || numStr.toLowerCase() !== entity) {
+      strictFail(parser, "Invalid character entity");
+      return "&" + parser.entity + ";";
+    }
+
+    return String.fromCodePoint(num);
+  }
+
+  function beginWhiteSpace(parser, c) {
+    if (c === "<") {
+      parser.state = S.OPEN_WAKA;
+      parser.startTagPosition = parser.position;
+    } else if (!isWhitespace(c)) {
+      // have to process this as a text node.
+      // weird, but happens.
+      strictFail(parser, "Non-whitespace before first tag.");
+      parser.textNode = c;
+      parser.state = S.TEXT;
+    }
+  }
+
+  function charAt(chunk, i) {
+    var result = "";
+    if (i < chunk.length) {
+      result = chunk.charAt(i);
+    }
+    return result;
+  }
+
+  function write(chunk) {
+    var parser = this;
+    if (this.error) {
+      throw this.error;
+    }
+    if (parser.closed) {
+      return error(
+        parser,
+        "Cannot write after close. Assign an onready handler."
+      );
+    }
+    if (chunk === null) {
+      return end(parser);
+    }
+    if (typeof chunk === "object") {
+      chunk = chunk.toString();
+    }
+    var i = 0;
+    var c = "";
+    while (true) {
+      c = charAt(chunk, i++);
+      parser.c = c;
+
+      if (!c) {
+        break;
+      }
+
+      if (parser.trackPosition) {
+        parser.position++;
+        if (c === "\n") {
+          parser.line++;
+          parser.column = 0;
+        } else {
+          parser.column++;
+        }
+      }
+
+      switch (parser.state) {
+        case S.BEGIN:
+          parser.state = S.BEGIN_WHITESPACE;
+          if (c === "\uFEFF") {
+            continue;
+          }
+          beginWhiteSpace(parser, c);
+          continue;
+
+        case S.BEGIN_WHITESPACE:
+          beginWhiteSpace(parser, c);
+          continue;
+
+        case S.TEXT:
+          if (parser.sawRoot && !parser.closedRoot) {
+            var starti = i - 1;
+            while (c && c !== "<" && c !== "&") {
+              c = charAt(chunk, i++);
+              if (c && parser.trackPosition) {
+                parser.position++;
+                if (c === "\n") {
+                  parser.line++;
+                  parser.column = 0;
+                } else {
+                  parser.column++;
+                }
+              }
+            }
+            parser.textNode += chunk.substring(starti, i - 1);
+          }
+          if (
+            c === "<" &&
+            !(parser.sawRoot && parser.closedRoot && !parser.strict)
+          ) {
+            parser.state = S.OPEN_WAKA;
+            parser.startTagPosition = parser.position;
+          } else {
+            if (!isWhitespace(c) && (!parser.sawRoot || parser.closedRoot)) {
+              strictFail(parser, "Text data outside of root node.");
+            }
+            if (c === "&") {
+              parser.state = S.TEXT_ENTITY;
+            } else {
+              parser.textNode += c;
+            }
+          }
+          continue;
+
+        case S.SCRIPT:
+          // only non-strict
+          if (c === "<") {
+            parser.state = S.SCRIPT_ENDING;
+          } else {
+            parser.script += c;
+          }
+          continue;
+
+        case S.SCRIPT_ENDING:
+          if (c === "/") {
+            parser.state = S.CLOSE_TAG;
+          } else {
+            parser.script += "<" + c;
+            parser.state = S.SCRIPT;
+          }
+          continue;
+
+        case S.OPEN_WAKA:
+          // either a /, ?, !, or text is coming next.
+          if (c === "!") {
+            parser.state = S.SGML_DECL;
+            parser.sgmlDecl = "";
+          } else if (isWhitespace(c)) {
+            // wait for it...
+          } else if (isMatch(nameStart, c)) {
+            parser.state = S.OPEN_TAG;
+            parser.tagName = c;
+          } else if (c === "/") {
+            parser.state = S.CLOSE_TAG;
+            parser.tagName = "";
+          } else if (c === "?") {
+            parser.state = S.PROC_INST;
+            parser.procInstName = parser.procInstBody = "";
+          } else {
+            strictFail(parser, "Unencoded <");
+            // if there was some whitespace, then add that in.
+            if (parser.startTagPosition + 1 < parser.position) {
+              var pad = parser.position - parser.startTagPosition;
+              c = new Array(pad).join(" ") + c;
+            }
+            parser.textNode += "<" + c;
+            parser.state = S.TEXT;
+          }
+          continue;
+
+        case S.SGML_DECL:
+          if ((parser.sgmlDecl + c).toUpperCase() === CDATA) {
+            emitNode(parser, "onopencdata");
+            parser.state = S.CDATA;
+            parser.sgmlDecl = "";
+            parser.cdata = "";
+          } else if (parser.sgmlDecl + c === "--") {
+            parser.state = S.COMMENT;
+            parser.comment = "";
+            parser.sgmlDecl = "";
+          } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {
+            parser.state = S.DOCTYPE;
+            if (parser.doctype || parser.sawRoot) {
+              strictFail(parser, "Inappropriately located doctype declaration");
+            }
+            parser.doctype = "";
+            parser.sgmlDecl = "";
+          } else if (c === ">") {
+            emitNode(parser, "onsgmldeclaration", parser.sgmlDecl);
+            parser.sgmlDecl = "";
+            parser.state = S.TEXT;
+          } else if (isQuote(c)) {
+            parser.state = S.SGML_DECL_QUOTED;
+            parser.sgmlDecl += c;
+          } else {
+            parser.sgmlDecl += c;
+          }
+          continue;
+
+        case S.SGML_DECL_QUOTED:
+          if (c === parser.q) {
+            parser.state = S.SGML_DECL;
+            parser.q = "";
+          }
+          parser.sgmlDecl += c;
+          continue;
+
+        case S.DOCTYPE:
+          if (c === ">") {
+            parser.state = S.TEXT;
+            emitNode(parser, "ondoctype", parser.doctype);
+            parser.doctype = true; // just remember that we saw it.
+          } else {
+            parser.doctype += c;
+            if (c === "[") {
+              parser.state = S.DOCTYPE_DTD;
+            } else if (isQuote(c)) {
+              parser.state = S.DOCTYPE_QUOTED;
+              parser.q = c;
+            }
+          }
+          continue;
+
+        case S.DOCTYPE_QUOTED:
+          parser.doctype += c;
+          if (c === parser.q) {
+            parser.q = "";
+            parser.state = S.DOCTYPE;
+          }
+          continue;
+
+        case S.DOCTYPE_DTD:
+          parser.doctype += c;
+          if (c === "]") {
+            parser.state = S.DOCTYPE;
+          } else if (isQuote(c)) {
+            parser.state = S.DOCTYPE_DTD_QUOTED;
+            parser.q = c;
+          }
+          continue;
+
+        case S.DOCTYPE_DTD_QUOTED:
+          parser.doctype += c;
+          if (c === parser.q) {
+            parser.state = S.DOCTYPE_DTD;
+            parser.q = "";
+          }
+          continue;
+
+        case S.COMMENT:
+          if (c === "-") {
+            parser.state = S.COMMENT_ENDING;
+          } else {
+            parser.comment += c;
+          }
+          continue;
+
+        case S.COMMENT_ENDING:
+          if (c === "-") {
+            parser.state = S.COMMENT_ENDED;
+            parser.comment = textopts(parser.opt, parser.comment);
+            if (parser.comment) {
+              emitNode(parser, "oncomment", parser.comment);
+            }
+            parser.comment = "";
+          } else {
+            parser.comment += "-" + c;
+            parser.state = S.COMMENT;
+          }
+          continue;
+
+        case S.COMMENT_ENDED:
+          if (c !== ">") {
+            strictFail(parser, "Malformed comment");
+            // allow <!-- blah -- bloo --> in non-strict mode,
+            // which is a comment of " blah -- bloo "
+            parser.comment += "--" + c;
+            parser.state = S.COMMENT;
+          } else {
+            parser.state = S.TEXT;
+          }
+          continue;
+
+        case S.CDATA:
+          if (c === "]") {
+            parser.state = S.CDATA_ENDING;
+          } else {
+            parser.cdata += c;
+          }
+          continue;
+
+        case S.CDATA_ENDING:
+          if (c === "]") {
+            parser.state = S.CDATA_ENDING_2;
+          } else {
+            parser.cdata += "]" + c;
+            parser.state = S.CDATA;
+          }
+          continue;
+
+        case S.CDATA_ENDING_2:
+          if (c === ">") {
+            if (parser.cdata) {
+              emitNode(parser, "oncdata", parser.cdata);
+            }
+            emitNode(parser, "onclosecdata");
+            parser.cdata = "";
+            parser.state = S.TEXT;
+          } else if (c === "]") {
+            parser.cdata += "]";
+          } else {
+            parser.cdata += "]]" + c;
+            parser.state = S.CDATA;
+          }
+          continue;
+
+        case S.PROC_INST:
+          if (c === "?") {
+            parser.state = S.PROC_INST_ENDING;
+          } else if (isWhitespace(c)) {
+            parser.state = S.PROC_INST_BODY;
+          } else {
+            parser.procInstName += c;
+          }
+          continue;
+
+        case S.PROC_INST_BODY:
+          if (!parser.procInstBody && isWhitespace(c)) {
+            continue;
+          } else if (c === "?") {
+            parser.state = S.PROC_INST_ENDING;
+          } else {
+            parser.procInstBody += c;
+          }
+          continue;
+
+        case S.PROC_INST_ENDING:
+          if (c === ">") {
+            emitNode(parser, "onprocessinginstruction", {
+              name: parser.procInstName,
+              body: parser.procInstBody,
+            });
+            parser.procInstName = parser.procInstBody = "";
+            parser.state = S.TEXT;
+          } else {
+            parser.procInstBody += "?" + c;
+            parser.state = S.PROC_INST_BODY;
+          }
+          continue;
+
+        case S.OPEN_TAG:
+          if (isMatch(nameBody, c)) {
+            parser.tagName += c;
+          } else {
+            newTag(parser);
+            if (c === ">") {
+              openTag(parser);
+            } else if (c === "/") {
+              parser.state = S.OPEN_TAG_SLASH;
+            } else {
+              if (!isWhitespace(c)) {
+                strictFail(parser, "Invalid character in tag name");
+              }
+              parser.state = S.ATTRIB;
+            }
+          }
+          continue;
+
+        case S.OPEN_TAG_SLASH:
+          if (c === ">") {
+            openTag(parser, true);
+            closeTag(parser);
+          } else {
+            strictFail(
+              parser,
+              "Forward-slash in opening tag not followed by >"
+            );
+            parser.state = S.ATTRIB;
+          }
+          continue;
+
+        case S.ATTRIB:
+          // haven't read the attribute name yet.
+          if (isWhitespace(c)) {
+            continue;
+          } else if (c === ">") {
+            openTag(parser);
+          } else if (c === "/") {
+            parser.state = S.OPEN_TAG_SLASH;
+          } else if (isMatch(nameStart, c)) {
+            parser.attribName = c;
+            parser.attribValue = "";
+            parser.state = S.ATTRIB_NAME;
+          } else {
+            strictFail(parser, "Invalid attribute name");
+          }
+          continue;
+
+        case S.ATTRIB_NAME:
+          if (c === "=") {
+            parser.state = S.ATTRIB_VALUE;
+          } else if (c === ">") {
+            strictFail(parser, "Attribute without value");
+            parser.attribValue = parser.attribName;
+            attrib(parser);
+            openTag(parser);
+          } else if (isWhitespace(c)) {
+            parser.state = S.ATTRIB_NAME_SAW_WHITE;
+          } else if (isMatch(nameBody, c)) {
+            parser.attribName += c;
+          } else {
+            strictFail(parser, "Invalid attribute name");
+          }
+          continue;
+
+        case S.ATTRIB_NAME_SAW_WHITE:
+          if (c === "=") {
+            parser.state = S.ATTRIB_VALUE;
+          } else if (isWhitespace(c)) {
+            continue;
+          } else {
+            strictFail(parser, "Attribute without value");
+            parser.tag.attributes[parser.attribName] = "";
+            parser.attribValue = "";
+            emitNode(parser, "onattribute", {
+              name: parser.attribName,
+              value: "",
+            });
+            parser.attribName = "";
+            if (c === ">") {
+              openTag(parser);
+            } else if (isMatch(nameStart, c)) {
+              parser.attribName = c;
+              parser.state = S.ATTRIB_NAME;
+            } else {
+              strictFail(parser, "Invalid attribute name");
+              parser.state = S.ATTRIB;
+            }
+          }
+          continue;
+
+        case S.ATTRIB_VALUE:
+          if (isWhitespace(c)) {
+            continue;
+          } else if (isQuote(c)) {
+            parser.q = c;
+            parser.state = S.ATTRIB_VALUE_QUOTED;
+          } else {
+            strictFail(parser, "Unquoted attribute value");
+            parser.state = S.ATTRIB_VALUE_UNQUOTED;
+            parser.attribValue = c;
+          }
+          continue;
+
+        case S.ATTRIB_VALUE_QUOTED:
+          if (c !== parser.q) {
+            if (c === "&") {
+              parser.state = S.ATTRIB_VALUE_ENTITY_Q;
+            } else {
+              parser.attribValue += c;
+            }
+            continue;
+          }
+          attrib(parser);
+          parser.q = "";
+          parser.state = S.ATTRIB_VALUE_CLOSED;
+          continue;
+
+        case S.ATTRIB_VALUE_CLOSED:
+          if (isWhitespace(c)) {
+            parser.state = S.ATTRIB;
+          } else if (c === ">") {
+            openTag(parser);
+          } else if (c === "/") {
+            parser.state = S.OPEN_TAG_SLASH;
+          } else if (isMatch(nameStart, c)) {
+            strictFail(parser, "No whitespace between attributes");
+            parser.attribName = c;
+            parser.attribValue = "";
+            parser.state = S.ATTRIB_NAME;
+          } else {
+            strictFail(parser, "Invalid attribute name");
+          }
+          continue;
+
+        case S.ATTRIB_VALUE_UNQUOTED:
+          if (!isAttribEnd(c)) {
+            if (c === "&") {
+              parser.state = S.ATTRIB_VALUE_ENTITY_U;
+            } else {
+              parser.attribValue += c;
+            }
+            continue;
+          }
+          attrib(parser);
+          if (c === ">") {
+            openTag(parser);
+          } else {
+            parser.state = S.ATTRIB;
+          }
+          continue;
+
+        case S.CLOSE_TAG:
+          if (!parser.tagName) {
+            if (isWhitespace(c)) {
+              continue;
+            } else if (notMatch(nameStart, c)) {
+              if (parser.script) {
+                parser.script += "</" + c;
+                parser.state = S.SCRIPT;
+              } else {
+                strictFail(parser, "Invalid tagname in closing tag.");
+              }
+            } else {
+              parser.tagName = c;
+            }
+          } else if (c === ">") {
+            closeTag(parser);
+          } else if (isMatch(nameBody, c)) {
+            parser.tagName += c;
+          } else if (parser.script) {
+            parser.script += "</" + parser.tagName;
+            parser.tagName = "";
+            parser.state = S.SCRIPT;
+          } else {
+            if (!isWhitespace(c)) {
+              strictFail(parser, "Invalid tagname in closing tag");
+            }
+            parser.state = S.CLOSE_TAG_SAW_WHITE;
+          }
+          continue;
+
+        case S.CLOSE_TAG_SAW_WHITE:
+          if (isWhitespace(c)) {
+            continue;
+          }
+          if (c === ">") {
+            closeTag(parser);
+          } else {
+            strictFail(parser, "Invalid characters in closing tag");
+          }
+          continue;
+
+        case S.TEXT_ENTITY:
+        case S.ATTRIB_VALUE_ENTITY_Q:
+        case S.ATTRIB_VALUE_ENTITY_U:
+          var returnState;
+          var buffer;
+          switch (parser.state) {
+            case S.TEXT_ENTITY:
+              returnState = S.TEXT;
+              buffer = "textNode";
+              break;
+
+            case S.ATTRIB_VALUE_ENTITY_Q:
+              returnState = S.ATTRIB_VALUE_QUOTED;
+              buffer = "attribValue";
+              break;
+
+            case S.ATTRIB_VALUE_ENTITY_U:
+              returnState = S.ATTRIB_VALUE_UNQUOTED;
+              buffer = "attribValue";
+              break;
+          }
+
+          if (c === ";") {
+            parser[buffer] += parseEntity(parser);
+            parser.entity = "";
+            parser.state = returnState;
+          } else if (
+            isMatch(parser.entity.length ? entityBody : entityStart, c)
+          ) {
+            parser.entity += c;
+          } else {
+            strictFail(parser, "Invalid character in entity name");
+            parser[buffer] += "&" + parser.entity + c;
+            parser.entity = "";
+            parser.state = returnState;
+          }
+
+          continue;
+
+        default:
+          throw new Error(parser, "Unknown state: " + parser.state);
+      }
+    } // while
+
+    if (parser.position >= parser.bufferCheckPosition) {
+      checkBufferLength(parser);
+    }
+    return parser;
+  }
+
+  /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
+  /* istanbul ignore next */
+  if (!String.fromCodePoint) {
+    (function() {
+      var stringFromCharCode = String.fromCharCode;
+      var floor = Math.floor;
+      var fromCodePoint = function() {
+        var MAX_SIZE = 0x4000;
+        var codeUnits = [];
+        var highSurrogate;
+        var lowSurrogate;
+        var index = -1;
+        var length = arguments.length;
+        if (!length) {
+          return "";
+        }
+        var result = "";
+        while (++index < length) {
+          var codePoint = Number(arguments[index]);
+          if (
+            !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
+            codePoint < 0 || // not a valid Unicode code point
+            codePoint > 0x10ffff || // not a valid Unicode code point
+            floor(codePoint) !== codePoint // not an integer
+          ) {
+            throw RangeError("Invalid code point: " + codePoint);
+          }
+          if (codePoint <= 0xffff) {
+            // BMP code point
+            codeUnits.push(codePoint);
+          } else {
+            // Astral code point; split in surrogate halves
+            // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+            codePoint -= 0x10000;
+            highSurrogate = (codePoint >> 10) + 0xd800;
+            lowSurrogate = (codePoint % 0x400) + 0xdc00;
+            codeUnits.push(highSurrogate, lowSurrogate);
+          }
+          if (index + 1 === length || codeUnits.length > MAX_SIZE) {
+            result += stringFromCharCode.apply(null, codeUnits);
+            codeUnits.length = 0;
+          }
+        }
+        return result;
+      };
+      /* istanbul ignore next */
+      if (Object.defineProperty) {
+        Object.defineProperty(String, "fromCodePoint", {
+          value: fromCodePoint,
+          configurable: true,
+          writable: true,
+        });
+      } else {
+        String.fromCodePoint = fromCodePoint;
+      }
+    })();
+  }
+})(typeof exports === "undefined" ? (this.sax = {}) : exports);
diff --git a/comm/chat/protocols/xmpp/moz.build b/comm/chat/protocols/xmpp/moz.build
new file mode 100644
index 0000000000..56140aeef6
--- /dev/null
+++ b/comm/chat/protocols/xmpp/moz.build
@@ -0,0 +1,26 @@
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+XPCSHELL_TESTS_MANIFESTS += ["test/xpcshell.ini"]
+
+DIRS += [
+    "lib",
+]
+
+EXTRA_JS_MODULES += [
+    "sax.sys.mjs",
+    "xmpp-authmechs.sys.mjs",
+    "xmpp-base.sys.mjs",
+    "xmpp-commands.sys.mjs",
+    "xmpp-session.sys.mjs",
+    "xmpp-xml.sys.mjs",
+    "xmpp.sys.mjs",
+]
+
+JAR_MANIFESTS += ["jar.mn"]
+
+XPCOM_MANIFESTS += [
+    "components.conf",
+]
diff --git a/comm/chat/protocols/xmpp/sax.sys.mjs b/comm/chat/protocols/xmpp/sax.sys.mjs
new file mode 100644
index 0000000000..3098c6df79
--- /dev/null
+++ b/comm/chat/protocols/xmpp/sax.sys.mjs
@@ -0,0 +1,7 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+let scope = {};
+Services.scriptloader.loadSubScript("resource:///modules/sax/sax.js", scope);
+export var SAX = scope.sax;
diff --git a/comm/chat/protocols/xmpp/test/test_authmechs.js b/comm/chat/protocols/xmpp/test/test_authmechs.js
new file mode 100644
index 0000000000..f935026dbc
--- /dev/null
+++ b/comm/chat/protocols/xmpp/test/test_authmechs.js
@@ -0,0 +1,160 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { XMPPAuthMechanisms } = ChromeUtils.importESModule(
+  "resource:///modules/xmpp-authmechs.sys.mjs"
+);
+var { Stanza } = ChromeUtils.importESModule(
+  "resource:///modules/xmpp-xml.sys.mjs"
+);
+
+/*
+ * Test PLAIN using the examples given in section 6 of RFC 6120.
+ */
+add_task(async function testPlain() {
+  const username = "juliet";
+  const password = "r0m30myr0m30";
+
+  let mech = XMPPAuthMechanisms.PLAIN(username, password, undefined);
+
+  // Send the initiation message.
+  let result = mech.next();
+  ok(!result.done);
+  let value = await Promise.resolve(result.value);
+
+  // Check the algorithm.
+  equal(value.send.attributes.mechanism, "PLAIN");
+  // Check the PLAIN content.
+  equal(value.send.children[0].text, "AGp1bGlldAByMG0zMG15cjBtMzA=");
+
+  // Receive the success.
+  let response = Stanza.node("success", Stanza.NS.sasl);
+  result = mech.next(response);
+  ok(result.done);
+  // There is no final value.
+  equal(result.value, undefined);
+});
+
+/*
+ * Test SCRAM-SHA-1 using the examples given in section 5 of RFC 5802.
+ *
+ * Full test vectors of intermediate values are available at:
+ * https://wiki.xmpp.org/web/SASL_and_SCRAM-SHA-1
+ */
+add_task(async function testScramSha1() {
+  const username = "user";
+  const password = "pencil";
+
+  // Use a constant value for the nonce.
+  const nonce = "fyko+d2lbbFgONRv9qkxdawL";
+
+  let mech = XMPPAuthMechanisms["SCRAM-SHA-1"](
+    username,
+    password,
+    undefined,
+    nonce
+  );
+
+  // Send the client-first-message.
+  let result = mech.next();
+  ok(!result.done);
+  let value = await Promise.resolve(result.value);
+
+  // Check the algorithm.
+  equal(value.send.attributes.mechanism, "SCRAM-SHA-1");
+  // Check the SCRAM content.
+  equal(
+    atob(value.send.children[0].text),
+    "n,,n=user,r=fyko+d2lbbFgONRv9qkxdawL"
+  );
+
+  // Receive the server-first-message and send the client-final-message.
+  let response = Stanza.node(
+    "challenge",
+    Stanza.NS.sasl,
+    null,
+    btoa(
+      "r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,s=QSXCR+Q6sek8bf92,i=4096"
+    )
+  );
+  result = mech.next(response);
+  ok(!result.done);
+  value = await Promise.resolve(result.value);
+
+  // Check the SCRAM content.
+  equal(
+    atob(value.send.children[0].text),
+    "c=biws,r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,p=v0X8v3Bz2T0CJGbJQyF0X+HI4Ts="
+  );
+
+  // Receive the server-final-message.
+  response = Stanza.node(
+    "success",
+    Stanza.NS.sasl,
+    null,
+    btoa("v=rmF9pqV8S7suAoZWja4dJRkFsKQ=")
+  );
+  result = mech.next(response);
+  ok(result.done);
+  // There is no final value.
+  equal(result.value, undefined);
+});
+
+/*
+ * Test SCRAM-SHA-256 using the examples given in section 3 of RFC 7677.
+ */
+add_task(async function testScramSha256() {
+  const username = "user";
+  const password = "pencil";
+
+  // Use a constant value for the nonce.
+  const nonce = "rOprNGfwEbeRWgbNEkqO";
+
+  let mech = XMPPAuthMechanisms["SCRAM-SHA-256"](
+    username,
+    password,
+    undefined,
+    nonce
+  );
+
+  // Send the client-first-message.
+  let result = mech.next();
+  ok(!result.done);
+  let value = await Promise.resolve(result.value);
+
+  // Check the algorithm.
+  equal(value.send.attributes.mechanism, "SCRAM-SHA-256");
+  // Check the SCRAM content.
+  equal(atob(value.send.children[0].text), "n,,n=user,r=rOprNGfwEbeRWgbNEkqO");
+
+  // Receive the server-first-message and send the client-final-message.
+  let response = Stanza.node(
+    "challenge",
+    Stanza.NS.sasl,
+    null,
+    btoa(
+      "r=rOprNGfwEbeRWgbNEkqO%hvYDpWUa2RaTCAfuxFIlj)hNlF$k0,s=W22ZaJ0SNY7soEsUEjb6gQ==,i=4096"
+    )
+  );
+  result = mech.next(response);
+  ok(!result.done);
+  value = await Promise.resolve(result.value);
+
+  // Check the SCRAM content.
+  equal(
+    atob(value.send.children[0].text),
+    "c=biws,r=rOprNGfwEbeRWgbNEkqO%hvYDpWUa2RaTCAfuxFIlj)hNlF$k0,p=dHzbZapWIk4jUhN+Ute9ytag9zjfMHgsqmmiz7AndVQ="
+  );
+
+  // Receive the server-final-message.
+  response = Stanza.node(
+    "success",
+    Stanza.NS.sasl,
+    null,
+    btoa("v=6rriTRBi23WpRR/wtup+mMhUZUn/dB5nLTJRsjl95G4=")
+  );
+  result = mech.next(response);
+  ok(result.done);
+  // There is no final value.
+  equal(result.value, undefined);
+});
diff --git a/comm/chat/protocols/xmpp/test/test_dnsSrv.js b/comm/chat/protocols/xmpp/test/test_dnsSrv.js
new file mode 100644
index 0000000000..37f1b6b052
--- /dev/null
+++ b/comm/chat/protocols/xmpp/test/test_dnsSrv.js
@@ -0,0 +1,112 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { XMPPAccountPrototype } = ChromeUtils.importESModule(
+  "resource:///modules/xmpp-base.sys.mjs"
+);
+var { XMPPSession } = ChromeUtils.importESModule(
+  "resource:///modules/xmpp-session.sys.mjs"
+);
+var { SRVRecord } = ChromeUtils.import("resource:///modules/DNS.jsm");
+
+function FakeXMPPSession() {}
+FakeXMPPSession.prototype = {
+  __proto__: XMPPSession.prototype,
+  _account: { __proto__: XMPPAccountPrototype },
+  _host: null,
+  _port: 0,
+  connect(
+    aHostOrigin,
+    aPortOrigin,
+    aSecurity,
+    aProxy,
+    aHost = aHostOrigin,
+    aPort = aPortOrigin
+  ) {},
+  _connectNextRecord() {
+    this.isConnectNextRecord = true;
+  },
+
+  // Used to indicate that method _connectNextRecord is called or not.
+  isConnectNextRecord: false,
+
+  LOG(aMsg) {},
+  WARN(aMsg) {},
+};
+
+var TEST_DATA = [
+  {
+    // Test sorting based on priority and weight.
+    input: [
+      new SRVRecord(20, 0, "xmpp.instantbird.com", 5222),
+      new SRVRecord(5, 0, "xmpp1.instantbird.com", 5222),
+      new SRVRecord(10, 0, "xmpp2.instantbird.com", 5222),
+      new SRVRecord(0, 0, "xmpp3.instantbird.com", 5222),
+      new SRVRecord(15, 0, "xmpp4.instantbird.com", 5222),
+    ],
+    output: [
+      new SRVRecord(0, 0, "xmpp3.instantbird.com", 5222),
+      new SRVRecord(5, 0, "xmpp1.instantbird.com", 5222),
+      new SRVRecord(10, 0, "xmpp2.instantbird.com", 5222),
+      new SRVRecord(15, 0, "xmpp4.instantbird.com", 5222),
+      new SRVRecord(20, 0, "xmpp.instantbird.com", 5222),
+    ],
+    isConnectNextRecord: true,
+  },
+  {
+    input: [
+      new SRVRecord(5, 30, "xmpp5.instantbird.com", 5222),
+      new SRVRecord(5, 0, "xmpp1.instantbird.com", 5222),
+      new SRVRecord(10, 60, "xmpp2.instantbird.com", 5222),
+      new SRVRecord(5, 10, "xmpp3.instantbird.com", 5222),
+      new SRVRecord(20, 10, "xmpp.instantbird.com", 5222),
+      new SRVRecord(15, 0, "xmpp4.instantbird.com", 5222),
+    ],
+    output: [
+      new SRVRecord(5, 30, "xmpp5.instantbird.com", 5222),
+      new SRVRecord(5, 10, "xmpp3.instantbird.com", 5222),
+      new SRVRecord(5, 0, "xmpp1.instantbird.com", 5222),
+      new SRVRecord(10, 60, "xmpp2.instantbird.com", 5222),
+      new SRVRecord(15, 0, "xmpp4.instantbird.com", 5222),
+      new SRVRecord(20, 10, "xmpp.instantbird.com", 5222),
+    ],
+    isConnectNextRecord: true,
+  },
+
+  // Tests no SRV records are found.
+  {
+    input: [],
+    output: [],
+    isConnectNextRecord: false,
+  },
+
+  // Tests XMPP is not supported if the result is one record with target ".".
+  {
+    input: [new SRVRecord(5, 30, ".", 5222)],
+    output: XMPPSession.prototype.SRV_ERROR_XMPP_NOT_SUPPORTED,
+    isConnectNextRecord: false,
+  },
+  {
+    input: [new SRVRecord(5, 30, "xmpp.instantbird.com", 5222)],
+    output: [new SRVRecord(5, 30, "xmpp.instantbird.com", 5222)],
+    isConnectNextRecord: true,
+  },
+];
+
+function run_test() {
+  for (let currentQuery of TEST_DATA) {
+    let session = new FakeXMPPSession();
+    try {
+      session._handleSrvQuery(currentQuery.input);
+      equal(session._srvRecords.length, currentQuery.output.length);
+      for (let index = 0; index < session._srvRecords.length; index++) {
+        deepEqual(session._srvRecords[index], currentQuery.output[index]);
+      }
+    } catch (e) {
+      equal(e, currentQuery.output);
+    }
+    equal(session.isConnectNextRecord, currentQuery.isConnectNextRecord);
+  }
+
+  run_next_test();
+}
diff --git a/comm/chat/protocols/xmpp/test/test_parseJidAndNormalization.js b/comm/chat/protocols/xmpp/test/test_parseJidAndNormalization.js
new file mode 100644
index 0000000000..f041d2356b
--- /dev/null
+++ b/comm/chat/protocols/xmpp/test/test_parseJidAndNormalization.js
@@ -0,0 +1,104 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { XMPPAccountPrototype } = ChromeUtils.importESModule(
+  "resource:///modules/xmpp-base.sys.mjs"
+);
+
+var TEST_DATA = {
+  "abdelrhman@instantbird": {
+    node: "abdelrhman",
+    domain: "instantbird",
+    jid: "abdelrhman@instantbird",
+    normalized: "abdelrhman@instantbird",
+  },
+  " room@instantbird/abdelrhman ": {
+    node: "room",
+    domain: "instantbird",
+    resource: "abdelrhman",
+    jid: "room@instantbird/abdelrhman",
+    normalized: "room@instantbird",
+  },
+  "room@instantbird/@bdelrhman": {
+    node: "room",
+    domain: "instantbird",
+    resource: "@bdelrhman",
+    jid: "room@instantbird/@bdelrhman",
+    normalized: "room@instantbird",
+  },
+  "room@instantbird/abdelrhm\u0061\u0308n": {
+    node: "room",
+    domain: "instantbird",
+    resource: "abdelrhm\u0061\u0308n",
+    jid: "room@instantbird/abdelrhm\u0061\u0308n",
+    normalized: "room@instantbird",
+  },
+  "Room@Instantbird/Abdelrhman": {
+    node: "room",
+    domain: "instantbird",
+    resource: "Abdelrhman",
+    jid: "room@instantbird/Abdelrhman",
+    normalized: "room@instantbird",
+  },
+  "Abdelrhman@instantbird/Instant bird": {
+    node: "abdelrhman",
+    domain: "instantbird",
+    resource: "Instant bird",
+    jid: "abdelrhman@instantbird/Instant bird",
+    normalized: "abdelrhman@instantbird",
+  },
+  "abdelrhman@host/instant/Bird": {
+    node: "abdelrhman",
+    domain: "host",
+    resource: "instant/Bird",
+    jid: "abdelrhman@host/instant/Bird",
+    normalized: "abdelrhman@host",
+  },
+  instantbird: {
+    domain: "instantbird",
+    jid: "instantbird",
+    normalized: "instantbird",
+  },
+};
+
+function testParseJID() {
+  for (let currentJID in TEST_DATA) {
+    let jid = XMPPAccountPrototype._parseJID(currentJID);
+    equal(jid.node, TEST_DATA[currentJID].node);
+    equal(jid.domain, TEST_DATA[currentJID].domain);
+    equal(jid.resource, TEST_DATA[currentJID].resource);
+    equal(jid.jid, TEST_DATA[currentJID].jid);
+  }
+
+  run_next_test();
+}
+
+function testNormalize() {
+  for (let currentJID in TEST_DATA) {
+    equal(
+      XMPPAccountPrototype.normalize(currentJID),
+      TEST_DATA[currentJID].normalized
+    );
+  }
+
+  run_next_test();
+}
+
+function testNormalizeFullJid() {
+  for (let currentJID in TEST_DATA) {
+    equal(
+      XMPPAccountPrototype.normalizeFullJid(currentJID),
+      TEST_DATA[currentJID].jid
+    );
+  }
+
+  run_next_test();
+}
+
+function run_test() {
+  add_test(testParseJID);
+  add_test(testNormalize);
+  add_test(testNormalizeFullJid);
+
+  run_next_test();
+}
diff --git a/comm/chat/protocols/xmpp/test/test_parseVCard.js b/comm/chat/protocols/xmpp/test/test_parseVCard.js
new file mode 100644
index 0000000000..08155218de
--- /dev/null
+++ b/comm/chat/protocols/xmpp/test/test_parseVCard.js
@@ -0,0 +1,139 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { XMPPAccountPrototype } = ChromeUtils.importESModule(
+  "resource:///modules/xmpp-base.sys.mjs"
+);
+var { XMPPParser } = ChromeUtils.importESModule(
+  "resource:///modules/xmpp-xml.sys.mjs"
+);
+
+/*
+ * Open an input stream, instantiate an XMPP parser, and feed the input string
+ * into it. Then assert that the resulting vCard matches the expected result.
+ */
+function _test_vcard(aInput, aExpectedResult) {
+  let listener = {
+    onXMLError(aError, aException) {
+      // Ensure that no errors happen.
+      ok(false, aError + " - " + aException);
+    },
+    LOG(aString) {},
+    onXmppStanza(aStanza) {
+      // This is a simplified stanza parser that assumes inputs are vCards.
+      let vCard = aStanza.getElement(["vCard"]);
+      deepEqual(XMPPAccountPrototype.parseVCard(vCard), aExpectedResult);
+    },
+  };
+  let parser = new XMPPParser(listener);
+  parser.onDataAvailable(aInput);
+  parser.destroy();
+}
+
+/*
+ * Test parsing of the example vCard from XEP-0054 section 3.1, example 2.
+ */
+function test_standard_vcard() {
+  const standard_vcard =
+    "<iq xmlns='jabber:client'\
+    id='v1'\
+    to='stpeter@jabber.org/roundabout'\
+    type='result'>\
+  <vCard xmlns='vcard-temp'>\
+    <FN>Peter Saint-Andre</FN>\
+    <N>\
+      <FAMILY>Saint-Andre</FAMILY>\
+      <GIVEN>Peter</GIVEN>\
+      <MIDDLE/>\
+    </N>\
+    <NICKNAME>stpeter</NICKNAME>\
+    <URL>http://www.xmpp.org/xsf/people/stpeter.shtml</URL>\
+    <BDAY>1966-08-06</BDAY>\
+    <ORG>\
+      <ORGNAME>XMPP Standards Foundation</ORGNAME>\
+      <ORGUNIT/>\
+    </ORG>\
+    <TITLE>Executive Director</TITLE>\
+    <ROLE>Patron Saint</ROLE>\
+    <TEL><WORK/><VOICE/><NUMBER>303-308-3282</NUMBER></TEL>\
+    <TEL><WORK/><FAX/><NUMBER/></TEL>\
+    <TEL><WORK/><MSG/><NUMBER/></TEL>\
+    <ADR>\
+      <WORK/>\
+      <EXTADD>Suite 600</EXTADD>\
+      <STREET>1899 Wynkoop Street</STREET>\
+      <LOCALITY>Denver</LOCALITY>\
+      <REGION>CO</REGION>\
+      <PCODE>80202</PCODE>\
+      <CTRY>USA</CTRY>\
+    </ADR>\
+    <TEL><HOME/><VOICE/><NUMBER>303-555-1212</NUMBER></TEL>\
+    <TEL><HOME/><FAX/><NUMBER/></TEL>\
+    <TEL><HOME/><MSG/><NUMBER/></TEL>\
+    <ADR>\
+      <HOME/>\
+      <EXTADD/>\
+      <STREET/>\
+      <LOCALITY>Denver</LOCALITY>\
+      <REGION>CO</REGION>\
+      <PCODE>80209</PCODE>\
+      <CTRY>USA</CTRY>\
+    </ADR>\
+    <EMAIL><INTERNET/><PREF/><USERID>stpeter@jabber.org</USERID></EMAIL>\
+    <JABBERID>stpeter@jabber.org</JABBERID>\
+    <DESC>\
+      More information about me is located on my\
+      personal website: http://www.saint-andre.com/\
+    </DESC>\
+  </vCard>\
+</iq>";
+
+  const expectedResult = {
+    fullName: "Peter Saint-Andre",
+    // Name is not parsed.
+    nickname: "stpeter",
+    // URL is not parsed.
+    birthday: "1966-08-06",
+    organization: "XMPP Standards Foundation",
+    title: "Executive Director",
+    // Role is not parsed.
+    // This only pulls the *last* telephone number.
+    telephone: "303-555-1212",
+    // Part of the address is parsed.
+    locality: "Denver",
+    country: "USA",
+    email: "stpeter@jabber.org",
+    userName: "stpeter@jabber.org", // Jabber ID.
+    // Description is not parsed.
+  };
+
+  _test_vcard(standard_vcard, expectedResult);
+
+  run_next_test();
+}
+
+/*
+ * Test parsing of the example empty vCard from XEP-0054 section 3.1, example
+ * 4. This can be used instead of returning an error stanza.
+ */
+function test_empty_vcard() {
+  const empty_vcard =
+    "<iq xmlns='jabber:client'\
+    id='v1'\
+    to='stpeter@jabber.org/roundabout'\
+    type='result'>\
+  <vCard xmlns='vcard-temp'/>\
+</iq>";
+
+  // There should be no properties.
+  _test_vcard(empty_vcard, {});
+
+  run_next_test();
+}
+
+function run_test() {
+  add_test(test_standard_vcard);
+  add_test(test_empty_vcard);
+
+  run_next_test();
+}
diff --git a/comm/chat/protocols/xmpp/test/test_saslPrep.js b/comm/chat/protocols/xmpp/test/test_saslPrep.js
new file mode 100644
index 0000000000..b2d0a1f147
--- /dev/null
+++ b/comm/chat/protocols/xmpp/test/test_saslPrep.js
@@ -0,0 +1,66 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { saslPrep } = ChromeUtils.importESModule(
+  "resource:///modules/xmpp-authmechs.sys.mjs"
+);
+
+// RFC 4013 3.Examples
+var TEST_DATA = [
+  {
+    // SOFT HYPHEN mapped to nothing.
+    input: "I\u00adX",
+    output: "IX",
+    isError: false,
+  },
+  {
+    // No transformation.
+    input: "user",
+    output: "user",
+    isError: false,
+  },
+  {
+    // Case preserved, will not match #2.
+    input: "USER",
+    output: "USER",
+    isError: false,
+  },
+  {
+    // Output is NFKC, input in ISO 8859-1.
+    input: "\u00aa",
+    output: "a",
+    isError: false,
+  },
+  {
+    // Output is NFKC, will match #1.
+    input: "\u2168",
+    output: "IX",
+    isError: false,
+  },
+  {
+    // Error - prohibited character.
+    input: "\u0007",
+    output: "",
+    isError: true,
+  },
+  {
+    // Error - bidirectional check.
+    input: "\u0627\u0031",
+    output: "",
+    isError: true,
+  },
+];
+
+function run_test() {
+  for (let current of TEST_DATA) {
+    try {
+      let result = saslPrep(current.input);
+      equal(current.isError, false);
+      equal(result, current.output);
+    } catch (e) {
+      equal(current.isError, true);
+    }
+  }
+
+  run_next_test();
+}
diff --git a/comm/chat/protocols/xmpp/test/test_xmppParser.js b/comm/chat/protocols/xmpp/test/test_xmppParser.js
new file mode 100644
index 0000000000..c18304a544
--- /dev/null
+++ b/comm/chat/protocols/xmpp/test/test_xmppParser.js
@@ -0,0 +1,135 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { XMPPParser } = ChromeUtils.importESModule(
+  "resource:///modules/xmpp-xml.sys.mjs"
+);
+
+let expectedResult =
+  '<presence xmlns="jabber:client" from="chat@example.com/Étienne" to="user@example.com/Thunderbird" \
+xml:lang="en" id="5ed0ae8b7051fa6169037da4e2a1ded6"><c xmlns="http://jabber.org/protocol/caps" \
+ver="ZyB1liM9c9GvKOnvl61+5ScWcqw=" node="https://example.com" hash="sha-1"/><x \
+xmlns="vcard-temp:x:update"><photo xmlns="vcard-temp:x:update"/></x><idle xmlns="urn:xmpp:idle:1" \
+since="2021-04-13T11:52:16.538713+00:00"/><occupant-id xmlns="urn:xmpp:occupant-id:0" \
+id="wNZPCZIVQ51D/heZQpOHi0ZgHXAEQonNPaLdyzLxHWs="/><x xmlns="http://jabber.org/protocol/muc#user"><item \
+xmlns="http://jabber.org/protocol/muc#user" jid="example@example.com/client" affiliation="member" \
+role="participant"/></x></presence>';
+let byteVersion = new TextEncoder().encode(expectedResult);
+let utf8Input = Array.from(byteVersion, byte => String.fromCharCode(byte)).join(
+  ""
+);
+
+var TEST_DATA = [
+  {
+    input:
+      '<message xmlns="jabber:client" from="juliet@capulet.example/balcony" \
+to="romeo@montague.example/garden" type="chat">\
+<body>What man art thou that, thus bescreen"d in night, so stumblest on my \
+counsel?</body>\
+</message>',
+    output:
+      '<message xmlns="jabber:client" \
+from="juliet@capulet.example/balcony" to="romeo@montague.example/garden" \
+type="chat"><body xmlns="jabber:client">What man art thou that, thus \
+bescreen"d in night, so stumblest on my counsel?</body>\
+</message>',
+    isError: false,
+    description: "Message stanza with body element",
+  },
+  {
+    input:
+      '<message xmlns="jabber:client" from="romeo@montague.example" \
+to="romeo@montague.example/home" type="chat">\
+<received xmlns="urn:xmpp:carbons:2">\
+<forwarded xmlns="urn:xmpp:forward:0">\
+<message xmlns="jabber:client" from="juliet@capulet.example/balcony" \
+to="romeo@montague.example/garden" type="chat">\
+<body>What man art thou that, thus bescreen"d in night, so stumblest on my \
+counsel?</body>\
+<thread>0e3141cd80894871a68e6fe6b1ec56fa</thread>\
+</message>\
+</forwarded>\
+</received>\
+</message>',
+    output:
+      '<message xmlns="jabber:client" from="romeo@montague.example" \
+to="romeo@montague.example/home" type="chat">\
+<received xmlns="urn:xmpp:carbons:2"><forwarded xmlns="urn:xmpp:forward:0">\
+<message xmlns="jabber:client" from="juliet@capulet.example/balcony" \
+to="romeo@montague.example/garden" type="chat">\
+<body xmlns="jabber:client">What man art thou that, thus bescreen"d in night, \
+so stumblest on my counsel?</body>\
+<thread xmlns="jabber:client">0e3141cd80894871a68e6fe6b1ec56fa</thread>\
+</message>\
+</forwarded>\
+</received>\
+</message>',
+    isError: false,
+    description: "Forwarded copy of message carbons",
+  },
+  {
+    input:
+      '<message xmlns="jabber:client" from="juliet@capulet.example/balcony" \
+to="romeo@montague.example/garden" type="chat">\
+<body>What man art thou that, thus bescreen"d in night, so stumblest on my \
+counsel?\
+</message>',
+    output: "",
+    isError: true,
+    description: "No closing of body tag",
+  },
+  {
+    input:
+      '<message xmlns="http://etherx.jabber.org/streams" from="juliet@capulet.example/balcony" \
+to="romeo@montague.example/garden" type="chat">\
+<body>What man art thou that, thus bescreen"d in night, so stumblest on my \
+counsel?</body>\
+</message>',
+    output: "",
+    isError: true,
+    description: "Invalid namespace of top-level element",
+  },
+  {
+    input:
+      '<field xmlns="jabber:x:data" type="fixed">\
+<value>What man art thou that, thus bescreen"d in night, so stumblest on my \
+counsel?</value>\
+</field>',
+    output: "",
+    isError: true,
+    description: "Invalid top-level element",
+  },
+  {
+    input: utf8Input,
+    output: expectedResult,
+    isError: false,
+    description: "UTF-8 encoded content from socket",
+  },
+];
+
+function testXMPPParser() {
+  for (let current of TEST_DATA) {
+    let listener = {
+      onXMLError(aString) {
+        ok(current.isError, aString + " - " + current.description);
+      },
+      LOG(aString) {},
+      startLegacyAuth() {},
+      onXmppStanza(aStanza) {
+        equal(current.output, aStanza.getXML(), current.description);
+        ok(!current.isError, current.description);
+      },
+    };
+    let parser = new XMPPParser(listener);
+    parser.onDataAvailable(current.input);
+    parser.destroy();
+  }
+
+  run_next_test();
+}
+
+function run_test() {
+  add_test(testXMPPParser);
+
+  run_next_test();
+}
diff --git a/comm/chat/protocols/xmpp/test/test_xmppXml.js b/comm/chat/protocols/xmpp/test/test_xmppXml.js
new file mode 100644
index 0000000000..1b6ea9a175
--- /dev/null
+++ b/comm/chat/protocols/xmpp/test/test_xmppXml.js
@@ -0,0 +1,103 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { Stanza } = ChromeUtils.importESModule(
+  "resource:///modules/xmpp-xml.sys.mjs"
+);
+
+var TEST_DATA = [
+  {
+    input: {
+      name: "message",
+      namespace: Stanza.NS.client,
+      attributes: {
+        jid: "user@domain",
+        type: null,
+      },
+      data: [],
+    },
+    XmlOutput: '<message xmlns="jabber:client" jid="user@domain"/>',
+    stringOutput: '<message xmlns="jabber:client" jid="user@domain"/>\n',
+    isError: false,
+    description: "Ignore attribute with null value",
+  },
+  {
+    input: {
+      name: "message",
+      namespace: Stanza.NS.client,
+      attributes: {
+        jid: "user@domain",
+        type: undefined,
+      },
+      data: [],
+    },
+    XmlOutput: '<message xmlns="jabber:client" jid="user@domain"/>',
+    stringOutput: '<message xmlns="jabber:client" jid="user@domain"/>\n',
+    isError: false,
+    description: "Ignore attribute with undefined value",
+  },
+  {
+    input: {
+      name: "message",
+      namespace: undefined,
+      attributes: {},
+      data: [],
+    },
+    XmlOutput: "<message/>",
+    stringOutput: "<message/>\n",
+    isError: false,
+    description: "Ignore namespace with undefined value",
+  },
+  {
+    input: {
+      name: undefined,
+      attributes: {},
+      data: [],
+    },
+    XmlOutput: "",
+    stringOutput: "",
+    isError: true,
+    description: "Node must have a name",
+  },
+  {
+    input: {
+      name: "message",
+      attributes: {},
+      data: "test message",
+    },
+    XmlOutput: "<message>test message</message>",
+    stringOutput: "<message>\n test message\n</message>\n",
+    isError: false,
+    description: "Node with text content",
+  },
+];
+
+function testXMLNode() {
+  for (let current of TEST_DATA) {
+    try {
+      let result = Stanza.node(
+        current.input.name,
+        current.input.namespace,
+        current.input.attributes,
+        current.input.data
+      );
+      equal(result.getXML(), current.XmlOutput, current.description);
+      equal(
+        result.convertToString(),
+        current.stringOutput,
+        current.description
+      );
+      equal(current.isError, false);
+    } catch (e) {
+      equal(current.isError, true, current.description);
+    }
+  }
+
+  run_next_test();
+}
+
+function run_test() {
+  add_test(testXMLNode);
+
+  run_next_test();
+}
diff --git a/comm/chat/protocols/xmpp/test/xpcshell.ini b/comm/chat/protocols/xmpp/test/xpcshell.ini
new file mode 100644
index 0000000000..a4cb9534b8
--- /dev/null
+++ b/comm/chat/protocols/xmpp/test/xpcshell.ini
@@ -0,0 +1,11 @@
+[DEFAULT]
+head =
+tail =
+
+[test_authmechs.js]
+[test_dnsSrv.js]
+[test_parseJidAndNormalization.js]
+[test_saslPrep.js]
+[test_parseVCard.js]
+[test_xmppParser.js]
+[test_xmppXml.js]
diff --git a/comm/chat/protocols/xmpp/xmpp-authmechs.sys.mjs b/comm/chat/protocols/xmpp/xmpp-authmechs.sys.mjs
new file mode 100644
index 0000000000..7517d6f6aa
--- /dev/null
+++ b/comm/chat/protocols/xmpp/xmpp-authmechs.sys.mjs
@@ -0,0 +1,561 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// This module exports XMPPAuthMechanisms, an object containing the supported
+// SASL authentication mechanisms. Each authentication mechanism is a generator
+// function which takes the following parameters:
+//
+// * The provided username (JID node),
+// * The password
+// * The user's domain (again from the JID).
+//
+// The generator should yield objects (or Promises which resolve to objects)
+// with two properties:
+//
+// * send: The next XML stanza to send.
+// * log: The plaintext content to log (instead of the stanza, which likely
+//   contains sensitive information).
+//
+// Alternately the object can have an error property which causes the account
+// to disconnect with an ERROR_AUTHENTICATION_FAILED error.
+//
+// The response stanza from the server is sent to the generator each time it
+// yields. Once the authentication negotiation is complete the generator should
+// return.
+//
+// By default the PLAIN, SCRAM-SHA-1, and SCRAM-SHA-256 mechanisms are supported.
+//
+// As this is only used by XMPPSession, it may seem like an internal detail of
+// the XMPP implementation, but exporting it is valuable for testing purposes.
+
+import { CommonUtils } from "resource://services-common/utils.sys.mjs";
+import { CryptoUtils } from "resource://services-crypto/utils.sys.mjs";
+import { Stanza } from "resource:///modules/xmpp-xml.sys.mjs";
+
+// Handle PLAIN authorization mechanism.
+function* PlainAuth(aUsername, aPassword, aDomain) {
+  let data = "\0" + aUsername + "\0" + aPassword;
+
+  // btoa for Unicode, see https://developer.mozilla.org/en-US/docs/DOM/window.btoa
+  let base64Data = btoa(unescape(encodeURIComponent(data)));
+
+  let stanza = yield {
+    send: Stanza.node(
+      "auth",
+      Stanza.NS.sasl,
+      { mechanism: "PLAIN" },
+      base64Data
+    ),
+    log: '<auth mechanism:="PLAIN"/> (base64 encoded username and password not logged)',
+  };
+
+  if (stanza.localName != "success") {
+    throw new Error("Didn't receive the expected auth success stanza.");
+  }
+}
+
+// Handle SCRAM-SHA-1 authorization mechanism.
+const RFC3454 = {
+  A1: "\u0221|[\u0234-\u024f]|[\u02ae-\u02af]|[\u02ef-\u02ff]|\
+[\u0350-\u035f]|[\u0370-\u0373]|[\u0376-\u0379]|[\u037b-\u037d]|\
+[\u037f-\u0383]|\u038b|\u038d|\u03a2|\u03cf|[\u03f7-\u03ff]|\u0487|\
+\u04cf|[\u04f6-\u04f7]|[\u04fa-\u04ff]|[\u0510-\u0530]|\
+[\u0557-\u0558]|\u0560|\u0588|[\u058b-\u0590]|\u05a2|\u05ba|\
+[\u05c5-\u05cf]|[\u05eb-\u05ef]|[\u05f5-\u060b]|[\u060d-\u061a]|\
+[\u061c-\u061e]|\u0620|[\u063b-\u063f]|[\u0656-\u065f]|\
+[\u06ee-\u06ef]|\u06ff|\u070e|[\u072d-\u072f]|[\u074b-\u077f]|\
+[\u07b2-\u0900]|\u0904|[\u093a-\u093b]|[\u094e-\u094f]|\
+[\u0955-\u0957]|[\u0971-\u0980]|\u0984|[\u098d-\u098e]|\
+[\u0991-\u0992]|\u09a9|\u09b1|[\u09b3-\u09b5]|[\u09ba-\u09bb]|\u09bd|\
+[\u09c5-\u09c6]|[\u09c9-\u09ca]|[\u09ce-\u09d6]|[\u09d8-\u09db]|\
+\u09de|[\u09e4-\u09e5]|[\u09fb-\u0a01]|[\u0a03-\u0a04]|\
+[\u0a0b-\u0a0e]|[\u0a11-\u0a12]|\u0a29|\u0a31|\u0a34|\u0a37|\
+[\u0a3a-\u0a3b]|\u0a3d|[\u0a43-\u0a46]|[\u0a49-\u0a4a]|\
+[\u0a4e-\u0a58]|\u0a5d|[\u0a5f-\u0a65]|[\u0a75-\u0a80]|\u0a84|\u0a8c|\
+\u0a8e|\u0a92|\u0aa9|\u0ab1|\u0ab4|[\u0aba-\u0abb]|\u0ac6|\u0aca|\
+[\u0ace-\u0acf]|[\u0ad1-\u0adf]|[\u0ae1-\u0ae5]|[\u0af0-\u0b00]|\
+\u0b04|[\u0b0d-\u0b0e]|[\u0b11-\u0b12]|\u0b29|\u0b31|[\u0b34-\u0b35]|\
+[\u0b3a-\u0b3b]|[\u0b44-\u0b46]|[\u0b49-\u0b4a]|[\u0b4e-\u0b55]|\
+[\u0b58-\u0b5b]|\u0b5e|[\u0b62-\u0b65]|[\u0b71-\u0b81]|\u0b84|\
+[\u0b8b-\u0b8d]|\u0b91|[\u0b96-\u0b98]|\u0b9b|\u0b9d|[\u0ba0-\u0ba2]|\
+[\u0ba5-\u0ba7]|[\u0bab-\u0bad]|\u0bb6|[\u0bba-\u0bbd]|\
+[\u0bc3-\u0bc5]|\u0bc9|[\u0bce-\u0bd6]|[\u0bd8-\u0be6]|\
+[\u0bf3-\u0c00]|\u0c04|\u0c0d|\u0c11|\u0c29|\u0c34|[\u0c3a-\u0c3d]|\
+\u0c45|\u0c49|[\u0c4e-\u0c54]|[\u0c57-\u0c5f]|[\u0c62-\u0c65]|\
+[\u0c70-\u0c81]|\u0c84|\u0c8d|\u0c91|\u0ca9|\u0cb4|[\u0cba-\u0cbd]|\
+\u0cc5|\u0cc9|[\u0cce-\u0cd4]|[\u0cd7-\u0cdd]|\u0cdf|[\u0ce2-\u0ce5]|\
+[\u0cf0-\u0d01]|\u0d04|\u0d0d|\u0d11|\u0d29|[\u0d3a-\u0d3d]|\
+[\u0d44-\u0d45]|\u0d49|[\u0d4e-\u0d56]|[\u0d58-\u0d5f]|\
+[\u0d62-\u0d65]|[\u0d70-\u0d81]|\u0d84|[\u0d97-\u0d99]|\u0db2|\u0dbc|\
+[\u0dbe-\u0dbf]|[\u0dc7-\u0dc9]|[\u0dcb-\u0dce]|\u0dd5|\u0dd7|\
+[\u0de0-\u0df1]|[\u0df5-\u0e00]|[\u0e3b-\u0e3e]|[\u0e5c-\u0e80]|\
+\u0e83|[\u0e85-\u0e86]|\u0e89|[\u0e8b-\u0e8c]|[\u0e8e-\u0e93]|\u0e98|\
+\u0ea0|\u0ea4|\u0ea6|[\u0ea8-\u0ea9]|\u0eac|\u0eba|[\u0ebe-\u0ebf]|\
+\u0ec5|\u0ec7|[\u0ece-\u0ecf]|[\u0eda-\u0edb]|[\u0ede-\u0eff]|\u0f48|\
+[\u0f6b-\u0f70]|[\u0f8c-\u0f8f]|\u0f98|\u0fbd|[\u0fcd-\u0fce]|\
+[\u0fd0-\u0fff]|\u1022|\u1028|\u102b|[\u1033-\u1035]|[\u103a-\u103f]|\
+[\u105a-\u109f]|[\u10c6-\u10cf]|[\u10f9-\u10fa]|[\u10fc-\u10ff]|\
+[\u115a-\u115e]|[\u11a3-\u11a7]|[\u11fa-\u11ff]|\u1207|\u1247|\u1249|\
+[\u124e-\u124f]|\u1257|\u1259|[\u125e-\u125f]|\u1287|\u1289|\
+[\u128e-\u128f]|\u12af|\u12b1|[\u12b6-\u12b7]|\u12bf|\u12c1|\
+[\u12c6-\u12c7]|\u12cf|\u12d7|\u12ef|\u130f|\u1311|[\u1316-\u1317]|\
+\u131f|\u1347|[\u135b-\u1360]|[\u137d-\u139f]|[\u13f5-\u1400]|\
+[\u1677-\u167f]|[\u169d-\u169f]|[\u16f1-\u16ff]|\u170d|\
+[\u1715-\u171f]|[\u1737-\u173f]|[\u1754-\u175f]|\u176d|\u1771|\
+[\u1774-\u177f]|[\u17dd-\u17df]|[\u17ea-\u17ff]|\u180f|\
+[\u181a-\u181f]|[\u1878-\u187f]|[\u18aa-\u1dff]|[\u1e9c-\u1e9f]|\
+[\u1efa-\u1eff]|[\u1f16-\u1f17]|[\u1f1e-\u1f1f]|[\u1f46-\u1f47]|\
+[\u1f4e-\u1f4f]|\u1f58|\u1f5a|\u1f5c|\u1f5e|[\u1f7e-\u1f7f]|\u1fb5|\
+\u1fc5|[\u1fd4-\u1fd5]|\u1fdc|[\u1ff0-\u1ff1]|\u1ff5|\u1fff|\
+[\u2053-\u2056]|[\u2058-\u205e]|[\u2064-\u2069]|[\u2072-\u2073]|\
+[\u208f-\u209f]|[\u20b2-\u20cf]|[\u20eb-\u20ff]|[\u213b-\u213c]|\
+[\u214c-\u2152]|[\u2184-\u218f]|[\u23cf-\u23ff]|[\u2427-\u243f]|\
+[\u244b-\u245f]|\u24ff|[\u2614-\u2615]|\u2618|[\u267e-\u267f]|\
+[\u268a-\u2700]|\u2705|[\u270a-\u270b]|\u2728|\u274c|\u274e|\
+[\u2753-\u2755]|\u2757|[\u275f-\u2760]|[\u2795-\u2797]|\u27b0|\
+[\u27bf-\u27cf]|[\u27ec-\u27ef]|[\u2b00-\u2e7f]|\u2e9a|\
+[\u2ef4-\u2eff]|[\u2fd6-\u2fef]|[\u2ffc-\u2fff]|\u3040|\
+[\u3097-\u3098]|[\u3100-\u3104]|[\u312d-\u3130]|\u318f|\
+[\u31b8-\u31ef]|[\u321d-\u321f]|[\u3244-\u3250]|[\u327c-\u327e]|\
+[\u32cc-\u32cf]|\u32ff|[\u3377-\u337a]|[\u33de-\u33df]|\u33ff|\
+[\u4db6-\u4dff]|[\u9fa6-\u9fff]|[\ua48d-\ua48f]|[\ua4c7-\uabff]|\
+[\ud7a4-\ud7ff]|[\ufa2e-\ufa2f]|[\ufa6b-\ufaff]|[\ufb07-\ufb12]|\
+[\ufb18-\ufb1c]|\ufb37|\ufb3d|\ufb3f|\ufb42|\ufb45|[\ufbb2-\ufbd2]|\
+[\ufd40-\ufd4f]|[\ufd90-\ufd91]|[\ufdc8-\ufdcf]|[\ufdfd-\ufdff]|\
+[\ufe10-\ufe1f]|[\ufe24-\ufe2f]|[\ufe47-\ufe48]|\ufe53|\ufe67|\
+[\ufe6c-\ufe6f]|\ufe75|[\ufefd-\ufefe]|\uff00|[\uffbf-\uffc1]|\
+[\uffc8-\uffc9]|[\uffd0-\uffd1]|[\uffd8-\uffd9]|[\uffdd-\uffdf]|\
+\uffe7|[\uffef-\ufff8]|[\u{10000}-\u{102ff}]|\u{1031f}|\
+[\u{10324}-\u{1032f}]|[\u{1034b}-\u{103ff}]|[\u{10426}-\u{10427}]|\
+[\u{1044e}-\u{1cfff}]|[\u{1d0f6}-\u{1d0ff}]|[\u{1d127}-\u{1d129}]|\
+[\u{1d1de}-\u{1d3ff}]|\u{1d455}|\u{1d49d}|[\u{1d4a0}-\u{1d4a1}]|\
+[\u{1d4a3}-\u{1d4a4}]|[\u{1d4a7}-\u{1d4a8}]|\u{1d4ad}|\u{1d4ba}|\
+\u{1d4bc}|\u{1d4c1}|\u{1d4c4}|\u{1d506}|[\u{1d50b}-\u{1d50c}]|\
+\u{1d515}|\u{1d51d}|\u{1d53a}|\u{1d53f}|\u{1d545}|\
+[\u{1d547}-\u{1d549}]|\u{1d551}|[\u{1d6a4}-\u{1d6a7}]|\
+[\u{1d7ca}-\u{1d7cd}]|[\u{1d800}-\u{1fffd}]|[\u{2a6d7}-\u{2f7ff}]|\
+[\u{2fa1e}-\u{2fffd}]|[\u{30000}-\u{3fffd}]|[\u{40000}-\u{4fffd}]|\
+[\u{50000}-\u{5fffd}]|[\u{60000}-\u{6fffd}]|[\u{70000}-\u{7fffd}]|\
+[\u{80000}-\u{8fffd}]|[\u{90000}-\u{9fffd}]|[\u{a0000}-\u{afffd}]|\
+[\u{b0000}-\u{bfffd}]|[\u{c0000}-\u{cfffd}]|[\u{d0000}-\u{dfffd}]|\
+\u{e0000}|[\u{e0002}-\u{e001f}]|[\u{e0080}-\u{efffd}]",
+  B1: "\u00ad|\u034f|\u1806|[\u180b-\u180d]|[\u200b-\u200d]|\u2060|\
+[\ufe00-\ufe0f]|\ufeff",
+  C12: "\u00a0|\u1680|[\u2000-\u200b]|\u202f|\u205f|\u3000",
+  C21: "[\u0000-\u001f]|\u007f",
+  C22: "[\u0080-\u009f]|\u06dd|\u070f|\u180e|\u200c|\u200d|\u2028|\u2029|\
+[\u2060-\u2063]|[\u206a-\u206f]|\ufeff|[\ufff9-\ufffc]",
+  C3: "[\ue000-\uf8ff]|[\u{f0000}-\u{ffffd}]|[\u{100000}-\u{10fffd}]",
+  C4: "[\ufdd0-\ufdef]|[\ufffe-\uffff]|[\u{1fffe}-\u{1ffff}]|\
+[\u{2fffe}-\u{2ffff}]|[\u{3fffe}-\u{3ffff}]|[\u{4fffe}-\u{4ffff}]|\
+[\u{5fffe}-\u{5ffff}]|[\u{6fffe}-\u{6ffff}]|[\u{7fffe}-\u{7ffff}]|\
+[\u{8fffe}-\u{8ffff}]|[\u{9fffe}-\u{9ffff}]|[\u{afffe}-\u{affff}]|\
+[\u{bfffe}-\u{bffff}]|[\u{cfffe}-\u{cffff}]|[\u{dfffe}-\u{dffff}]|\
+[\u{efffe}-\u{effff}]|[\u{ffffe}-\u{fffff}]|[\u{10fffe}-\u{10ffff}]",
+  C5: "[\ud800-\udfff]",
+  C6: "\ufff9|[\ufffa-\ufffd]",
+  C7: "[\u2ff0-\u2ffb]",
+  C8: "\u0340|\u0341|\u200e|\u200f|[\u202a-\u202e]|[\u206a-\u206f]",
+  C9: "\u{e0001}|[\u{e0020}-\u{e007f}]",
+  D1: "\u05be|\u05c0|\u05c3|[\u05d0-\u05ea]|[\u05f0-\u05f4]|\u061b|\u061f|\
+[\u0621-\u063a]|[\u0640-\u064a]|[\u066d-\u066f]|[\u0671-\u06d5]|\
+\u06dd|[\u06e5-\u06e6]|[\u06fa-\u06fe]|[\u0700-\u070d]|\u0710|\
+[\u0712-\u072c]|[\u0780-\u07a5]|\u07b1|\u200f|\ufb1d|[\ufb1f-\ufb28]|\
+[\ufb2a-\ufb36]|[\ufb38-\ufb3c]|\ufb3e|[\ufb40-\ufb41]|\
+[\ufb43-\ufb44]|[\ufb46-\ufbb1]|[\ufbd3-\ufd3d]|[\ufd50-\ufd8f]|\
+[\ufd92-\ufdc7]|[\ufdf0-\ufdfc]|[\ufe70-\ufe74]|[\ufe76-\ufefc]",
+  D2: "[\u0041-\u005a]|[\u0061-\u007a]|\u00aa|\u00b5|\u00ba|[\u00c0-\u00d6]|\
+[\u00d8-\u00f6]|[\u00f8-\u0220]|[\u0222-\u0233]|[\u0250-\u02ad]|\
+[\u02b0-\u02b8]|[\u02bb-\u02c1]|[\u02d0-\u02d1]|[\u02e0-\u02e4]|\
+\u02ee|\u037a|\u0386|[\u0388-\u038a]|\u038c|[\u038e-\u03a1]|\
+[\u03a3-\u03ce]|[\u03d0-\u03f5]|[\u0400-\u0482]|[\u048a-\u04ce]|\
+[\u04d0-\u04f5]|[\u04f8-\u04f9]|[\u0500-\u050f]|[\u0531-\u0556]|\
+[\u0559-\u055f]|[\u0561-\u0587]|\u0589|\u0903|[\u0905-\u0939]|\
+[\u093d-\u0940]|[\u0949-\u094c]|\u0950|[\u0958-\u0961]|\
+[\u0964-\u0970]|[\u0982-\u0983]|[\u0985-\u098c]|[\u098f-\u0990]|\
+[\u0993-\u09a8]|[\u09aa-\u09b0]|\u09b2|[\u09b6-\u09b9]|\
+[\u09be-\u09c0]|[\u09c7-\u09c8]|[\u09cb-\u09cc]|\u09d7|\
+[\u09dc-\u09dd]|[\u09df-\u09e1]|[\u09e6-\u09f1]|[\u09f4-\u09fa]|\
+[\u0a05-\u0a0a]|[\u0a0f-\u0a10]|[\u0a13-\u0a28]|[\u0a2a-\u0a30]|\
+[\u0a32-\u0a33]|[\u0a35-\u0a36]|[\u0a38-\u0a39]|[\u0a3e-\u0a40]|\
+[\u0a59-\u0a5c]|\u0a5e|[\u0a66-\u0a6f]|[\u0a72-\u0a74]|\u0a83|\
+[\u0a85-\u0a8b]|\u0a8d|[\u0a8f-\u0a91]|[\u0a93-\u0aa8]|\
+[\u0aaa-\u0ab0]|[\u0ab2-\u0ab3]|[\u0ab5-\u0ab9]|[\u0abd-\u0ac0]|\
+\u0ac9|[\u0acb-\u0acc]|\u0ad0|\u0ae0|[\u0ae6-\u0aef]|[\u0b02-\u0b03]|\
+[\u0b05-\u0b0c]|[\u0b0f-\u0b10]|[\u0b13-\u0b28]|[\u0b2a-\u0b30]|\
+[\u0b32-\u0b33]|[\u0b36-\u0b39]|[\u0b3d-\u0b3e]|\u0b40|\
+[\u0b47-\u0b48]|[\u0b4b-\u0b4c]|\u0b57|[\u0b5c-\u0b5d]|\
+[\u0b5f-\u0b61]|[\u0b66-\u0b70]|\u0b83|[\u0b85-\u0b8a]|\
+[\u0b8e-\u0b90]|[\u0b92-\u0b95]|[\u0b99-\u0b9a]|\u0b9c|\
+[\u0b9e-\u0b9f]|[\u0ba3-\u0ba4]|[\u0ba8-\u0baa]|[\u0bae-\u0bb5]|\
+[\u0bb7-\u0bb9]|[\u0bbe-\u0bbf]|[\u0bc1-\u0bc2]|[\u0bc6-\u0bc8]|\
+[\u0bca-\u0bcc]|\u0bd7|[\u0be7-\u0bf2]|[\u0c01-\u0c03]|\
+[\u0c05-\u0c0c]|[\u0c0e-\u0c10]|[\u0c12-\u0c28]|[\u0c2a-\u0c33]|\
+[\u0c35-\u0c39]|[\u0c41-\u0c44]|[\u0c60-\u0c61]|[\u0c66-\u0c6f]|\
+[\u0c82-\u0c83]|[\u0c85-\u0c8c]|[\u0c8e-\u0c90]|[\u0c92-\u0ca8]|\
+[\u0caa-\u0cb3]|[\u0cb5-\u0cb9]|\u0cbe|[\u0cc0-\u0cc4]|\
+[\u0cc7-\u0cc8]|[\u0cca-\u0ccb]|[\u0cd5-\u0cd6]|\u0cde|\
+[\u0ce0-\u0ce1]|[\u0ce6-\u0cef]|[\u0d02-\u0d03]|[\u0d05-\u0d0c]|\
+[\u0d0e-\u0d10]|[\u0d12-\u0d28]|[\u0d2a-\u0d39]|[\u0d3e-\u0d40]|\
+[\u0d46-\u0d48]|[\u0d4a-\u0d4c]|\u0d57|[\u0d60-\u0d61]|\
+[\u0d66-\u0d6f]|[\u0d82-\u0d83]|[\u0d85-\u0d96]|[\u0d9a-\u0db1]|\
+[\u0db3-\u0dbb]|\u0dbd|[\u0dc0-\u0dc6]|[\u0dcf-\u0dd1]|\
+[\u0dd8-\u0ddf]|[\u0df2-\u0df4]|[\u0e01-\u0e30]|[\u0e32-\u0e33]|\
+[\u0e40-\u0e46]|[\u0e4f-\u0e5b]|[\u0e81-\u0e82]|\u0e84|\
+[\u0e87-\u0e88]|\u0e8a|\u0e8d|[\u0e94-\u0e97]|[\u0e99-\u0e9f]|\
+[\u0ea1-\u0ea3]|\u0ea5|\u0ea7|[\u0eaa-\u0eab]|[\u0ead-\u0eb0]|\
+[\u0eb2-\u0eb3]|\u0ebd|[\u0ec0-\u0ec4]|\u0ec6|[\u0ed0-\u0ed9]|\
+[\u0edc-\u0edd]|[\u0f00-\u0f17]|[\u0f1a-\u0f34]|\u0f36|\u0f38|\
+[\u0f3e-\u0f47]|[\u0f49-\u0f6a]|\u0f7f|\u0f85|[\u0f88-\u0f8b]|\
+[\u0fbe-\u0fc5]|[\u0fc7-\u0fcc]|\u0fcf|[\u1000-\u1021]|\
+[\u1023-\u1027]|[\u1029-\u102a]|\u102c|\u1031|\u1038|[\u1040-\u1057]|\
+[\u10a0-\u10c5]|[\u10d0-\u10f8]|\u10fb|[\u1100-\u1159]|\
+[\u115f-\u11a2]|[\u11a8-\u11f9]|[\u1200-\u1206]|[\u1208-\u1246]|\
+\u1248|[\u124a-\u124d]|[\u1250-\u1256]|\u1258|[\u125a-\u125d]|\
+[\u1260-\u1286]|\u1288|[\u128a-\u128d]|[\u1290-\u12ae]|\u12b0|\
+[\u12b2-\u12b5]|[\u12b8-\u12be]|\u12c0|[\u12c2-\u12c5]|\
+[\u12c8-\u12ce]|[\u12d0-\u12d6]|[\u12d8-\u12ee]|[\u12f0-\u130e]|\
+\u1310|[\u1312-\u1315]|[\u1318-\u131e]|[\u1320-\u1346]|\
+[\u1348-\u135a]|[\u1361-\u137c]|[\u13a0-\u13f4]|[\u1401-\u1676]|\
+[\u1681-\u169a]|[\u16a0-\u16f0]|[\u1700-\u170c]|[\u170e-\u1711]|\
+[\u1720-\u1731]|[\u1735-\u1736]|[\u1740-\u1751]|[\u1760-\u176c]|\
+[\u176e-\u1770]|[\u1780-\u17b6]|[\u17be-\u17c5]|[\u17c7-\u17c8]|\
+[\u17d4-\u17da]|\u17dc|[\u17e0-\u17e9]|[\u1810-\u1819]|\
+[\u1820-\u1877]|[\u1880-\u18a8]|[\u1e00-\u1e9b]|[\u1ea0-\u1ef9]|\
+[\u1f00-\u1f15]|[\u1f18-\u1f1d]|[\u1f20-\u1f45]|[\u1f48-\u1f4d]|\
+[\u1f50-\u1f57]|\u1f59|\u1f5b|\u1f5d|[\u1f5f-\u1f7d]|[\u1f80-\u1fb4]|\
+[\u1fb6-\u1fbc]|\u1fbe|[\u1fc2-\u1fc4]|[\u1fc6-\u1fcc]|\
+[\u1fd0-\u1fd3]|[\u1fd6-\u1fdb]|[\u1fe0-\u1fec]|[\u1ff2-\u1ff4]|\
+[\u1ff6-\u1ffc]|\u200e|\u2071|\u207f|\u2102|\u2107|[\u210a-\u2113]|\
+\u2115|[\u2119-\u211d]|\u2124|\u2126|\u2128|[\u212a-\u212d]|\
+[\u212f-\u2131]|[\u2133-\u2139]|[\u213d-\u213f]|[\u2145-\u2149]|\
+[\u2160-\u2183]|[\u2336-\u237a]|\u2395|[\u249c-\u24e9]|\
+[\u3005-\u3007]|[\u3021-\u3029]|[\u3031-\u3035]|[\u3038-\u303c]|\
+[\u3041-\u3096]|[\u309d-\u309f]|[\u30a1-\u30fa]|[\u30fc-\u30ff]|\
+[\u3105-\u312c]|[\u3131-\u318e]|[\u3190-\u31b7]|[\u31f0-\u321c]|\
+[\u3220-\u3243]|[\u3260-\u327b]|[\u327f-\u32b0]|[\u32c0-\u32cb]|\
+[\u32d0-\u32fe]|[\u3300-\u3376]|[\u337b-\u33dd]|[\u33e0-\u33fe]|\
+[\u3400-\u4db5]|[\u4e00-\u9fa5]|[\ua000-\ua48c]|[\uac00-\ud7a3]|\
+[\ud800-\ufa2d]|[\ufa30-\ufa6a]|[\ufb00-\ufb06]|[\ufb13-\ufb17]|\
+[\uff21-\uff3a]|[\uff41-\uff5a]|[\uff66-\uffbe]|[\uffc2-\uffc7]|\
+[\uffca-\uffcf]|[\uffd2-\uffd7]|[\uffda-\uffdc]|[\u{10300}-\u{1031e}]|\
+[\u{10320}-\u{10323}]|[\u{10330}-\u{1034a}]|[\u{10400}-\u{10425}]|\
+[\u{10428}-\u{1044d}]|[\u{1d000}-\u{1d0f5}]|[\u{1d100}-\u{1d126}]|\
+[\u{1d12a}-\u{1d166}]|[\u{1d16a}-\u{1d172}]|[\u{1d183}-\u{1d184}]|\
+[\u{1d18c}-\u{1d1a9}]|[\u{1d1ae}-\u{1d1dd}]|[\u{1d400}-\u{1d454}]|\
+[\u{1d456}-\u{1d49c}]|[\u{1d49e}-\u{1d49f}]|\u{1d4a2}|\
+[\u{1d4a5}-\u{1d4a6}]|[\u{1d4a9}-\u{1d4ac}]|[\u{1d4ae}-\u{1d4b9}]|\
+\u{1d4bb}|[\u{1d4bd}-\u{1d4c0}]|[\u{1d4c2}-\u{1d4c3}]|\
+[\u{1d4c5}-\u{1d505}]|[\u{1d507}-\u{1d50a}]|[\u{1d50d}-\u{1d514}]|\
+[\u{1d516}-\u{1d51c}]|[\u{1d51e}-\u{1d539}]|[\u{1d53b}-\u{1d53e}]|\
+[\u{1d540}-\u{1d544}]|\u{1d546}|[\u{1d54a}-\u{1d550}]|\
+[\u{1d552}-\u{1d6a3}]|[\u{1d6a8}-\u{1d7c9}]|[\u{20000}-\u{2a6d6}]|\
+[\u{2f800}-\u{2fa1d}]|[\u{f0000}-\u{ffffd}]|[\u{100000}-\u{10fffd}]",
+};
+
+// Generates a random nonce and returns a base64 encoded string.
+// aLength in bytes.
+function createNonce(aLength) {
+  // RFC 5802 (5.1): Printable ASCII except ",".
+  // We guarantee a valid nonce value using base64 encoding.
+  return btoa(CryptoUtils.generateRandomBytes(aLength));
+}
+
+// Parses the string of server's response (aChallenge) into an object.
+function parseChallenge(aChallenge) {
+  let attributes = {};
+  aChallenge.split(",").forEach(value => {
+    let match = /^(\w)=([\s\S]*)$/.exec(value);
+    if (match) {
+      attributes[match[1]] = match[2];
+    }
+  });
+  return attributes;
+}
+
+// RFC 4013 and RFC 3454: Stringprep Profile for User Names and Passwords.
+export function saslPrep(aString) {
+  // RFC 4013 2.1: non-ASCII space characters (RFC 3454 C.1.2) mapped to space.
+  let retVal = aString.replace(new RegExp(RFC3454.C12, "u"), " ");
+
+  // RFC 4013 2.1: RFC 3454 3.1, B.1: Map certain codepoints to nothing.
+  retVal = retVal.replace(new RegExp(RFC3454.B1, "u"), "");
+
+  // RFC 4013 2.2 asks for Unicode normalization form KC, which corresponds to
+  // RFC 3454 B.2.
+  retVal = retVal.normalize("NFKC");
+
+  // RFC 4013 2.3: Prohibited Output and 2.5: Unassigned Code Points.
+  let matchStr =
+    RFC3454.C12 +
+    "|" +
+    RFC3454.C21 +
+    "|" +
+    RFC3454.C22 +
+    "|" +
+    RFC3454.C3 +
+    "|" +
+    RFC3454.C4 +
+    "|" +
+    RFC3454.C5 +
+    "|" +
+    RFC3454.C6 +
+    "|" +
+    RFC3454.C7 +
+    "|" +
+    RFC3454.C8 +
+    "|" +
+    RFC3454.C9 +
+    "|" +
+    RFC3454.A1;
+  let match = new RegExp(matchStr, "u").test(retVal);
+  if (match) {
+    throw new Error("String contains prohibited characters");
+  }
+
+  // RFC 4013 2.4: Bidirectional Characters.
+  let r = new RegExp(RFC3454.D1, "u").test(retVal);
+  let l = new RegExp(RFC3454.D2, "u").test(retVal);
+  if (l && r) {
+    throw new Error(
+      "String must not contain LCat and RandALCat characters together"
+    );
+  } else if (r) {
+    let matchFirst = new RegExp("^(" + RFC3454.D1 + ")", "u").test(retVal);
+    let matchLast = new RegExp("(" + RFC3454.D1 + ")$", "u").test(retVal);
+    if (!matchFirst || !matchLast) {
+      throw new Error(
+        "A RandALCat character must be the first and the last character"
+      );
+    }
+  }
+
+  return retVal;
+}
+
+// Converts aName to saslname.
+function saslName(aName) {
+  // RFC 5802 (5.1): the client SHOULD prepare the username using the "SASLprep".
+  // The characters ’,’ or ’=’ in usernames are sent as ’=2C’ and
+  // ’=3D’ respectively.
+  let saslName = saslPrep(aName).replace(/=/g, "=3D").replace(/,/g, "=2C");
+  if (!saslName) {
+    throw new Error("Name is not valid");
+  }
+
+  return saslName;
+}
+
+// Converts aMessage to array of bytes then apply hashing.
+function bytesAndHash(aMessage, aHash) {
+  let hasher = Cc["@mozilla.org/security/hash;1"].createInstance(
+    Ci.nsICryptoHash
+  );
+  hasher.init(hasher[aHash]);
+
+  return CryptoUtils.digestBytes(aMessage, hasher);
+}
+
+/**
+ * PBKDF2 password stretching with hmac.
+ *
+ * This is a copy of CryptoUtils.pbkdf2Generate, but with an additional argument to take the hash type.
+ *
+ * @param {string} passphrase Passphrase as an octet string.
+ * @param {string} salt Salt as an octet string.
+ * @param {string} iterations Number of iterations, a positive integer.
+ * @param {string} len Desired output length in bytes.
+ * @param {string} hash The desired hash algorithm (e.g. SHA-1 or SHA-256).
+ * @returns {Uint8Array}
+ */
+async function pbkdf2Generate(passphrase, salt, iterations, len, hash) {
+  passphrase = CommonUtils.byteStringToArrayBuffer(passphrase);
+  salt = CommonUtils.byteStringToArrayBuffer(salt);
+  const key = await crypto.subtle.importKey(
+    "raw",
+    passphrase,
+    { name: "PBKDF2" },
+    false,
+    ["deriveBits"]
+  );
+  const output = await crypto.subtle.deriveBits(
+    {
+      name: "PBKDF2",
+      hash,
+      salt,
+      iterations,
+    },
+    key,
+    len * 8
+  );
+  return new Uint8Array(output);
+}
+
+/*
+ * Given hash functions return a generator to be used as an XMPP authentication
+ * mechanism.
+ *
+ * @param {string} aHashFunctionName The name of a hash, e.g. SHA-1 or SHA-256.
+ * @param {string} aDigestLength The length of a hash digest, e.g. 20 for SHA-1 or 32 for SHA-256.
+ */
+function generateScramAuth(aHashFunctionName, aDigestLength) {
+  function* scramAuth(aUsername, aPassword, aDomain, aNonce) {
+    // The hash function name, without the '-' in it (e.g. convert SHA-1 to SHA1).
+    const hashFunctionProp = aHashFunctionName.replace("-", "");
+
+    // RFC 5802 (5): SCRAM Authentication Exchange.
+    const gs2Header = "n,,";
+    // If a hard-coded nonce was given (e.g. for testing), use it.
+    let cNonce = aNonce ? aNonce : createNonce(32);
+
+    let clientFirstMessageBare = "n=" + saslName(aUsername) + ",r=" + cNonce;
+    let clientFirstMessage = gs2Header + clientFirstMessageBare;
+
+    let receivedStanza = yield {
+      send: Stanza.node(
+        "auth",
+        Stanza.NS.sasl,
+        { mechanism: "SCRAM-" + aHashFunctionName },
+        btoa(clientFirstMessage)
+      ),
+    };
+
+    if (receivedStanza.localName != "challenge") {
+      throw new Error("Not authorized");
+    }
+
+    // RFC 5802 (3): SCRAM Algorithm Overview.
+    let decodedChallenge = atob(receivedStanza.innerText);
+
+    // Expected to contain the user’s iteration count (i) and the user’s
+    // salt (s), and the server appends its own nonce to the client-specified
+    // one (r).
+    let attributes = parseChallenge(decodedChallenge);
+    if (attributes.hasOwnProperty("e")) {
+      throw new Error("Authentication failed: " + attributes.e);
+    } else if (
+      !attributes.hasOwnProperty("i") ||
+      !attributes.hasOwnProperty("s") ||
+      !attributes.hasOwnProperty("r")
+    ) {
+      throw new Error("Unexpected response: " + decodedChallenge);
+    }
+    if (!attributes.r.startsWith(cNonce)) {
+      throw new Error("Nonce is not correct");
+    }
+
+    let clientFinalMessageWithoutProof =
+      "c=" + btoa(gs2Header) + ",r=" + attributes.r;
+
+    // The server signature is calculated below, but needs to escape back to the main scope.
+    let serverSignature;
+
+    // Once the promise resolves, continue with the handshake.
+    receivedStanza = yield (async () => {
+      // SaltedPassword := Hi(Normalize(password), salt, i)
+      // Normalize using saslPrep.
+      // dkLen MUST be equal to the SHA digest size.
+      let saltedPassword = await pbkdf2Generate(
+        saslPrep(aPassword),
+        atob(attributes.s),
+        parseInt(attributes.i),
+        aDigestLength,
+        aHashFunctionName
+      );
+
+      // Calculate ClientProof.
+
+      // ClientKey := HMAC(SaltedPassword, "Client Key")
+      let clientKeyBuffer = await CryptoUtils.hmac(
+        aHashFunctionName,
+        saltedPassword,
+        CommonUtils.byteStringToArrayBuffer("Client Key")
+      );
+      let clientKey = CommonUtils.arrayBufferToByteString(clientKeyBuffer);
+
+      // StoredKey := H(ClientKey)
+      let storedKey = bytesAndHash(clientKey, hashFunctionProp);
+
+      let authMessage = CommonUtils.byteStringToArrayBuffer(
+        clientFirstMessageBare +
+          "," +
+          decodedChallenge +
+          "," +
+          clientFinalMessageWithoutProof
+      );
+
+      // ClientSignature := HMAC(StoredKey, AuthMessage)
+      let clientSignatureBuffer = await CryptoUtils.hmac(
+        aHashFunctionName,
+        CommonUtils.byteStringToArrayBuffer(storedKey),
+        authMessage
+      );
+      let clientSignature = CommonUtils.arrayBufferToByteString(
+        clientSignatureBuffer
+      );
+      // ClientProof := ClientKey XOR ClientSignature
+      let clientProof = CryptoUtils.xor(clientKey, clientSignature);
+
+      // Calculate ServerSignature.
+
+      // ServerKey := HMAC(SaltedPassword, "Server Key")
+      let serverKeyBuffer = await CryptoUtils.hmac(
+        aHashFunctionName,
+        saltedPassword,
+        CommonUtils.byteStringToArrayBuffer("Server Key")
+      );
+
+      // ServerSignature := HMAC(ServerKey, AuthMessage)
+      let serverSignatureBuffer = await CryptoUtils.hmac(
+        aHashFunctionName,
+        serverKeyBuffer,
+        authMessage
+      );
+      serverSignature = CommonUtils.arrayBufferToByteString(
+        serverSignatureBuffer
+      );
+
+      let clientFinalMessage =
+        clientFinalMessageWithoutProof + ",p=" + btoa(clientProof);
+
+      return {
+        send: Stanza.node(
+          "response",
+          Stanza.NS.sasl,
+          null,
+          btoa(clientFinalMessage)
+        ),
+        log: "<response/> (base64 encoded SCRAM response containing password not logged)",
+      };
+    })();
+
+    // Only check server signature if we succeed to authenticate.
+    if (receivedStanza.localName != "success") {
+      throw new Error("Didn't receive the expected auth success stanza.");
+    }
+
+    let decodedResponse = atob(receivedStanza.innerText);
+
+    // Expected to contain a base64-encoded ServerSignature (v).
+    attributes = parseChallenge(decodedResponse);
+    if (!attributes.hasOwnProperty("v")) {
+      throw new Error("Unexpected response: " + decodedResponse);
+    }
+
+    // Compare ServerSignature with our ServerSignature which we calculated in
+    // _generateResponse.
+    let serverSignatureResponse = atob(attributes.v);
+    if (serverSignature != serverSignatureResponse) {
+      throw new Error("Server signature does not match");
+    }
+  }
+
+  return scramAuth;
+}
+
+export var XMPPAuthMechanisms = {
+  PLAIN: PlainAuth,
+  "SCRAM-SHA-1": generateScramAuth("SHA-1", 20),
+  "SCRAM-SHA-256": generateScramAuth("SHA-256", 32),
+};
diff --git a/comm/chat/protocols/xmpp/xmpp-base.sys.mjs b/comm/chat/protocols/xmpp/xmpp-base.sys.mjs
new file mode 100644
index 0000000000..f7e0ccd98e
--- /dev/null
+++ b/comm/chat/protocols/xmpp/xmpp-base.sys.mjs
@@ -0,0 +1,3421 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { clearTimeout, setTimeout } from "resource://gre/modules/Timer.sys.mjs";
+
+import { IMServices } from "resource:///modules/IMServices.sys.mjs";
+import { Status } from "resource:///modules/imStatusUtils.sys.mjs";
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import {
+  executeSoon,
+  nsSimpleEnumerator,
+  EmptyEnumerator,
+  ClassInfo,
+  l10nHelper,
+} from "resource:///modules/imXPCOMUtils.sys.mjs";
+import {
+  GenericAccountPrototype,
+  GenericAccountBuddyPrototype,
+  GenericConvIMPrototype,
+  GenericConvChatPrototype,
+  GenericConversationPrototype,
+  TooltipInfo,
+} from "resource:///modules/jsProtoHelper.sys.mjs";
+import { NormalizedMap } from "resource:///modules/NormalizedMap.sys.mjs";
+import {
+  Stanza,
+  SupportedFeatures,
+} from "resource:///modules/xmpp-xml.sys.mjs";
+import { XMPPSession } from "resource:///modules/xmpp-session.sys.mjs";
+
+const lazy = {};
+ChromeUtils.defineESModuleGetters(lazy, {
+  DownloadUtils: "resource://gre/modules/DownloadUtils.sys.mjs",
+  FileUtils: "resource://gre/modules/FileUtils.sys.mjs",
+});
+ChromeUtils.defineModuleGetter(
+  lazy,
+  "NetUtil",
+  "resource://gre/modules/NetUtil.jsm"
+);
+XPCOMUtils.defineLazyServiceGetter(
+  lazy,
+  "imgTools",
+  "@mozilla.org/image/tools;1",
+  "imgITools"
+);
+
+XPCOMUtils.defineLazyGetter(lazy, "_", () =>
+  l10nHelper("chrome://chat/locale/xmpp.properties")
+);
+
+XPCOMUtils.defineLazyGetter(lazy, "TXTToHTML", function () {
+  let cs = Cc["@mozilla.org/txttohtmlconv;1"].getService(Ci.mozITXTToHTMLConv);
+  return aTxt => cs.scanTXT(aTxt, cs.kEntities);
+});
+
+// Parses the status from a presence stanza into an object of statusType,
+// statusText and idleSince.
+function parseStatus(aStanza) {
+  let statusType = Ci.imIStatusInfo.STATUS_AVAILABLE;
+  let show = aStanza.getElement(["show"]);
+  if (show) {
+    show = show.innerText;
+    if (show == "away") {
+      statusType = Ci.imIStatusInfo.STATUS_AWAY;
+    } else if (show == "chat") {
+      statusType = Ci.imIStatusInfo.STATUS_AVAILABLE; // FIXME
+    } else if (show == "dnd") {
+      statusType = Ci.imIStatusInfo.STATUS_UNAVAILABLE;
+    } else if (show == "xa") {
+      statusType = Ci.imIStatusInfo.STATUS_IDLE;
+    }
+  }
+
+  let idleSince = 0;
+  let date = _getDelay(aStanza);
+  if (date) {
+    idleSince = date.getTime();
+  }
+
+  let query = aStanza.getElement(["query"]);
+  if (query && query.uri == Stanza.NS.last) {
+    let now = Math.floor(Date.now() / 1000);
+    idleSince = now - parseInt(query.attributes.seconds, 10);
+    statusType = Ci.imIStatusInfo.STATUS_IDLE;
+  }
+
+  let status = aStanza.getElement(["status"]);
+  status = status ? status.innerText : "";
+
+  return { statusType, statusText: status, idleSince };
+}
+
+// Returns a Date object for the delay value (stamp) in aStanza if it exists,
+// otherwise returns undefined.
+function _getDelay(aStanza) {
+  // XEP-0203: Delayed Delivery.
+  let date;
+  let delay = aStanza.getElement(["delay"]);
+  if (delay && delay.uri == Stanza.NS.delay) {
+    if (delay.attributes.stamp) {
+      date = new Date(delay.attributes.stamp);
+    }
+  }
+  if (date && isNaN(date.getTime())) {
+    return undefined;
+  }
+
+  return date;
+}
+
+// Writes aMsg in aConv as an outgoing message with optional date as the
+// message may be sent from another client.
+function _displaySentMsg(aConv, aMsg, aDate) {
+  let who;
+  if (aConv._account._connection) {
+    who = aConv._account._connection._jid.jid;
+  }
+  if (!who) {
+    who = aConv._account.name;
+  }
+
+  let flags = { outgoing: true };
+  flags._alias = aConv.account.alias || aConv.account.statusInfo.displayName;
+
+  if (aDate) {
+    flags.time = aDate / 1000;
+    flags.delayed = true;
+  }
+  aConv.writeMessage(who, aMsg, flags);
+}
+
+// The timespan after which we consider roomInfo to be stale.
+var kListRefreshInterval = 12 * 60 * 60 * 1000; // 12 hours.
+
+/* This is an ordered list, used to determine chat buddy flags:
+ *  index = member    -> voiced
+ *          moderator -> moderator
+ *          admin     -> admin
+ *          owner     -> founder
+ */
+var kRoles = [
+  "outcast",
+  "visitor",
+  "participant",
+  "member",
+  "moderator",
+  "admin",
+  "owner",
+];
+
+function MUCParticipant(aNick, aJid, aPresenceStanza) {
+  this._jid = aJid;
+  this.name = aNick;
+  this.onPresenceStanza(aPresenceStanza);
+}
+MUCParticipant.prototype = {
+  __proto__: ClassInfo("prplIConvChatBuddy", "XMPP ConvChatBuddy object"),
+
+  buddy: false,
+
+  // The occupant jid of the participant which is of the form room@domain/nick.
+  _jid: null,
+
+  // The real jid of the participant which is of the form local@domain/resource.
+  accountJid: null,
+
+  statusType: null,
+  statusText: null,
+  get alias() {
+    return this.name;
+  },
+
+  role: 2, // "participant" by default
+
+  // Called when a presence stanza is received for this participant.
+  onPresenceStanza(aStanza) {
+    let statusInfo = parseStatus(aStanza);
+    this.statusType = statusInfo.statusType;
+    this.statusText = statusInfo.statusText;
+
+    let x = aStanza.children.filter(
+      child => child.localName == "x" && child.uri == Stanza.NS.muc_user
+    );
+    if (x.length == 0) {
+      return;
+    }
+
+    // XEP-0045 (7.2.3): We only expect a single <x/> element of this namespace,
+    // so we ignore any others.
+    x = x[0];
+
+    let item = x.getElement(["item"]);
+    if (!item) {
+      return;
+    }
+
+    this.role = Math.max(
+      kRoles.indexOf(item.attributes.role),
+      kRoles.indexOf(item.attributes.affiliation)
+    );
+
+    let accountJid = item.attributes.jid;
+    if (accountJid) {
+      this.accountJid = accountJid;
+    }
+  },
+
+  get voiced() {
+    /* FIXME: The "voiced" role corresponds to users that can send messages to
+     * the room. If the chat is unmoderated, this should include everyone, not
+     * just members. */
+    return this.role == kRoles.indexOf("member");
+  },
+  get moderator() {
+    return this.role == kRoles.indexOf("moderator");
+  },
+  get admin() {
+    return this.role == kRoles.indexOf("admin");
+  },
+  get founder() {
+    return this.role == kRoles.indexOf("owner");
+  },
+  typing: false,
+};
+
+// MUC (Multi-User Chat)
+export var XMPPMUCConversationPrototype = {
+  __proto__: GenericConvChatPrototype,
+  // By default users are not in a MUC.
+  _left: true,
+
+  // Tracks all received messages to avoid possible duplication if the server
+  // sends us the last few messages again when we rejoin a room.
+  _messageIds: new Set(),
+
+  _init(aAccount, aJID, aNick) {
+    this._messageIds = new Set();
+    GenericConvChatPrototype._init.call(this, aAccount, aJID, aNick);
+  },
+
+  _targetResource: "",
+
+  // True while we are rejoining a room previously parted by the user.
+  _rejoined: false,
+
+  get topic() {
+    return this._topic;
+  },
+  set topic(aTopic) {
+    // XEP-0045 (8.1): Modifying the room subject.
+    let subject = Stanza.node("subject", null, null, aTopic.trim());
+    let s = Stanza.message(
+      this.name,
+      null,
+      null,
+      { type: "groupchat" },
+      subject
+    );
+    let notAuthorized = lazy._(
+      "conversation.error.changeTopicFailedNotAuthorized"
+    );
+    this._account.sendStanza(
+      s,
+      this._account.handleErrors(
+        {
+          forbidden: notAuthorized,
+          notAcceptable: notAuthorized,
+          itemNotFound: notAuthorized,
+        },
+        this
+      )
+    );
+  },
+  get topicSettable() {
+    return true;
+  },
+
+  /* Called when the user enters a chat message */
+  dispatchMessage(aMsg, aAction = false) {
+    if (aAction) {
+      // XEP-0245: The /me Command.
+      // We need to prepend "/me " as the first four characters of the message
+      // body.
+      aMsg = "/me " + aMsg;
+    }
+    // XEP-0045 (7.4): Sending a message to all occupants in a room.
+    let s = Stanza.message(this.name, aMsg, null, { type: "groupchat" });
+    let notInRoom = lazy._(
+      "conversation.error.sendFailedAsNotInRoom",
+      this.name,
+      aMsg
+    );
+    this._account.sendStanza(
+      s,
+      this._account.handleErrors(
+        {
+          itemNotFound: notInRoom,
+          notAcceptable: notInRoom,
+        },
+        this
+      )
+    );
+  },
+
+  /* Called by the account when a presence stanza is received for this muc */
+  onPresenceStanza(aStanza) {
+    let from = aStanza.attributes.from;
+    let nick = this._account._parseJID(from).resource;
+    let jid = this._account.normalize(from);
+    let x = aStanza
+      .getElements(["x"])
+      .find(
+        e => e.uri == Stanza.NS.muc_user || e.uri == Stanza.NS.vcard_update
+      );
+
+    // Check if the join failed.
+    if (this.left && aStanza.attributes.type == "error") {
+      let error = this._account.parseError(aStanza);
+      let message;
+      switch (error.condition) {
+        case "not-authorized":
+        case "registration-required":
+          // XEP-0045 (7.2.7): Members-Only Rooms.
+          message = lazy._("conversation.error.joinFailedNotAuthorized");
+          break;
+        case "not-allowed":
+          message = lazy._("conversation.error.creationFailedNotAllowed");
+          break;
+        case "remote-server-not-found":
+          message = lazy._(
+            "conversation.error.joinFailedRemoteServerNotFound",
+            this.name
+          );
+          break;
+        case "forbidden":
+          // XEP-0045 (7.2.8): Banned users.
+          message = lazy._("conversation.error.joinForbidden", this.name);
+          break;
+        default:
+          message = lazy._("conversation.error.joinFailed", this.name);
+          this.ERROR("Failed to join MUC: " + aStanza.convertToString());
+          break;
+      }
+      this.writeMessage(this.name, message, { system: true, error: true });
+      this.joining = false;
+      return;
+    }
+
+    if (!x) {
+      this.WARN(
+        "Received a MUC presence stanza without an x element or " +
+          "with a namespace we don't handle."
+      );
+      return;
+    }
+    // Handle a MUC resource avatar
+    if (
+      x.uri == Stanza.NS.vcard_update &&
+      aStanza.attributes.from == this.normalizedName
+    ) {
+      let photo = aStanza.getElement(["x", "photo"]);
+      if (photo && photo.uri == Stanza.NS.vcard_update) {
+        let hash = photo.innerText;
+        if (hash && hash != this._photoHash) {
+          this._account._addVCardRequest(this.normalizedName);
+        } else if (!hash && this._photoHash) {
+          delete this._photoHash;
+          this.convIconFilename = "";
+        }
+      }
+      return;
+    }
+    let codes = x.getElements(["status"]).map(elt => elt.attributes.code);
+    let item = x.getElement(["item"]);
+
+    // Changes the nickname of a participant for this muc.
+    let changeNick = () => {
+      if (!item || !item.attributes.nick) {
+        this.WARN(
+          "Received a MUC presence code 303 or 210 stanza without an " +
+            "item element or a nick attribute."
+        );
+        return;
+      }
+      let newNick = item.attributes.nick;
+      this.updateNick(nick, newNick, nick == this.nick);
+    };
+
+    if (aStanza.attributes.type == "unavailable") {
+      if (!this._participants.has(nick)) {
+        this.WARN(
+          "received unavailable presence for an unknown MUC participant: " +
+            from
+        );
+        return;
+      }
+      if (codes.includes("303")) {
+        // XEP-0045 (7.6): Changing Nickname.
+        // Service Updates Nick for user.
+        changeNick();
+        return;
+      }
+      if (item && item.attributes.role == "none") {
+        // XEP-0045: an occupant has left the room.
+        this.removeParticipant(nick);
+
+        // Who caused the participant to leave the room.
+        let actor = item.getElement(["actor"]);
+        let actorNick = actor ? actor.attributes.nick : "";
+        let isActor = actorNick ? ".actor" : "";
+
+        // Why the participant left.
+        let reasonNode = item.getElement(["reason"]);
+        let reason = reasonNode ? reasonNode.innerText : "";
+        let isReason = reason ? ".reason" : "";
+
+        let isYou = nick == this.nick ? ".you" : "";
+        let affectedNick = isYou ? "" : nick;
+        if (isYou) {
+          this.left = true;
+        }
+
+        let message;
+        if (codes.includes("301")) {
+          // XEP-0045 (9.1): Banning a User.
+          message = "conversation.message.banned";
+        } else if (codes.includes("307")) {
+          // XEP-0045 (8.2): Kicking an Occupant.
+          message = "conversation.message.kicked";
+        } else if (codes.includes("322") || codes.includes("321")) {
+          // XEP-0045: Inform user that he or she is being removed from the
+          // room because the room has been changed to members-only and the
+          // user is not a member.
+          message = "conversation.message.removedNonMember";
+        } else if (codes.includes("332")) {
+          // XEP-0045: Inform user that he or she is being removed from the
+          // room because the MUC service is being shut down.
+          message = "conversation.message.mucShutdown";
+
+          // The reason here just duplicates what's in the system message.
+          reason = isReason = "";
+        } else {
+          // XEP-0045 (7.14): Received when the user parts a room.
+          message = "conversation.message.parted";
+
+          // The reason is in a status element in this case.
+          reasonNode = aStanza.getElement(["status"]);
+          reason = reasonNode ? reasonNode.innerText : "";
+          isReason = reason ? ".reason" : "";
+        }
+
+        if (message) {
+          let messageID = message + isYou + isActor + isReason;
+          let params = [actorNick, affectedNick, reason].filter(s => s);
+          this.writeMessage(this.name, lazy._(messageID, ...params), {
+            system: true,
+          });
+        }
+      } else {
+        this.WARN("Unhandled type==unavailable MUC presence stanza.");
+      }
+      return;
+    }
+
+    if (codes.includes("201")) {
+      // XEP-0045 (10.1): Creating room.
+      // Service Acknowledges Room Creation
+      // and Room is awaiting configuration.
+      // XEP-0045 (10.1.2): Instant room.
+      let query = Stanza.node(
+        "query",
+        Stanza.NS.muc_owner,
+        null,
+        Stanza.node("x", Stanza.NS.xdata, { type: "submit" })
+      );
+      let s = Stanza.iq("set", null, jid, query);
+      this._account.sendStanza(s, aStanzaReceived => {
+        if (aStanzaReceived.attributes.type != "result") {
+          return false;
+        }
+
+        // XEP-0045: Service Informs New Room Owner of Success
+        // for instant and reserved rooms.
+        this.left = false;
+        this.joining = false;
+        return true;
+      });
+    } else if (codes.includes("210")) {
+      // XEP-0045 (7.6): Changing Nickname.
+      // Service modifies this user's nickname in accordance with local service
+      // policies.
+      changeNick();
+      return;
+    } else if (codes.includes("110")) {
+      // XEP-0045: Room exists and joined successfully.
+      this.left = false;
+      this.joining = false;
+      // TODO (Bug 1172350): Implement Service Discovery Extensions (XEP-0128) to obtain
+      // configuration of this room.
+    } else if (codes.includes("104") && nick == this.name) {
+      // https://xmpp.org/extensions/inbox/muc-avatars.html (XEP-XXXX)
+      this._account._addVCardRequest(this.normalizedName);
+    }
+
+    if (!this._participants.get(nick)) {
+      let participant = new MUCParticipant(nick, from, aStanza);
+      this._participants.set(nick, participant);
+      this.notifyObservers(
+        new nsSimpleEnumerator([participant]),
+        "chat-buddy-add"
+      );
+      if (this.nick != nick && !this.joining) {
+        this.writeMessage(
+          this.name,
+          lazy._("conversation.message.join", nick),
+          {
+            system: true,
+          }
+        );
+      } else if (this.nick == nick && this._rejoined) {
+        this.writeMessage(this.name, lazy._("conversation.message.rejoined"), {
+          system: true,
+        });
+        this._rejoined = false;
+      }
+    } else {
+      this._participants.get(nick).onPresenceStanza(aStanza);
+      this.notifyObservers(this._participants.get(nick), "chat-buddy-update");
+    }
+  },
+
+  /* Called by the account when a message is received for this muc */
+  incomingMessage(aMsg, aStanza, aDate) {
+    let from = this._account._parseJID(aStanza.attributes.from).resource;
+    let id = aStanza.attributes.id;
+    let flags = {};
+    if (!from) {
+      flags.system = true;
+      from = this.name;
+    } else if (aStanza.attributes.type == "error") {
+      aMsg = lazy._("conversation.error.notDelivered", aMsg);
+      flags.system = true;
+      flags.error = true;
+    } else if (from == this._nick) {
+      flags.outgoing = true;
+    } else {
+      flags.incoming = true;
+    }
+    if (aDate) {
+      flags.time = aDate / 1000;
+      flags.delayed = true;
+    }
+    if (id) {
+      // Checks if a message exists in conversation to avoid duplication.
+      if (this._messageIds.has(id)) {
+        return;
+      }
+      this._messageIds.add(id);
+    }
+    this.writeMessage(from, aMsg, flags);
+  },
+
+  getNormalizedChatBuddyName(aNick) {
+    return this._account.normalizeFullJid(this.name + "/" + aNick);
+  },
+
+  // Leaves MUC conversation.
+  part(aMsg = null) {
+    let s = Stanza.presence(
+      { to: this.name + "/" + this._nick, type: "unavailable" },
+      aMsg ? Stanza.node("status", null, null, aMsg.trim()) : null
+    );
+    this._account.sendStanza(s);
+    delete this.chatRoomFields;
+  },
+
+  // Invites a user to MUC conversation.
+  invite(aJID, aMsg = null) {
+    // XEP-0045 (7.8): Inviting Another User to a Room.
+    // XEP-0045 (7.8.2): Mediated Invitation.
+    let invite = Stanza.node(
+      "invite",
+      null,
+      { to: aJID },
+      aMsg ? Stanza.node("reason", null, null, aMsg) : null
+    );
+    let x = Stanza.node("x", Stanza.NS.muc_user, null, invite);
+    let s = Stanza.node("message", null, { to: this.name }, x);
+    this._account.sendStanza(
+      s,
+      this._account.handleErrors(
+        {
+          forbidden: lazy._("conversation.error.inviteFailedForbidden"),
+          // ejabberd uses error not-allowed to indicate that this account does not
+          // have the required privileges to invite users instead of forbidden error,
+          // and this is not mentioned in the spec (XEP-0045).
+          notAllowed: lazy._("conversation.error.inviteFailedForbidden"),
+          itemNotFound: lazy._("conversation.error.failedJIDNotFound", aJID),
+        },
+        this
+      )
+    );
+  },
+
+  // Bans a participant from MUC conversation.
+  ban(aNickName, aMsg = null) {
+    // XEP-0045 (9.1): Banning a User.
+    let participant = this._participants.get(aNickName);
+    if (!participant) {
+      this.writeMessage(
+        this.name,
+        lazy._("conversation.error.nickNotInRoom", aNickName),
+        { system: true }
+      );
+      return;
+    }
+    if (!participant.accountJid) {
+      this.writeMessage(
+        this.name,
+        lazy._("conversation.error.banCommandAnonymousRoom"),
+        { system: true }
+      );
+      return;
+    }
+
+    let attributes = { affiliation: "outcast", jid: participant.accountJid };
+    let item = Stanza.node(
+      "item",
+      null,
+      attributes,
+      aMsg ? Stanza.node("reason", null, null, aMsg) : null
+    );
+    let s = Stanza.iq(
+      "set",
+      null,
+      this.name,
+      Stanza.node("query", Stanza.NS.muc_admin, null, item)
+    );
+    this._account.sendStanza(s, this._banKickHandler, this);
+  },
+
+  // Kicks a participant from MUC conversation.
+  kick(aNickName, aMsg = null) {
+    // XEP-0045 (8.2): Kicking an Occupant.
+    let attributes = { role: "none", nick: aNickName };
+    let item = Stanza.node(
+      "item",
+      null,
+      attributes,
+      aMsg ? Stanza.node("reason", null, null, aMsg) : null
+    );
+    let s = Stanza.iq(
+      "set",
+      null,
+      this.name,
+      Stanza.node("query", Stanza.NS.muc_admin, null, item)
+    );
+    this._account.sendStanza(s, this._banKickHandler, this);
+  },
+
+  // Callback for ban and kick commands.
+  _banKickHandler(aStanza) {
+    return this._account._handleResult(
+      {
+        notAllowed: lazy._("conversation.error.banKickCommandNotAllowed"),
+        conflict: lazy._("conversation.error.banKickCommandConflict"),
+      },
+      this
+    )(aStanza);
+  },
+
+  // Changes nick in MUC conversation to a new one.
+  setNick(aNewNick) {
+    // XEP-0045 (7.6): Changing Nickname.
+    let s = Stanza.presence({ to: this.name + "/" + aNewNick }, null);
+    this._account.sendStanza(
+      s,
+      this._account.handleErrors(
+        {
+          // XEP-0045 (7.6): Changing Nickname (example 53).
+          // TODO: We should discover if the user has a reserved nickname (maybe
+          // before joining a room), cf. XEP-0045 (7.12).
+          notAcceptable: lazy._(
+            "conversation.error.changeNickFailedNotAcceptable",
+            aNewNick
+          ),
+          // XEP-0045 (7.2.9): Nickname Conflict.
+          conflict: lazy._(
+            "conversation.error.changeNickFailedConflict",
+            aNewNick
+          ),
+        },
+        this
+      )
+    );
+  },
+
+  // Called by the account when a message stanza is received for this muc and
+  // needs to be handled.
+  onMessageStanza(aStanza) {
+    let x = aStanza.getElement(["x"]);
+    let decline = x.getElement(["decline"]);
+    if (decline) {
+      // XEP-0045 (7.8): Inviting Another User to a Room.
+      // XEP-0045 (7.8.2): Mediated Invitation.
+      let invitee = decline.attributes.jid;
+      let reasonNode = decline.getElement(["reason"]);
+      let reason = reasonNode ? reasonNode.innerText : "";
+      let msg;
+      if (reason) {
+        msg = lazy._(
+          "conversation.message.invitationDeclined.reason",
+          invitee,
+          reason
+        );
+      } else {
+        msg = lazy._("conversation.message.invitationDeclined", invitee);
+      }
+
+      this.writeMessage(this.name, msg, { system: true });
+    } else {
+      this.WARN("Unhandled message stanza.");
+    }
+  },
+
+  /* Called when the user closed the conversation */
+  close() {
+    if (!this.left) {
+      this.part();
+    }
+    GenericConvChatPrototype.close.call(this);
+  },
+  unInit() {
+    this._account.removeConversation(this.name);
+    GenericConvChatPrototype.unInit.call(this);
+  },
+
+  _photoHash: null,
+  _saveIcon(aPhotoNode) {
+    this._account._saveResourceIcon(aPhotoNode, this).then(
+      url => {
+        this.convIconFilename = url;
+      },
+      error => {
+        this._account.WARN(
+          "Error while loading conversation icon for " +
+            this.normalizedName +
+            ": " +
+            error.message
+        );
+      }
+    );
+  },
+};
+
+function XMPPMUCConversation(aAccount, aJID, aNick) {
+  this._init(aAccount, aJID, aNick);
+}
+XMPPMUCConversation.prototype = XMPPMUCConversationPrototype;
+
+/* Helper class for buddy conversations */
+export var XMPPConversationPrototype = {
+  __proto__: GenericConvIMPrototype,
+
+  _typingTimer: null,
+  supportChatStateNotifications: true,
+  _typingState: "active",
+
+  // Indicates that current conversation is with a MUC participant and the
+  // recipient jid (stored in the userName) is of the form room@domain/nick.
+  _isMucParticipant: false,
+
+  get buddy() {
+    return this._account._buddies.get(this.name);
+  },
+  get title() {
+    return this.contactDisplayName;
+  },
+  get contactDisplayName() {
+    return this.buddy ? this.buddy.contactDisplayName : this.name;
+  },
+  get userName() {
+    return this.buddy ? this.buddy.userName : this.name;
+  },
+
+  // Returns jid (room@domain/nick) if it is with a MUC participant, and the
+  // name of conversation otherwise.
+  get normalizedName() {
+    if (this._isMucParticipant) {
+      return this._account.normalizeFullJid(this.name);
+    }
+    return this._account.normalize(this.name);
+  },
+
+  // Used to avoid showing full jids in typing notifications.
+  get shortName() {
+    if (this.buddy) {
+      return this.buddy.contactDisplayName;
+    }
+
+    let jid = this._account._parseJID(this.name);
+    if (!jid) {
+      return this.name;
+    }
+
+    // Returns nick of the recipient if conversation is with a participant of
+    // a MUC we are in as jid of the recipient is of the form room@domain/nick.
+    if (this._isMucParticipant) {
+      return jid.resource;
+    }
+
+    return jid.node;
+  },
+
+  get shouldSendTypingNotifications() {
+    return (
+      this.supportChatStateNotifications &&
+      Services.prefs.getBoolPref("purple.conversations.im.send_typing")
+    );
+  },
+
+  /* Called when the user is typing a message
+   * aString - the currently typed message
+   * Returns the number of characters that can still be typed */
+  sendTyping(aString) {
+    if (!this.shouldSendTypingNotifications) {
+      return Ci.prplIConversation.NO_TYPING_LIMIT;
+    }
+
+    this._cancelTypingTimer();
+    if (aString.length) {
+      this._typingTimer = setTimeout(this.finishedComposing.bind(this), 10000);
+    }
+
+    this._setTypingState(aString.length ? "composing" : "active");
+
+    return Ci.prplIConversation.NO_TYPING_LIMIT;
+  },
+
+  finishedComposing() {
+    if (!this.shouldSendTypingNotifications) {
+      return;
+    }
+
+    this._setTypingState("paused");
+  },
+
+  _setTypingState(aNewState) {
+    if (this._typingState == aNewState) {
+      return;
+    }
+
+    let s = Stanza.message(this.to, null, aNewState);
+
+    // We don't care about errors in response to typing notifications
+    // (e.g. because the user has left the room when talking to a MUC
+    // participant).
+    this._account.sendStanza(s, () => true);
+
+    this._typingState = aNewState;
+  },
+  _cancelTypingTimer() {
+    if (this._typingTimer) {
+      clearTimeout(this._typingTimer);
+      delete this._typingTimer;
+    }
+  },
+
+  // Holds the resource of user that you are currently talking to, but if the
+  // user is a participant of a MUC we are in, holds the nick of user you are
+  // talking to.
+  _targetResource: "",
+
+  get to() {
+    if (!this._targetResource || this._isMucParticipant) {
+      return this.userName;
+    }
+    return this.userName + "/" + this._targetResource;
+  },
+
+  /* Called when the user enters a chat message */
+  dispatchMessage(aMsg, aAction = false) {
+    if (aAction) {
+      // XEP-0245: The /me Command.
+      // We need to prepend "/me " as the first four characters of the message
+      // body.
+      aMsg = "/me" + aMsg;
+    }
+    this._cancelTypingTimer();
+    let cs = this.shouldSendTypingNotifications ? "active" : null;
+    let s = Stanza.message(this.to, aMsg, cs);
+    this._account.sendStanza(s);
+    _displaySentMsg(this, aMsg);
+    delete this._typingState;
+  },
+
+  // Invites the contact to a MUC room.
+  invite(aRoomJid, aPassword = null) {
+    // XEP-0045 (7.8): Inviting Another User to a Room.
+    // XEP-0045 (7.8.1) and XEP-0249: Direct Invitation.
+    let x = Stanza.node("x", Stanza.NS.conference, {
+      jid: aRoomJid,
+      password: aPassword,
+    });
+    this._account.sendStanza(Stanza.node("message", null, { to: this.to }, x));
+  },
+
+  // Query the user for its Software Version.
+  // XEP-0092: Software Version.
+  getVersion() {
+    // TODO: Use Service Discovery to determine if the user's client supports
+    // jabber:iq:version protocol.
+
+    let s = Stanza.iq(
+      "get",
+      null,
+      this.to,
+      Stanza.node("query", Stanza.NS.version)
+    );
+    this._account.sendStanza(s, aStanza => {
+      // TODO: handle other errors that can result from querying
+      // user for its software version.
+      if (
+        this._account.handleErrors(
+          {
+            default: lazy._("conversation.error.version.unknown"),
+          },
+          this
+        )(aStanza)
+      ) {
+        return;
+      }
+
+      let query = aStanza.getElement(["query"]);
+      if (!query || query.uri != Stanza.NS.version) {
+        this.WARN(
+          "Received a response to version query which does not " +
+            "contain query element or 'jabber:iq:version' namespace."
+        );
+        return;
+      }
+
+      let name = query.getElement(["name"]);
+      let version = query.getElement(["version"]);
+      if (!name || !version) {
+        // XEP-0092: name and version elements are REQUIRED.
+        this.WARN(
+          "Received a response to version query which does not " +
+            "contain name or version."
+        );
+        return;
+      }
+
+      let messageID = "conversation.message.version";
+      let params = [this.shortName, name.innerText, version.innerText];
+
+      // XEP-0092: os is OPTIONAL.
+      let os = query.getElement(["os"]);
+      if (os) {
+        params.push(os.innerText);
+        messageID += "WithOS";
+      }
+
+      this.writeMessage(this.name, lazy._(messageID, ...params), {
+        system: true,
+      });
+    });
+  },
+
+  /* Perform entity escaping before displaying the message. We assume incoming
+     messages have already been escaped, and will otherwise be filtered. */
+  prepareForDisplaying(aMsg) {
+    if (aMsg.outgoing && !aMsg.system) {
+      aMsg.displayMessage = lazy.TXTToHTML(aMsg.displayMessage);
+    }
+    GenericConversationPrototype.prepareForDisplaying.apply(this, arguments);
+  },
+
+  /* Called by the account when a message is received from the buddy */
+  incomingMessage(aMsg, aStanza, aDate) {
+    let from = aStanza.attributes.from;
+    this._targetResource = this._account._parseJID(from).resource;
+    let flags = {};
+    let error = this._account.parseError(aStanza);
+    if (error) {
+      let norm = this._account.normalize(from);
+      let muc = this._account._mucs.get(norm);
+
+      if (!aMsg) {
+        // Failed outgoing message.
+        switch (error.condition) {
+          case "remote-server-not-found":
+            aMsg = lazy._("conversation.error.remoteServerNotFound");
+            break;
+          case "service-unavailable":
+            aMsg = lazy._(
+              "conversation.error.sendServiceUnavailable",
+              this.shortName
+            );
+            break;
+          default:
+            aMsg = lazy._("conversation.error.unknownSendError");
+            break;
+        }
+      } else if (
+        this._isMucParticipant &&
+        muc &&
+        !muc.left &&
+        error.condition == "item-not-found"
+      ) {
+        // XEP-0045 (7.5): MUC private messages.
+        // If we try to send to participant not in a room we are in.
+        aMsg = lazy._(
+          "conversation.error.sendFailedAsRecipientNotInRoom",
+          this._targetResource,
+          aMsg
+        );
+      } else if (
+        this._isMucParticipant &&
+        (error.condition == "item-not-found" ||
+          error.condition == "not-acceptable")
+      ) {
+        // If we left a room and try to send to a participant in it or the
+        // room is removed.
+        aMsg = lazy._(
+          "conversation.error.sendFailedAsNotInRoom",
+          this._account.normalize(from),
+          aMsg
+        );
+      } else {
+        aMsg = lazy._("conversation.error.notDelivered", aMsg);
+      }
+      flags.system = true;
+      flags.error = true;
+    } else {
+      flags = { incoming: true, _alias: this.contactDisplayName };
+      // XEP-0245: The /me Command.
+      if (aMsg.startsWith("/me ")) {
+        flags.action = true;
+        aMsg = aMsg.slice(4);
+      }
+    }
+    if (aDate) {
+      flags.time = aDate / 1000;
+      flags.delayed = true;
+    }
+    this.writeMessage(from, aMsg, flags);
+  },
+
+  /* Called when the user closed the conversation */
+  close() {
+    // TODO send the stanza indicating we have left the conversation?
+    GenericConvIMPrototype.close.call(this);
+  },
+  unInit() {
+    this._account.removeConversation(this.normalizedName);
+    GenericConvIMPrototype.unInit.call(this);
+  },
+};
+
+// Creates XMPP conversation.
+function XMPPConversation(aAccount, aNormalizedName, aMucParticipant) {
+  this._init(aAccount, aNormalizedName);
+  if (aMucParticipant) {
+    this._isMucParticipant = true;
+  }
+}
+XMPPConversation.prototype = XMPPConversationPrototype;
+
+/* Helper class for buddies */
+export var XMPPAccountBuddyPrototype = {
+  __proto__: GenericAccountBuddyPrototype,
+
+  subscription: "none",
+  // Returns a list of TooltipInfo objects to be displayed when the user
+  // hovers over the buddy.
+  getTooltipInfo() {
+    if (!this._account.connected) {
+      return null;
+    }
+
+    let tooltipInfo = [];
+    if (this._resources) {
+      for (let r in this._resources) {
+        let status = this._resources[r];
+        let statusString = Status.toLabel(status.statusType);
+        if (
+          status.statusType == Ci.imIStatusInfo.STATUS_IDLE &&
+          status.idleSince
+        ) {
+          let now = Math.floor(Date.now() / 1000);
+          let valuesAndUnits = lazy.DownloadUtils.convertTimeUnits(
+            now - status.idleSince
+          );
+          if (!valuesAndUnits[2]) {
+            valuesAndUnits.splice(2, 2);
+          }
+          statusString += " (" + valuesAndUnits.join(" ") + ")";
+        }
+        if (status.statusText) {
+          statusString += " - " + status.statusText;
+        }
+        let label = r
+          ? lazy._("tooltip.status", r)
+          : lazy._("tooltip.statusNoResource");
+        tooltipInfo.push(new TooltipInfo(label, statusString));
+      }
+    }
+
+    // The subscription value is interesting to display only in unusual cases.
+    if (this.subscription != "both") {
+      tooltipInfo.push(
+        new TooltipInfo(lazy._("tooltip.subscription"), this.subscription)
+      );
+    }
+
+    return tooltipInfo;
+  },
+
+  // _rosterAlias is the value stored in the roster on the XMPP
+  // server. For most servers we will be read/write.
+  _rosterAlias: "",
+  set rosterAlias(aNewAlias) {
+    let old = this.displayName;
+    this._rosterAlias = aNewAlias;
+    if (old != this.displayName) {
+      this._notifyObservers("display-name-changed", old);
+    }
+  },
+  _vCardReceived: false,
+  // _vCardFormattedName is the display name the contact has set for
+  // himself in his vCard. It's read-only from our point of view.
+  _vCardFormattedName: "",
+  set vCardFormattedName(aNewFormattedName) {
+    let old = this.displayName;
+    this._vCardFormattedName = aNewFormattedName;
+    if (old != this.displayName) {
+      this._notifyObservers("display-name-changed", old);
+    }
+  },
+
+  // _serverAlias is set by jsProtoHelper to the value we cached in sqlite.
+  // Use it only if we have neither of the other two values; usually because
+  // we haven't connected to the server yet.
+  get serverAlias() {
+    return this._rosterAlias || this._vCardFormattedName || this._serverAlias;
+  },
+  set serverAlias(aNewAlias) {
+    if (!this._rosterItem) {
+      this.ERROR(
+        "attempting to update the server alias of an account buddy " +
+          "for which we haven't received a roster item."
+      );
+      return;
+    }
+
+    let item = this._rosterItem;
+    if (aNewAlias) {
+      item.attributes.name = aNewAlias;
+    } else if ("name" in item.attributes) {
+      delete item.attributes.name;
+    }
+
+    let s = Stanza.iq(
+      "set",
+      null,
+      null,
+      Stanza.node("query", Stanza.NS.roster, null, item)
+    );
+    this._account.sendStanza(s);
+
+    // If we are going to change the alias on the server, discard the cached
+    // value that we got from our local sqlite storage at startup.
+    delete this._serverAlias;
+  },
+
+  /* Display name of the buddy */
+  get contactDisplayName() {
+    return this.buddy.contact.displayName || this.displayName;
+  },
+
+  get tag() {
+    return this._tag;
+  },
+  set tag(aNewTag) {
+    let oldTag = this._tag;
+    if (oldTag.name == aNewTag.name) {
+      this.ERROR("attempting to set the tag to the same value");
+      return;
+    }
+
+    this._tag = aNewTag;
+    IMServices.contacts.accountBuddyMoved(this, oldTag, aNewTag);
+
+    if (!this._rosterItem) {
+      this.ERROR(
+        "attempting to change the tag of an account buddy without roster item"
+      );
+      return;
+    }
+
+    let item = this._rosterItem;
+    let oldXML = item.getXML();
+    // Remove the old tag if it was listed in the roster item.
+    item.children = item.children.filter(
+      c => c.qName != "group" || c.innerText != oldTag.name
+    );
+    // Ensure the new tag is listed.
+    let newTagName = aNewTag.name;
+    if (!item.getChildren("group").some(g => g.innerText == newTagName)) {
+      item.addChild(Stanza.node("group", null, null, newTagName));
+    }
+    // Avoid sending anything to the server if the roster item hasn't changed.
+    // It's possible that the roster item hasn't changed if the roster
+    // item had several groups and the user moved locally the contact
+    // to another group where it already was on the server.
+    if (item.getXML() == oldXML) {
+      return;
+    }
+
+    let s = Stanza.iq(
+      "set",
+      null,
+      null,
+      Stanza.node("query", Stanza.NS.roster, null, item)
+    );
+    this._account.sendStanza(s);
+  },
+
+  remove() {
+    if (!this._account.connected) {
+      return;
+    }
+
+    let s = Stanza.iq(
+      "set",
+      null,
+      null,
+      Stanza.node(
+        "query",
+        Stanza.NS.roster,
+        null,
+        Stanza.node("item", null, {
+          jid: this.normalizedName,
+          subscription: "remove",
+        })
+      )
+    );
+    this._account.sendStanza(s);
+  },
+
+  _photoHash: null,
+  _saveIcon(aPhotoNode) {
+    this._account._saveResourceIcon(aPhotoNode, this).then(
+      url => {
+        this.buddyIconFilename = url;
+      },
+      error => {
+        this._account.WARN(
+          "Error loading buddy icon for " +
+            this.normalizedName +
+            ": " +
+            error.message
+        );
+      }
+    );
+  },
+
+  _preferredResource: undefined,
+  _resources: null,
+  onAccountDisconnected() {
+    delete this._preferredResource;
+    delete this._resources;
+  },
+  // Called by the account when a presence stanza is received for this buddy.
+  onPresenceStanza(aStanza) {
+    let preferred = this._preferredResource;
+
+    // Facebook chat's XMPP server doesn't send resources, let's
+    // replace undefined resources with empty resources.
+    let resource =
+      this._account._parseJID(aStanza.attributes.from).resource || "";
+
+    let type = aStanza.attributes.type;
+
+    // Reset typing status if the buddy is in a conversation and becomes unavailable.
+    let conv = this._account._conv.get(this.normalizedName);
+    if (type == "unavailable" && conv) {
+      conv.updateTyping(Ci.prplIConvIM.NOT_TYPING, this.contactDisplayName);
+    }
+
+    if (type == "unavailable" || type == "error") {
+      if (!this._resources || !(resource in this._resources)) {
+        // Ignore for already offline resources.
+        return;
+      }
+      delete this._resources[resource];
+      if (preferred == resource) {
+        preferred = undefined;
+      }
+    } else {
+      let statusInfo = parseStatus(aStanza);
+      let priority = aStanza.getElement(["priority"]);
+      priority = priority ? parseInt(priority.innerText, 10) : 0;
+
+      if (!this._resources) {
+        this._resources = {};
+      }
+      this._resources[resource] = {
+        statusType: statusInfo.statusType,
+        statusText: statusInfo.statusText,
+        idleSince: statusInfo.idleSince,
+        priority,
+        stanza: aStanza,
+      };
+    }
+
+    let photo = aStanza.getElement(["x", "photo"]);
+    if (photo && photo.uri == Stanza.NS.vcard_update) {
+      let hash = photo.innerText;
+      if (hash && hash != this._photoHash) {
+        this._account._addVCardRequest(this.normalizedName);
+      } else if (!hash && this._photoHash) {
+        delete this._photoHash;
+        this.buddyIconFilename = "";
+      }
+    }
+
+    for (let r in this._resources) {
+      if (
+        preferred === undefined ||
+        this._resources[r].statusType > this._resources[preferred].statusType
+      ) {
+        // FIXME also compare priorities...
+        preferred = r;
+      }
+    }
+    if (
+      preferred != undefined &&
+      preferred == this._preferredResource &&
+      resource != preferred
+    ) {
+      // The presence information change is only for an unused resource,
+      // only potential buddy tooltips need to be refreshed.
+      this._notifyObservers("status-detail-changed");
+      return;
+    }
+
+    // Presence info has changed enough that if we are having a
+    // conversation with one resource of this buddy, we should send
+    // the next message to all resources.
+    // FIXME: the test here isn't exactly right...
+    if (
+      this._preferredResource != preferred &&
+      this._account._conv.has(this.normalizedName)
+    ) {
+      delete this._account._conv.get(this.normalizedName)._targetResource;
+    }
+
+    this._preferredResource = preferred;
+    if (preferred === undefined) {
+      let statusType = Ci.imIStatusInfo.STATUS_UNKNOWN;
+      if (type == "unavailable") {
+        statusType = Ci.imIStatusInfo.STATUS_OFFLINE;
+      }
+      this.setStatus(statusType, "");
+    } else {
+      preferred = this._resources[preferred];
+      this.setStatus(preferred.statusType, preferred.statusText);
+    }
+  },
+
+  /* Can send messages to buddies who appear offline */
+  get canSendMessage() {
+    return this.account.connected;
+  },
+
+  /* Called when the user wants to chat with the buddy */
+  createConversation() {
+    return this._account.createConversation(this.normalizedName);
+  },
+};
+
+function XMPPAccountBuddy(aAccount, aBuddy, aTag, aUserName) {
+  this._init(aAccount, aBuddy, aTag, aUserName);
+}
+XMPPAccountBuddy.prototype = XMPPAccountBuddyPrototype;
+
+var XMPPRoomInfoPrototype = {
+  __proto__: ClassInfo("prplIRoomInfo", "XMPP RoomInfo Object"),
+  get topic() {
+    return "";
+  },
+  get participantCount() {
+    return Ci.prplIRoomInfo.NO_PARTICIPANT_COUNT;
+  },
+  get chatRoomFieldValues() {
+    let roomJid = this._account._roomList.get(this.name);
+    return this._account.getChatRoomDefaultFieldValues(roomJid);
+  },
+};
+function XMPPRoomInfo(aName, aAccount) {
+  this.name = aName;
+  this._account = aAccount;
+}
+XMPPRoomInfo.prototype = XMPPRoomInfoPrototype;
+
+/* Helper class for account */
+export var XMPPAccountPrototype = {
+  __proto__: GenericAccountPrototype,
+
+  _jid: null, // parsed Jabber ID: node, domain, resource
+  _connection: null, // XMPPSession socket
+  authMechanisms: null, // hook to let prpls tweak the list of auth mechanisms
+
+  // Contains the domain of MUC service which is obtained using service
+  // discovery.
+  _mucService: null,
+
+  // Maps room names to room jid.
+  _roomList: new Map(),
+
+  // Callbacks used when roomInfo is available.
+  _roomInfoCallbacks: new Set(),
+
+  // Determines if roomInfo that we have is expired or not.
+  _lastListTime: 0,
+  get isRoomInfoStale() {
+    return Date.now() - this._lastListTime > kListRefreshInterval;
+  },
+
+  // If true, we are waiting for replies.
+  _pendingList: false,
+
+  // An array of jids for which we still need to request vCards.
+  _pendingVCardRequests: [],
+
+  // XEP-0280: Message Carbons.
+  // If true, message carbons are currently enabled.
+  _isCarbonsEnabled: false,
+
+  /* Generate unique id for a stanza. Using id and unique sid is defined in
+   * RFC 6120 (Section 8.2.3, 4.7.3).
+   */
+  generateId: () => Services.uuid.generateUUID().toString().slice(1, -1),
+
+  _init(aProtoInstance, aImAccount) {
+    GenericAccountPrototype._init.call(this, aProtoInstance, aImAccount);
+
+    // Ongoing conversations.
+    // The keys of this._conv are assumed to be normalized like account@domain
+    // for normal conversations and like room@domain/nick for MUC participant
+    // convs.
+    this._conv = new NormalizedMap(this.normalizeFullJid.bind(this));
+
+    this._buddies = new NormalizedMap(this.normalize.bind(this));
+    this._mucs = new NormalizedMap(this.normalize.bind(this));
+
+    this._pendingVCardRequests = [];
+  },
+
+  get canJoinChat() {
+    return true;
+  },
+  chatRoomFields: {
+    room: {
+      get label() {
+        return lazy._("chatRoomField.room");
+      },
+      required: true,
+    },
+    server: {
+      get label() {
+        return lazy._("chatRoomField.server");
+      },
+      required: true,
+    },
+    nick: {
+      get label() {
+        return lazy._("chatRoomField.nick");
+      },
+      required: true,
+    },
+    password: {
+      get label() {
+        return lazy._("chatRoomField.password");
+      },
+      isPassword: true,
+    },
+  },
+  parseDefaultChatName(aDefaultChatName) {
+    if (!aDefaultChatName) {
+      return { nick: this._jid.node };
+    }
+
+    let params = aDefaultChatName.trim().split(/\s+/);
+    let jid = this._parseJID(params[0]);
+
+    // We swap node and domain as domain is required for parseJID, but node and
+    // resource are optional. In MUC join command, Node is required as it
+    // represents a room, but domain and resource are optional as we get muc
+    // domain from service discovery.
+    if (!jid.node && jid.domain) {
+      [jid.node, jid.domain] = [jid.domain, jid.node];
+    }
+
+    let chatFields = {
+      room: jid.node,
+      server: jid.domain || this._mucService,
+      nick: jid.resource || this._jid.node,
+    };
+    if (params.length > 1) {
+      chatFields.password = params[1];
+    }
+    return chatFields;
+  },
+  getChatRoomDefaultFieldValues(aDefaultChatName) {
+    let rv = GenericAccountPrototype.getChatRoomDefaultFieldValues.call(
+      this,
+      aDefaultChatName
+    );
+    if (!rv.values.nick) {
+      rv.values.nick = this._jid.node;
+    }
+    if (!rv.values.server && this._mucService) {
+      rv.values.server = this._mucService;
+    }
+
+    return rv;
+  },
+
+  // XEP-0045: Requests joining room if it exists or
+  // creating room if it does not exist.
+  joinChat(aComponents) {
+    let jid =
+      aComponents.getValue("room") + "@" + aComponents.getValue("server");
+    let nick = aComponents.getValue("nick");
+
+    let muc = this._mucs.get(jid);
+    if (muc) {
+      if (!muc.left) {
+        // We are already in this conversation.
+        return muc;
+      } else if (!muc.chatRoomFields) {
+        // We are rejoining a room that was parted by the user.
+        muc._rejoined = true;
+      }
+    } else {
+      muc = new this._MUCConversationConstructor(this, jid, nick);
+      this._mucs.set(jid, muc);
+    }
+
+    // Store the prplIChatRoomFieldValues to enable later reconnections.
+    muc.chatRoomFields = aComponents;
+    muc.joining = true;
+    muc.removeAllParticipants();
+
+    let password = aComponents.getValue("password");
+    let x = Stanza.node(
+      "x",
+      Stanza.NS.muc,
+      null,
+      password ? Stanza.node("password", null, null, password) : null
+    );
+    let logString;
+    if (password) {
+      logString =
+        "<presence .../> (Stanza containing password to join MUC " +
+        jid +
+        "/" +
+        nick +
+        " not logged)";
+    }
+    this.sendStanza(
+      Stanza.presence({ to: jid + "/" + nick }, x),
+      undefined,
+      undefined,
+      logString
+    );
+    return muc;
+  },
+
+  _idleSince: 0,
+  observe(aSubject, aTopic, aData) {
+    if (aTopic == "idle-time-changed") {
+      let idleTime = parseInt(aData, 10);
+      if (idleTime) {
+        this._idleSince = Math.floor(Date.now() / 1000) - idleTime;
+      } else {
+        delete this._idleSince;
+      }
+      this._shouldSendPresenceForIdlenessChange = true;
+      executeSoon(
+        function () {
+          if ("_shouldSendPresenceForIdlenessChange" in this) {
+            this._sendPresence();
+          }
+        }.bind(this)
+      );
+    } else if (aTopic == "status-changed") {
+      this._sendPresence();
+    } else if (aTopic == "user-icon-changed") {
+      delete this._cachedUserIcon;
+      this._forceUserIconUpdate = true;
+      this._sendVCard();
+    } else if (aTopic == "user-display-name-changed") {
+      this._forceUserDisplayNameUpdate = true;
+    }
+    this._sendVCard();
+  },
+
+  /* GenericAccountPrototype events */
+  /* Connect to the server */
+  connect() {
+    this._jid = this._parseJID(this.name);
+
+    // For the resource, if the user has edited the option, always use that.
+    if (this.prefs.prefHasUserValue("resource")) {
+      let resource = this.getString("resource");
+
+      // this._jid needs to be updated. This value is however never used
+      // because while connected it's the jid of the session that's
+      // interesting.
+      this._jid = this._setJID(this._jid.domain, this._jid.node, resource);
+    } else if (this._jid.resource) {
+      // If there is a resource in the account name (inherited from libpurple),
+      // migrate it to the pref so it appears correctly in the advanced account
+      // options next time.
+      this.prefs.setStringPref("resource", this._jid.resource);
+    }
+
+    this._connection = new XMPPSession(
+      this.getString("server") || this._jid.domain,
+      this.getInt("port") || 5222,
+      this.getString("connection_security"),
+      this._jid,
+      this.imAccount.password,
+      this
+    );
+  },
+
+  remove() {
+    this._conv.forEach(conv => conv.close());
+    this._mucs.forEach(muc => muc.close());
+    this._buddies.forEach((buddy, jid) => this._forgetRosterItem(jid));
+  },
+
+  unInit() {
+    if (this._connection) {
+      this._disconnect(undefined, undefined, true);
+    }
+    delete this._jid;
+    delete this._conv;
+    delete this._buddies;
+    delete this._mucs;
+  },
+
+  /* Disconnect from the server */
+  disconnect() {
+    this._disconnect();
+  },
+
+  addBuddy(aTag, aName) {
+    if (!this._connection) {
+      throw new Error("The account isn't connected");
+    }
+
+    let jid = this.normalize(aName);
+    if (!jid || !jid.includes("@")) {
+      throw new Error("Invalid username");
+    }
+
+    if (this._buddies.has(jid)) {
+      let subscription = this._buddies.get(jid).subscription;
+      if (subscription && (subscription == "both" || subscription == "to")) {
+        this.DEBUG("not re-adding an existing buddy");
+        return;
+      }
+    } else {
+      let s = Stanza.iq(
+        "set",
+        null,
+        null,
+        Stanza.node(
+          "query",
+          Stanza.NS.roster,
+          null,
+          Stanza.node(
+            "item",
+            null,
+            { jid },
+            Stanza.node("group", null, null, aTag.name)
+          )
+        )
+      );
+      this.sendStanza(
+        s,
+        this._handleResult({
+          default: aError => {
+            this.WARN(
+              "Unable to add a roster item due to " + aError + " error."
+            );
+          },
+        })
+      );
+    }
+    this.sendStanza(Stanza.presence({ to: jid, type: "subscribe" }));
+  },
+
+  /* Loads a buddy from the local storage.
+   * Called for each buddy locally stored before connecting
+   * to the server. */
+  loadBuddy(aBuddy, aTag) {
+    let buddy = new this._accountBuddyConstructor(this, aBuddy, aTag);
+    this._buddies.set(buddy.normalizedName, buddy);
+    return buddy;
+  },
+
+  /* Replies to a buddy request in order to accept it or deny it. */
+  replyToBuddyRequest(aReply, aRequest) {
+    if (!this._connection) {
+      return;
+    }
+    let s = Stanza.presence({ to: aRequest.userName, type: aReply });
+    this.sendStanza(s);
+    this.removeBuddyRequest(aRequest);
+  },
+
+  requestBuddyInfo(aJid) {
+    if (!this.connected) {
+      Services.obs.notifyObservers(EmptyEnumerator, "user-info-received", aJid);
+      return;
+    }
+
+    let userName;
+    let tooltipInfo = [];
+    let jid = this._parseJID(aJid);
+    let muc = this._mucs.get(jid.node + "@" + jid.domain);
+    let participant;
+    if (muc) {
+      participant = muc._participants.get(jid.resource);
+      if (participant) {
+        if (participant.accountJid) {
+          userName = participant.accountJid;
+        }
+        if (!muc.left) {
+          let statusType = participant.statusType;
+          let statusText = participant.statusText;
+          tooltipInfo.push(
+            new TooltipInfo(statusType, statusText, Ci.prplITooltipInfo.status)
+          );
+
+          if (participant.buddyIconFilename) {
+            tooltipInfo.push(
+              new TooltipInfo(
+                null,
+                participant.buddyIconFilename,
+                Ci.prplITooltipInfo.icon
+              )
+            );
+          }
+        }
+      }
+    }
+    Services.obs.notifyObservers(
+      new nsSimpleEnumerator(tooltipInfo),
+      "user-info-received",
+      aJid
+    );
+
+    let iq = Stanza.iq(
+      "get",
+      null,
+      aJid,
+      Stanza.node("vCard", Stanza.NS.vcard)
+    );
+    this.sendStanza(iq, aStanza => {
+      let vCardInfo = {};
+      let vCardNode = aStanza.getElement(["vCard"]);
+
+      // In the case of an error response, we just notify the observers with
+      // what info we already have.
+      if (aStanza.attributes.type == "result" && vCardNode) {
+        vCardInfo = this.parseVCard(vCardNode);
+      }
+
+      // The real jid of participant which is of the form local@domain/resource.
+      // We consider the jid is provided by server is more correct than jid is
+      // set by the user.
+      if (userName) {
+        vCardInfo.userName = userName;
+      }
+
+      // vCard fields we want to display in the tooltip.
+      const kTooltipFields = [
+        "userName",
+        "fullName",
+        "nickname",
+        "title",
+        "organization",
+        "email",
+        "birthday",
+        "locality",
+        "country",
+        "telephone",
+      ];
+
+      let tooltipInfo = [];
+      for (let field of kTooltipFields) {
+        if (vCardInfo.hasOwnProperty(field)) {
+          tooltipInfo.push(
+            new TooltipInfo(lazy._("tooltip." + field), vCardInfo[field])
+          );
+        }
+      }
+      if (vCardInfo.photo) {
+        let dataURI = this._getPhotoURI(vCardInfo.photo);
+
+        // Store the photo URI for this participant.
+        if (participant) {
+          participant.buddyIconFilename = dataURI;
+        }
+
+        tooltipInfo.push(
+          new TooltipInfo(null, dataURI, Ci.prplITooltipInfo.icon)
+        );
+      }
+      Services.obs.notifyObservers(
+        new nsSimpleEnumerator(tooltipInfo),
+        "user-info-received",
+        aJid
+      );
+    });
+  },
+
+  // Parses the photo node of a received vCard if exists and returns string of
+  // data URI, otherwise returns null.
+  _getPhotoURI(aPhotoNode) {
+    if (!aPhotoNode) {
+      return null;
+    }
+
+    let type = aPhotoNode.getElement(["TYPE"]);
+    let value = aPhotoNode.getElement(["BINVAL"]);
+    if (!type || !value) {
+      return null;
+    }
+
+    return "data:" + type.innerText + ";base64," + value.innerText;
+  },
+
+  // Parses the vCard into the properties of the returned object.
+  parseVCard(aVCardNode) {
+    // XEP-0054: vcard-temp.
+    let aResult = {};
+    for (let node of aVCardNode.children.filter(
+      child => child.type == "node"
+    )) {
+      let localName = node.localName;
+      let innerText = node.innerText;
+      if (innerText) {
+        if (localName == "FN") {
+          aResult.fullName = innerText;
+        } else if (localName == "NICKNAME") {
+          aResult.nickname = innerText;
+        } else if (localName == "TITLE") {
+          aResult.title = innerText;
+        } else if (localName == "BDAY") {
+          aResult.birthday = innerText;
+        } else if (localName == "JABBERID") {
+          aResult.userName = innerText;
+        }
+      }
+      if (localName == "ORG") {
+        let organization = node.getElement(["ORGNAME"]);
+        if (organization && organization.innerText) {
+          aResult.organization = organization.innerText;
+        }
+      } else if (localName == "EMAIL") {
+        let userID = node.getElement(["USERID"]);
+        if (userID && userID.innerText) {
+          aResult.email = userID.innerText;
+        }
+      } else if (localName == "ADR") {
+        let locality = node.getElement(["LOCALITY"]);
+        if (locality && locality.innerText) {
+          aResult.locality = locality.innerText;
+        }
+
+        let country = node.getElement(["CTRY"]);
+        if (country && country.innerText) {
+          aResult.country = country.innerText;
+        }
+      } else if (localName == "PHOTO") {
+        aResult.photo = node;
+      } else if (localName == "TEL") {
+        let number = node.getElement(["NUMBER"]);
+        if (number && number.innerText) {
+          aResult.telephone = number.innerText;
+        }
+      }
+      // TODO: Parse the other fields of vCard and display it in system messages
+      // in response to /whois.
+    }
+    return aResult;
+  },
+
+  // Returns undefined if not an error stanza, and an object
+  // describing the error otherwise:
+  parseError(aStanza) {
+    if (aStanza.attributes.type != "error") {
+      return undefined;
+    }
+
+    let retval = { stanza: aStanza };
+    let error = aStanza.getElement(["error"]);
+
+    // RFC 6120 Section 8.3.2: Type must be one of
+    // auth -- retry after providing credentials
+    // cancel -- do not retry (the error cannot be remedied)
+    // continue -- proceed (the condition was only a warning)
+    // modify -- retry after changing the data sent
+    // wait -- retry after waiting (the error is temporary).
+    retval.type = error.attributes.type;
+
+    // RFC 6120 Section 8.3.3.
+    const kDefinedConditions = [
+      "bad-request",
+      "conflict",
+      "feature-not-implemented",
+      "forbidden",
+      "gone",
+      "internal-server-error",
+      "item-not-found",
+      "jid-malformed",
+      "not-acceptable",
+      "not-allowed",
+      "not-authorized",
+      "policy-violation",
+      "recipient-unavailable",
+      "redirect",
+      "registration-required",
+      "remote-server-not-found",
+      "remote-server-timeout",
+      "resource-constraint",
+      "service-unavailable",
+      "subscription-required",
+      "undefined-condition",
+      "unexpected-request",
+    ];
+    let condition = kDefinedConditions.find(c => error.getElement([c]));
+    if (!condition) {
+      // RFC 6120 Section 8.3.2.
+      this.WARN(
+        "Nonstandard or missing defined-condition element in error stanza."
+      );
+      condition = "undefined-condition";
+    }
+    retval.condition = condition;
+
+    let errortext = error.getElement(["text"]);
+    if (errortext) {
+      retval.text = errortext.innerText;
+    }
+
+    return retval;
+  },
+
+  // Returns an error-handling callback for use with sendStanza generated
+  // from aHandlers, an object defining the error handlers.
+  // If the stanza passed to the callback is an error stanza, it checks if
+  // aHandlers contains a property with the name of the defined condition
+  // of the error.
+  // * If the property is a function, it is called with the parsed error
+  //   as its argument, bound to aThis (if provided).
+  //   It should return true if the error was handled.
+  // * If the property is a string, it is displayed as a system message
+  //   in the conversation given by aThis.
+  handleErrors(aHandlers, aThis) {
+    return aStanza => {
+      if (!aHandlers) {
+        return false;
+      }
+
+      let error = this.parseError(aStanza);
+      if (!error) {
+        return false;
+      }
+
+      let toCamelCase = aStr => {
+        // Turn defined condition string into a valid camelcase
+        // JS property name.
+        let capitalize = s => s[0].toUpperCase() + s.slice(1);
+        let uncapitalize = s => s[0].toLowerCase() + s.slice(1);
+        return uncapitalize(aStr.split("-").map(capitalize).join(""));
+      };
+      let condition = toCamelCase(error.condition);
+      // Check if we have a handler property for this kind of error or a
+      // default handler.
+      if (!(condition in aHandlers) && !("default" in aHandlers)) {
+        return false;
+      }
+
+      // Try to get the handler for condition, if we cannot get it, try to get
+      // the default handler.
+      let handler = aHandlers[condition];
+      if (!handler) {
+        handler = aHandlers.default;
+      }
+
+      if (typeof handler == "string") {
+        // The string is an error message to be displayed in the conversation.
+        if (!aThis || !aThis.writeMessage) {
+          this.ERROR(
+            "HandleErrors was passed an error message string, but " +
+              "no conversation to display it in:\n" +
+              handler
+          );
+          return true;
+        }
+        aThis.writeMessage(aThis.name, handler, { system: true, error: true });
+        return true;
+      } else if (typeof handler == "function") {
+        // If we're given a function, call this error handler.
+        return handler.call(aThis, error);
+      }
+
+      // If this happens, there's a bug somewhere.
+      this.ERROR(
+        "HandleErrors was passed a handler for '" +
+          condition +
+          "'' which is neither a function nor a string."
+      );
+      return false;
+    };
+  },
+
+  // Returns a callback suitable for use in sendStanza, to handle type==result
+  // responses. aHandlers and aThis are passed on to handleErrors for error
+  // handling.
+  _handleResult(aHandlers, aThis) {
+    return aStanza => {
+      if (aStanza.attributes.type == "result") {
+        return true;
+      }
+      return this.handleErrors(aHandlers, aThis)(aStanza);
+    };
+  },
+
+  /* XMPPSession events */
+
+  /* Called when the XMPP session is started */
+  onConnection() {
+    // Request the roster. The account will be marked as connected when this is
+    // complete.
+    this.reportConnecting(lazy._("connection.downloadingRoster"));
+    let s = Stanza.iq(
+      "get",
+      null,
+      null,
+      Stanza.node("query", Stanza.NS.roster)
+    );
+    this.sendStanza(s, this.onRoster, this);
+
+    // XEP-0030 and XEP-0045 (6): Service Discovery.
+    // Queries Server for Associated Services.
+    let iq = Stanza.iq(
+      "get",
+      null,
+      this._jid.domain,
+      Stanza.node("query", Stanza.NS.disco_items)
+    );
+    this.sendStanza(iq, this.onServiceDiscovery, this);
+
+    // XEP-0030: Service Discovery Information Features.
+    iq = Stanza.iq(
+      "get",
+      null,
+      this._jid.domain,
+      Stanza.node("query", Stanza.NS.disco_info)
+    );
+    this.sendStanza(iq, this.onServiceDiscoveryInfo, this);
+  },
+
+  /* Called whenever a stanza is received */
+  onXmppStanza(aStanza) {},
+
+  /* Called when a iq stanza is received */
+  onIQStanza(aStanza) {
+    let type = aStanza.attributes.type;
+    if (type == "set") {
+      for (let query of aStanza.getChildren("query")) {
+        if (query.uri != Stanza.NS.roster) {
+          continue;
+        }
+
+        // RFC 6121 2.1.6 (Roster push):
+        // A receiving client MUST ignore the stanza unless it has no 'from'
+        // attribute (i.e., implicitly from the bare JID of the user's
+        // account) or it has a 'from' attribute whose value matches the
+        // user's bare JID <user@domainpart>.
+        let from = aStanza.attributes.from;
+        if (from && from != this._jid.node + "@" + this._jid.domain) {
+          this.WARN("Ignoring potentially spoofed roster push.");
+          return;
+        }
+
+        for (let item of query.getChildren("item")) {
+          this._onRosterItem(item, true);
+        }
+        return;
+      }
+    } else if (type == "get") {
+      let id = aStanza.attributes.id;
+      let from = aStanza.attributes.from;
+
+      // XEP-0199: XMPP server-to-client ping (XEP-0199)
+      let ping = aStanza.getElement(["ping"]);
+      if (ping && ping.uri == Stanza.NS.ping) {
+        this.sendStanza(Stanza.iq("result", id, from));
+        return;
+      }
+
+      let query = aStanza.getElement(["query"]);
+      if (query && query.uri == Stanza.NS.version) {
+        // XEP-0092: Software Version.
+        let children = [];
+        children.push(Stanza.node("name", null, null, Services.appinfo.name));
+        children.push(
+          Stanza.node("version", null, null, Services.appinfo.version)
+        );
+        let versionQuery = Stanza.node(
+          "query",
+          Stanza.NS.version,
+          null,
+          children
+        );
+        this.sendStanza(Stanza.iq("result", id, from, versionQuery));
+        return;
+      }
+      if (query && query.uri == Stanza.NS.disco_info) {
+        // XEP-0030: Service Discovery.
+        let children = [];
+        if (aStanza.attributes.node == Stanza.NS.muc_rooms) {
+          // XEP-0045 (6.7): Room query.
+          // TODO: Currently, we return an empty <query/> element, but we
+          // should return non-private rooms.
+        } else {
+          children = SupportedFeatures.map(feature =>
+            Stanza.node("feature", null, { var: feature })
+          );
+          children.unshift(
+            Stanza.node("identity", null, {
+              category: "client",
+              type: "pc",
+              name: Services.appinfo.name,
+            })
+          );
+        }
+        let discoveryQuery = Stanza.node(
+          "query",
+          Stanza.NS.disco_info,
+          null,
+          children
+        );
+        this.sendStanza(Stanza.iq("result", id, from, discoveryQuery));
+        return;
+      }
+    }
+    this.WARN(`Unhandled IQ ${type} stanza.`);
+    if (type == "get" || type == "set") {
+      // RFC 6120 (section 8.2.3): An entity that receives an IQ request of
+      // type "get" or "set" MUST reply with an IQ response of type "result"
+      // or "error".
+      let id = aStanza.attributes.id;
+      let from = aStanza.attributes.from;
+      let condition = Stanza.node("service-unavailable", Stanza.NS.stanzas, {
+        type: "cancel",
+      });
+      let error = Stanza.node("error", null, { type: "cancel" }, condition);
+      this.sendStanza(Stanza.iq("error", id, from, error));
+    }
+  },
+
+  /* Called when a presence stanza is received */
+  onPresenceStanza(aStanza) {
+    let from = aStanza.attributes.from;
+    this.DEBUG("Received presence stanza for " + from);
+
+    let jid = this.normalize(from);
+    let type = aStanza.attributes.type;
+    if (type == "subscribe") {
+      this.addBuddyRequest(
+        jid,
+        this.replyToBuddyRequest.bind(this, "subscribed"),
+        this.replyToBuddyRequest.bind(this, "unsubscribed")
+      );
+    } else if (
+      type == "unsubscribe" ||
+      type == "unsubscribed" ||
+      type == "subscribed"
+    ) {
+      // Nothing useful to do for these presence stanzas, as we will also
+      // receive a roster push containing more or less the same information
+    } else if (this._buddies.has(jid)) {
+      this._buddies.get(jid).onPresenceStanza(aStanza);
+    } else if (this._mucs.has(jid)) {
+      this._mucs.get(jid).onPresenceStanza(aStanza);
+    } else if (jid != this.normalize(this._connection._jid.jid)) {
+      this.WARN("received presence stanza for unknown buddy " + from);
+    } else if (
+      jid == this._jid.node + "@" + this._jid.domain &&
+      this._connection._resource != this._parseJID(from).resource
+    ) {
+      // Ignore presence stanzas for another resource.
+    } else {
+      this.WARN("Unhandled presence stanza.");
+    }
+  },
+
+  // XEP-0030: Discovering services and their features that are supported by
+  // the server.
+  onServiceDiscovery(aStanza) {
+    let query = aStanza.getElement(["query"]);
+    if (
+      aStanza.attributes.type != "result" ||
+      !query ||
+      query.uri != Stanza.NS.disco_items
+    ) {
+      this.LOG("Could not get services for this server: " + this._jid.domain);
+      return true;
+    }
+
+    // Discovering the Features that are Supported by each service.
+    query.getElements(["item"]).forEach(item => {
+      let jid = item.attributes.jid;
+      if (!jid) {
+        return;
+      }
+      let iq = Stanza.iq(
+        "get",
+        null,
+        jid,
+        Stanza.node("query", Stanza.NS.disco_info)
+      );
+      this.sendStanza(iq, receivedStanza => {
+        let query = receivedStanza.getElement(["query"]);
+        let from = receivedStanza.attributes.from;
+        if (
+          aStanza.attributes.type != "result" ||
+          !query ||
+          query.uri != Stanza.NS.disco_info
+        ) {
+          this.LOG("Could not get features for this service: " + from);
+          return true;
+        }
+        let features = query
+          .getElements(["feature"])
+          .map(elt => elt.attributes.var);
+        let identity = query.getElement(["identity"]);
+        if (
+          identity &&
+          identity.attributes.category == "conference" &&
+          identity.attributes.type == "text" &&
+          features.includes(Stanza.NS.muc)
+        ) {
+          // XEP-0045 (6.2): this feature is for a MUC Service.
+          // XEP-0045 (15.2): Service Discovery Category/Type.
+          this._mucService = from;
+        }
+        // TODO: Handle other services that are supported by XMPP through
+        // their features.
+
+        return true;
+      });
+    });
+    return true;
+  },
+
+  // XEP-0030: Discovering Service Information and its features that are
+  // supported by the server.
+  onServiceDiscoveryInfo(aStanza) {
+    let query = aStanza.getElement(["query"]);
+    if (
+      aStanza.attributes.type != "result" ||
+      !query ||
+      query.uri != Stanza.NS.disco_info
+    ) {
+      this.LOG("Could not get features for this server: " + this._jid.domain);
+      return true;
+    }
+
+    let features = query
+      .getElements(["feature"])
+      .map(elt => elt.attributes.var);
+    if (features.includes(Stanza.NS.carbons)) {
+      // XEP-0280: Message Carbons.
+      // Enabling Carbons on server, as it's disabled by default on server.
+      if (Services.prefs.getBoolPref("chat.xmpp.messageCarbons")) {
+        let iqStanza = Stanza.iq(
+          "set",
+          null,
+          null,
+          Stanza.node("enable", Stanza.NS.carbons)
+        );
+        this.sendStanza(iqStanza, aStanza => {
+          let error = this.parseError(aStanza);
+          if (error) {
+            this.WARN(
+              "Unable to enable message carbons due to " +
+                error.condition +
+                " error."
+            );
+            return true;
+          }
+
+          let type = aStanza.attributes.type;
+          if (type != "result") {
+            this.WARN(
+              "Received unexpected stanza with " +
+                type +
+                " type " +
+                "while enabling message carbons."
+            );
+            return true;
+          }
+
+          this.LOG("Message carbons enabled.");
+          this._isCarbonsEnabled = true;
+          return true;
+        });
+      }
+    }
+    // TODO: Handle other features that are supported by the server.
+    return true;
+  },
+
+  requestRoomInfo(aCallback) {
+    if (this._roomInfoCallbacks.has(aCallback)) {
+      return;
+    }
+
+    if (this.isRoomInfoStale && !this._pendingList) {
+      this._roomList = new Map();
+      this._lastListTime = Date.now();
+      this._roomInfoCallback = aCallback;
+      this._pendingList = true;
+
+      // XEP-0045 (6.3): Discovering Rooms.
+      let iq = Stanza.iq(
+        "get",
+        null,
+        this._mucService,
+        Stanza.node("query", Stanza.NS.disco_items)
+      );
+      this.sendStanza(iq, this.onRoomDiscovery, this);
+    } else {
+      let rooms = [...this._roomList.keys()];
+      aCallback.onRoomInfoAvailable(rooms, !this._pendingList);
+    }
+
+    if (this._pendingList) {
+      this._roomInfoCallbacks.add(aCallback);
+    }
+  },
+
+  onRoomDiscovery(aStanza) {
+    let query = aStanza.getElement(["query"]);
+    if (!query || query.uri != Stanza.NS.disco_items) {
+      this.LOG("Could not get rooms for this server: " + this._jid.domain);
+      return;
+    }
+
+    // XEP-0059: Result Set Management.
+    let set = query.getElement(["set"]);
+    let last = set ? set.getElement(["last"]) : null;
+    if (last) {
+      let iq = Stanza.iq(
+        "get",
+        null,
+        this._mucService,
+        Stanza.node("query", Stanza.NS.disco_items)
+      );
+      this.sendStanza(iq, this.onRoomDiscovery, this);
+    } else {
+      this._pendingList = false;
+    }
+
+    let rooms = [];
+    query.getElements(["item"]).forEach(item => {
+      let jid = this._parseJID(item.attributes.jid);
+      if (!jid) {
+        return;
+      }
+
+      let name = item.attributes.name;
+      if (!name) {
+        name = jid.node ? jid.node : jid.jid;
+      }
+
+      this._roomList.set(name, jid.jid);
+      rooms.push(name);
+    });
+
+    this._roomInfoCallback.onRoomInfoAvailable(rooms, !this._pendingList);
+  },
+
+  getRoomInfo(aName) {
+    return new XMPPRoomInfo(aName, this);
+  },
+
+  // Returns null if not an invitation stanza, and an object
+  // describing the invitation otherwise.
+  parseInvitation(aStanza) {
+    let x = aStanza.getElement(["x"]);
+    if (!x) {
+      return null;
+    }
+    let retVal = {
+      shouldDecline: false,
+    };
+
+    // XEP-0045. Direct Invitation (7.8.1)
+    // Described in XEP-0249.
+    // jid (chatroom) is required.
+    // Password, reason, continue and thread are optional.
+    if (x.uri == Stanza.NS.conference) {
+      if (!x.attributes.jid) {
+        this.WARN("Received an invitation with missing MUC jid.");
+        return null;
+      }
+      retVal.mucJid = this.normalize(x.attributes.jid);
+      retVal.from = this.normalize(aStanza.attributes.from);
+      retVal.password = x.attributes.password;
+      retVal.reason = x.attributes.reason;
+      retVal.continue = x.attributes.continue;
+      retVal.thread = x.attributes.thread;
+      return retVal;
+    }
+
+    // XEP-0045. Mediated Invitation (7.8.2)
+    // Sent by the chatroom on behalf of someone in the chatroom.
+    // jid (chatroom) and from (inviter) are required.
+    // password and reason are optional.
+    if (x.uri == Stanza.NS.muc_user) {
+      let invite = x.getElement(["invite"]);
+      if (!invite || !invite.attributes.from) {
+        this.WARN("Received an invitation with missing MUC invite or from.");
+        return null;
+      }
+      retVal.mucJid = this.normalize(aStanza.attributes.from);
+      retVal.from = this.normalize(invite.attributes.from);
+      retVal.shouldDecline = true;
+      let continueElement = invite.getElement(["continue"]);
+      retVal.continue = !!continueElement;
+      if (continueElement) {
+        retVal.thread = continueElement.attributes.thread;
+      }
+      if (x.getElement(["password"])) {
+        retVal.password = x.getElement(["password"]).innerText;
+      }
+      if (invite.getElement(["reason"])) {
+        retVal.reason = invite.getElement(["reason"]).innerText;
+      }
+      return retVal;
+    }
+
+    return null;
+  },
+
+  /* Called when a message stanza is received */
+  onMessageStanza(aStanza) {
+    // XEP-0280: Message Carbons.
+    // Sending and Receiving Messages.
+    // Indicates that the forwarded message was sent or received.
+    let isSent = false;
+    let carbonStanza =
+      aStanza.getElement(["sent"]) || aStanza.getElement(["received"]);
+    if (carbonStanza) {
+      if (carbonStanza.uri != Stanza.NS.carbons) {
+        this.WARN(
+          "Received a forwarded message which does not '" +
+            Stanza.NS.carbons +
+            "' namespace."
+        );
+        return;
+      }
+
+      isSent = carbonStanza.localName == "sent";
+      carbonStanza = carbonStanza.getElement(["forwarded", "message"]);
+      if (this._isCarbonsEnabled) {
+        aStanza = carbonStanza;
+      } else {
+        this.WARN(
+          "Received an unexpected forwarded message while message " +
+            "carbons are not enabled."
+        );
+        return;
+      }
+    }
+
+    // For forwarded sent messages, we need to use "to" attribute to
+    // get the right conversation as from in this case is this account.
+    let convJid = isSent ? aStanza.attributes.to : aStanza.attributes.from;
+
+    let normConvJid = this.normalize(convJid);
+    let isMuc = this._mucs.has(normConvJid);
+
+    let type = aStanza.attributes.type;
+    let x = aStanza.getElement(["x"]);
+    let body;
+    let b = aStanza.getElement(["body"]);
+    if (b) {
+      // If there's a <body> child we have more than just typing notifications.
+      // Prefer HTML (in <html><body>) and use plain text (<body>) as fallback.
+      let htmlBody = aStanza.getElement(["html", "body"]);
+      if (htmlBody) {
+        body = htmlBody.innerXML;
+      } else {
+        // Even if the message is in plain text, the prplIMessage
+        // should contain a string that's correctly escaped for
+        // insertion in an HTML document.
+        body = lazy.TXTToHTML(b.innerText);
+      }
+    }
+
+    let subject = aStanza.getElement(["subject"]);
+    // Ignore subject when !isMuc. We're being permissive about subject changes
+    // in the comment below, so we need to be careful about where that makes
+    // sense. Psi+'s OTR plugin includes a subject and body in its message
+    // stanzas.
+    if (subject && isMuc) {
+      // XEP-0045 (7.2.16): Check for a subject element in the stanza and update
+      // the topic if it exists.
+      // We are breaking the spec because only a message that contains a
+      // <subject/> but no <body/> element shall be considered a subject change
+      // for MUC, but we ignore that to be compatible with ejabberd versions
+      // before 15.06.
+      let muc = this._mucs.get(normConvJid);
+      let nick = this._parseJID(convJid).resource;
+      // TODO There can be multiple subject elements with different xml:lang
+      // attributes.
+      muc.setTopic(subject.innerText, nick);
+      return;
+    }
+
+    let invitation = this.parseInvitation(aStanza);
+    if (invitation) {
+      let messageID;
+      if (invitation.reason) {
+        messageID = "conversation.muc.invitationWithReason2";
+      } else {
+        messageID = "conversation.muc.invitationWithoutReason";
+      }
+      if (invitation.password) {
+        messageID += ".password";
+      }
+      let params = [
+        invitation.from,
+        invitation.mucJid,
+        invitation.password,
+        invitation.reason,
+      ].filter(s => s);
+      let message = lazy._(messageID, ...params);
+
+      this.addChatRequest(
+        invitation.mucJid,
+        () => {
+          let chatRoomFields = this.getChatRoomDefaultFieldValues(
+            invitation.mucJid
+          );
+          if (invitation.password) {
+            chatRoomFields.setValue("password", invitation.password);
+          }
+          let muc = this.joinChat(chatRoomFields);
+          muc.writeMessage(muc.name, message, { system: true });
+        },
+        (request, tryToDeny) => {
+          // Only mediated invitations (XEP-0045) can explicitly decline.
+          if (invitation.shouldDecline && tryToDeny) {
+            let decline = Stanza.node(
+              "decline",
+              null,
+              { from: invitation.from },
+              null
+            );
+            let x = Stanza.node("x", Stanza.NS.muc_user, null, decline);
+            let s = Stanza.node("message", null, { to: invitation.mucJid }, x);
+            this.sendStanza(s);
+          }
+          // Always show invite reason or password, even if the invite wasn't
+          // automatically declined based on the setting.
+          if (!request || invitation.reason || invitation.password) {
+            let conv = this.createConversation(invitation.from);
+            if (conv) {
+              conv.writeMessage(invitation.from, message, { system: true });
+            }
+          }
+        }
+      );
+    }
+
+    if (body) {
+      let date = _getDelay(aStanza);
+      if (
+        type == "groupchat" ||
+        (type == "error" && isMuc && !this._conv.has(convJid))
+      ) {
+        if (!isMuc) {
+          this.WARN(
+            "Received a groupchat message for unknown MUC " + normConvJid
+          );
+          return;
+        }
+        let muc = this._mucs.get(normConvJid);
+        muc.incomingMessage(body, aStanza, date);
+        return;
+      }
+
+      let conv = this.createConversation(convJid);
+      if (!conv) {
+        return;
+      }
+
+      if (isSent) {
+        _displaySentMsg(conv, body, date);
+        return;
+      }
+      conv.incomingMessage(body, aStanza, date);
+    } else if (type == "error") {
+      let conv = this.createConversation(convJid);
+      if (conv) {
+        conv.incomingMessage(null, aStanza);
+      }
+    } else if (x && x.uri == Stanza.NS.muc_user) {
+      let muc = this._mucs.get(normConvJid);
+      if (!muc) {
+        this.WARN(
+          "Received a groupchat message for unknown MUC " + normConvJid
+        );
+        return;
+      }
+      muc.onMessageStanza(aStanza);
+      return;
+    }
+
+    // If this is a sent message carbon, the user is typing on another client.
+    if (isSent) {
+      return;
+    }
+
+    // Don't create a conversation to only display the typing notifications.
+    if (!this._conv.has(normConvJid) && !this._conv.has(convJid)) {
+      return;
+    }
+
+    // Ignore errors while delivering typing notifications.
+    if (type == "error") {
+      return;
+    }
+
+    let typingState = Ci.prplIConvIM.NOT_TYPING;
+    let state;
+    let s = aStanza.getChildrenByNS(Stanza.NS.chatstates);
+    if (s.length > 0) {
+      state = s[0].localName;
+    }
+    if (state) {
+      this.DEBUG(state);
+      if (state == "composing") {
+        typingState = Ci.prplIConvIM.TYPING;
+      } else if (state == "paused") {
+        typingState = Ci.prplIConvIM.TYPED;
+      }
+    }
+    let convName = normConvJid;
+
+    // If the bare JID is a MUC that we have joined, use the full JID as this
+    // is a private message to a MUC participant.
+    if (isMuc) {
+      convName = convJid;
+    }
+
+    let conv = this._conv.get(convName);
+    if (!conv) {
+      return;
+    }
+    conv.updateTyping(typingState, conv.shortName);
+    conv.supportChatStateNotifications = !!state;
+  },
+
+  /** Called when there is an error in the XMPP session */
+  onError(aError, aException) {
+    if (aError === null || aError === undefined) {
+      aError = Ci.prplIAccount.ERROR_OTHER_ERROR;
+    }
+    this._disconnect(aError, aException.toString());
+  },
+
+  onVCard(aStanza) {
+    let jid = this._pendingVCardRequests.shift();
+    this._requestNextVCard();
+    if (!this._buddies.has(jid) && !this._mucs.has(jid)) {
+      this.WARN("Received a vCard for unknown buddy " + jid);
+      return;
+    }
+
+    let vCard = aStanza.getElement(["vCard"]);
+    let error = this.parseError(aStanza);
+    if (
+      (error &&
+        (error.condition == "item-not-found" ||
+          error.condition == "service-unavailable")) ||
+      !vCard ||
+      !vCard.children.length
+    ) {
+      this.LOG("No vCard exists (or the user does not exist) for " + jid);
+      return;
+    } else if (error) {
+      this.WARN("Received unexpected vCard error " + error.condition);
+      return;
+    }
+
+    let stanzaJid = this.normalize(aStanza.attributes.from);
+    if (jid && jid != stanzaJid) {
+      this.ERROR(
+        "Received vCard for a different jid (" +
+          stanzaJid +
+          ") " +
+          "than the requested " +
+          jid
+      );
+    }
+
+    let foundFormattedName = false;
+    let vCardInfo = this.parseVCard(vCard);
+    if (this._mucs.has(jid)) {
+      const conv = this._mucs.get(jid);
+      if (vCardInfo.photo) {
+        conv._saveIcon(vCardInfo.photo);
+      }
+      return;
+    }
+    let buddy = this._buddies.get(jid);
+    if (vCardInfo.fullName) {
+      buddy.vCardFormattedName = vCardInfo.fullName;
+      foundFormattedName = true;
+    }
+    if (vCardInfo.photo) {
+      buddy._saveIcon(vCardInfo.photo);
+    }
+    if (!foundFormattedName && buddy._vCardFormattedName) {
+      buddy.vCardFormattedName = "";
+    }
+    buddy._vCardReceived = true;
+  },
+
+  /**
+   * Save the icon for a resource to the local file system.
+   *
+   * @param photo - The vcard photo node representing the icon.
+   * @param {prplIChatBuddy|prplIConversation} resource - Resource the icon is for.
+   * @returns {Promise<string>} Resolves with the file:// URI to the local icon file.
+   */
+  _saveResourceIcon(photo, resource) {
+    // Some servers seem to send a photo node without a type declared.
+    let type = photo.getElement(["TYPE"]);
+    if (!type) {
+      return Promise.reject(new Error("Missing image type"));
+    }
+    type = type.innerText;
+    const kExt = {
+      "image/gif": "gif",
+      "image/jpeg": "jpg",
+      "image/png": "png",
+    };
+    if (!kExt.hasOwnProperty(type)) {
+      return Promise.reject(new Error("Unknown image type"));
+    }
+
+    let content = "",
+      data = "";
+    // Strip all characters not allowed in base64 before parsing.
+    let parseBase64 = aBase => atob(aBase.replace(/[^A-Za-z0-9\+\/\=]/g, ""));
+    for (let line of photo.getElement(["BINVAL"]).innerText.split("\n")) {
+      data += line;
+      // Mozilla's atob() doesn't handle padding with "=" or "=="
+      // unless it's at the end of the string, so we have to work around that.
+      if (line.endsWith("=")) {
+        content += parseBase64(data);
+        data = "";
+      }
+    }
+    content += parseBase64(data);
+
+    // Store a sha1 hash of the photo we have just received.
+    let ch = Cc["@mozilla.org/security/hash;1"].createInstance(
+      Ci.nsICryptoHash
+    );
+    ch.init(ch.SHA1);
+    let dataArray = Object.keys(content).map(i => content.charCodeAt(i));
+    ch.update(dataArray, dataArray.length);
+    let hash = ch.finish(false);
+    function toHexString(charCode) {
+      return charCode.toString(16).padStart(2, "0");
+    }
+    resource._photoHash = Object.keys(hash)
+      .map(i => toHexString(hash.charCodeAt(i)))
+      .join("");
+
+    let istream = Cc["@mozilla.org/io/string-input-stream;1"].createInstance(
+      Ci.nsIStringInputStream
+    );
+    istream.setData(content, content.length);
+
+    let fileName = resource._photoHash + "." + kExt[type];
+    let file = lazy.FileUtils.getFile("ProfD", [
+      "icons",
+      this.protocol.normalizedName,
+      this.normalizedName,
+      fileName,
+    ]);
+    let ostream = lazy.FileUtils.openSafeFileOutputStream(file);
+    return new Promise(resolve => {
+      lazy.NetUtil.asyncCopy(istream, ostream, rc => {
+        if (Components.isSuccessCode(rc)) {
+          resolve(Services.io.newFileURI(file).spec);
+        }
+      });
+    });
+  },
+
+  _requestNextVCard() {
+    if (!this._pendingVCardRequests.length) {
+      return;
+    }
+    let s = Stanza.iq(
+      "get",
+      null,
+      this._pendingVCardRequests[0],
+      Stanza.node("vCard", Stanza.NS.vcard)
+    );
+    this.sendStanza(s, this.onVCard, this);
+  },
+
+  _addVCardRequest(aJID) {
+    let requestPending = !!this._pendingVCardRequests.length;
+    this._pendingVCardRequests.push(aJID);
+    if (!requestPending) {
+      this._requestNextVCard();
+    }
+  },
+
+  // XEP-0029 (Section 2) and RFC 6122 (Section 2): The node and domain are
+  // lowercase, while resources are case sensitive and can contain spaces.
+  normalizeFullJid(aJID) {
+    return this._parseJID(aJID.trim()).jid;
+  },
+
+  // Standard normalization for XMPP removes the resource part of jids.
+  normalize(aJID) {
+    return aJID
+      .trim()
+      .split("/", 1)[0] // up to first slash
+      .toLowerCase();
+  },
+
+  // RFC 6122 (Section 2): [ localpart "@" ] domainpart [ "/" resourcepart ] is
+  // the form of jid.
+  // Localpart is parsed as node and optional.
+  // Domainpart is parsed as domain and required.
+  // resourcepart is parsed as resource and optional.
+  _parseJID(aJid) {
+    let match = /^(?:([^"&'/:<>@]+)@)?([^@/<>'\"]+)(?:\/(.*))?$/.exec(
+      aJid.trim()
+    );
+    if (!match) {
+      return null;
+    }
+
+    let result = {
+      node: match[1],
+      domain: match[2].toLowerCase(),
+      resource: match[3],
+    };
+    return this._setJID(result.domain, result.node, result.resource);
+  },
+
+  // Constructs jid as an object from domain, node and resource parts.
+  // The object has properties (node, domain, resource and jid).
+  // aDomain is required, but aNode and aResource are optional.
+  _setJID(aDomain, aNode = null, aResource = null) {
+    if (!aDomain) {
+      throw new Error("aDomain must have a value");
+    }
+
+    let result = {
+      node: aNode,
+      domain: aDomain.toLowerCase(),
+      resource: aResource,
+    };
+    let jid = result.domain;
+    if (result.node) {
+      result.node = result.node.toLowerCase();
+      jid = result.node + "@" + jid;
+    }
+    if (result.resource) {
+      jid += "/" + result.resource;
+    }
+    result.jid = jid;
+    return result;
+  },
+
+  _onRosterItem(aItem, aNotifyOfUpdates) {
+    let jid = aItem.attributes.jid;
+    if (!jid) {
+      this.WARN("Received a roster item without jid: " + aItem.getXML());
+      return "";
+    }
+    jid = this.normalize(jid);
+
+    let subscription = "";
+    if ("subscription" in aItem.attributes) {
+      subscription = aItem.attributes.subscription;
+    }
+    if (subscription == "remove") {
+      this._forgetRosterItem(jid);
+      return "";
+    }
+
+    let buddy;
+    if (this._buddies.has(jid)) {
+      buddy = this._buddies.get(jid);
+      let groups = aItem.getChildren("group");
+      if (groups.length) {
+        // If the server specified at least one group, ensure the group we use
+        // as the account buddy's tag is still a group on the server...
+        let tagName = buddy.tag.name;
+        if (!groups.some(g => g.innerText == tagName)) {
+          // ... otherwise we need to move our account buddy to a new group.
+          tagName = groups[0].innerText;
+          if (tagName) {
+            // Should always be true, but check just in case...
+            let oldTag = buddy.tag;
+            buddy._tag = IMServices.tags.createTag(tagName);
+            IMServices.contacts.accountBuddyMoved(buddy, oldTag, buddy._tag);
+          }
+        }
+      }
+    } else {
+      let tag;
+      for (let group of aItem.getChildren("group")) {
+        let name = group.innerText;
+        if (name) {
+          tag = IMServices.tags.createTag(name);
+          break; // TODO we should create an accountBuddy per group,
+          // but this._buddies would probably not like that...
+        }
+      }
+      buddy = new this._accountBuddyConstructor(
+        this,
+        null,
+        tag || IMServices.tags.defaultTag,
+        jid
+      );
+    }
+
+    // We request the vCard only if we haven't received it yet and are
+    // subscribed to presence for that contact.
+    if (
+      (subscription == "both" || subscription == "to") &&
+      !buddy._vCardReceived
+    ) {
+      this._addVCardRequest(jid);
+    }
+
+    let alias = "name" in aItem.attributes ? aItem.attributes.name : "";
+    if (alias) {
+      if (aNotifyOfUpdates && this._buddies.has(jid)) {
+        buddy.rosterAlias = alias;
+      } else {
+        buddy._rosterAlias = alias;
+      }
+    } else if (buddy._rosterAlias) {
+      buddy.rosterAlias = "";
+    }
+
+    if (subscription) {
+      buddy.subscription = subscription;
+    }
+    if (!this._buddies.has(jid)) {
+      this._buddies.set(jid, buddy);
+      IMServices.contacts.accountBuddyAdded(buddy);
+    } else if (aNotifyOfUpdates) {
+      buddy._notifyObservers("status-detail-changed");
+    }
+
+    // Keep the xml nodes of the item so that we don't have to
+    // recreate them when changing something (eg. the alias) in it.
+    buddy._rosterItem = aItem;
+
+    return jid;
+  },
+  _forgetRosterItem(aJID) {
+    IMServices.contacts.accountBuddyRemoved(this._buddies.get(aJID));
+    this._buddies.delete(aJID);
+  },
+
+  /* When the roster is received */
+  onRoster(aStanza) {
+    // For the first element that is a roster stanza.
+    for (let qe of aStanza.getChildren("query")) {
+      if (qe.uri != Stanza.NS.roster) {
+        continue;
+      }
+
+      // Find all the roster items in the new message.
+      let newRoster = new Set();
+      for (let item of qe.getChildren("item")) {
+        let jid = this._onRosterItem(item);
+        if (jid) {
+          newRoster.add(jid);
+        }
+      }
+      // If an item was in the old roster, but not in the new, forget it.
+      for (let jid of this._buddies.keys()) {
+        if (!newRoster.has(jid)) {
+          this._forgetRosterItem(jid);
+        }
+      }
+      break;
+    }
+
+    this._sendPresence();
+    this._buddies.forEach(b => {
+      if (b.subscription == "both" || b.subscription == "to") {
+        b.setStatus(Ci.imIStatusInfo.STATUS_OFFLINE, "");
+      }
+    });
+    this.reportConnected();
+    this._sendVCard();
+  },
+
+  /* Public methods */
+
+  sendStanza(aStanza, aCallback, aThis, aLogString) {
+    return this._connection.sendStanza(aStanza, aCallback, aThis, aLogString);
+  },
+
+  // Variations of the XMPP protocol can change these default constructors:
+  _conversationConstructor: XMPPConversation,
+  _MUCConversationConstructor: XMPPMUCConversation,
+  _accountBuddyConstructor: XMPPAccountBuddy,
+
+  /* Create a new conversation */
+  createConversation(aName) {
+    let convName = this.normalize(aName);
+
+    // Checks if conversation is with a participant of a MUC we are in. We do
+    // not want to strip the resource as it is of the form room@domain/nick.
+    let isMucParticipant = this._mucs.has(convName);
+    if (isMucParticipant) {
+      convName = this.normalizeFullJid(aName);
+    }
+
+    // Checking that the aName can be parsed and is not broken.
+    let jid = this._parseJID(convName);
+    if (
+      !jid ||
+      !jid.domain ||
+      (isMucParticipant && (!jid.node || !jid.resource))
+    ) {
+      this.ERROR("Could not create conversation as jid is broken: " + convName);
+      throw new Error("Invalid JID");
+    }
+
+    if (!this._conv.has(convName)) {
+      this._conv.set(
+        convName,
+        new this._conversationConstructor(this, convName, isMucParticipant)
+      );
+    }
+
+    return this._conv.get(convName);
+  },
+
+  /* Remove an existing conversation */
+  removeConversation(aNormalizedName) {
+    if (this._conv.has(aNormalizedName)) {
+      this._conv.delete(aNormalizedName);
+    } else if (this._mucs.has(aNormalizedName)) {
+      this._mucs.delete(aNormalizedName);
+    }
+  },
+
+  /* Private methods */
+
+  /**
+   * Disconnect from the server
+   *
+   * @param {number} aError - The error reason, passed to reportDisconnecting.
+   * @param {string} aErrorMessage - The error message, passed to reportDisconnecting.
+   * @param {boolean} aQuiet - True to avoid sending status change notifications
+   *   during the uninitialization of the account.
+   */
+  _disconnect(
+    aError = Ci.prplIAccount.NO_ERROR,
+    aErrorMessage = "",
+    aQuiet = false
+  ) {
+    if (!this._connection) {
+      return;
+    }
+
+    this.reportDisconnecting(aError, aErrorMessage);
+
+    this._buddies.forEach(b => {
+      if (!aQuiet) {
+        b.setStatus(Ci.imIStatusInfo.STATUS_UNKNOWN, "");
+      }
+      b.onAccountDisconnected();
+    });
+
+    this._mucs.forEach(muc => {
+      muc.joining = false; // In case we never finished joining.
+      muc.left = true;
+    });
+
+    this._connection.disconnect();
+    delete this._connection;
+
+    // We won't receive "user-icon-changed" notifications while the
+    // account isn't connected, so clear the cache to avoid keeping an
+    // obsolete icon.
+    delete this._cachedUserIcon;
+    // Also clear the cached user vCard, as we will want to redownload it
+    // after reconnecting.
+    delete this._userVCard;
+
+    // Clear vCard requests.
+    this._pendingVCardRequests = [];
+
+    this.reportDisconnected();
+  },
+
+  /* Set the user status on the server */
+  _sendPresence() {
+    delete this._shouldSendPresenceForIdlenessChange;
+
+    if (!this._connection) {
+      return;
+    }
+
+    let si = this.imAccount.statusInfo;
+    let statusType = si.statusType;
+    let show = "";
+    if (statusType == Ci.imIStatusInfo.STATUS_UNAVAILABLE) {
+      show = "dnd";
+    } else if (
+      statusType == Ci.imIStatusInfo.STATUS_AWAY ||
+      statusType == Ci.imIStatusInfo.STATUS_IDLE
+    ) {
+      show = "away";
+    }
+    let children = [];
+    if (show) {
+      children.push(Stanza.node("show", null, null, show));
+    }
+    let statusText = si.statusText;
+    if (statusText) {
+      children.push(Stanza.node("status", null, null, statusText));
+    }
+    if (this._idleSince) {
+      let time = Math.floor(Date.now() / 1000) - this._idleSince;
+      children.push(Stanza.node("query", Stanza.NS.last, { seconds: time }));
+    }
+    if (this.prefs.prefHasUserValue("priority")) {
+      let priority = Math.max(-128, Math.min(127, this.getInt("priority")));
+      if (priority) {
+        children.push(Stanza.node("priority", null, null, priority.toString()));
+      }
+    }
+    this.sendStanza(
+      Stanza.presence({ "xml:lang": "en" }, children),
+      aStanza => {
+        // As we are implicitly subscribed to our own presence (rfc6121#4), we
+        // will receive the presence stanza mirrored back to us. We don't need
+        // to do anything with this response.
+        return true;
+      }
+    );
+  },
+
+  _downloadingUserVCard: false,
+  _downloadUserVCard() {
+    // If a download is already in progress, don't start another one.
+    if (this._downloadingUserVCard) {
+      return;
+    }
+    this._downloadingUserVCard = true;
+    let s = Stanza.iq("get", null, null, Stanza.node("vCard", Stanza.NS.vcard));
+    this.sendStanza(s, this.onUserVCard, this);
+  },
+
+  onUserVCard(aStanza) {
+    delete this._downloadingUserVCard;
+    let userVCard = aStanza.getElement(["vCard"]) || null;
+    if (userVCard) {
+      // Strip any server-specific namespace off the incoming vcard
+      // before storing it.
+      this._userVCard = Stanza.node(
+        "vCard",
+        Stanza.NS.vcard,
+        null,
+        userVCard.children
+      );
+    }
+
+    // If a user icon exists in the vCard we received from the server,
+    // we need to ensure the line breaks in its binval are exactly the
+    // same as those we would include if we sent the icon, and that
+    // there isn't any other whitespace.
+    if (this._userVCard) {
+      let binval = this._userVCard.getElement(["PHOTO", "BINVAL"]);
+      if (binval && binval.children.length) {
+        binval = binval.children[0];
+        binval.text = binval.text
+          .replace(/[^A-Za-z0-9\+\/\=]/g, "")
+          .replace(/.{74}/g, "$&\n");
+      }
+    } else {
+      // Downloading the vCard failed.
+      if (
+        this.handleErrors({
+          itemNotFound: () => false, // OK, no vCard exists yet.
+          default: () => true,
+        })(aStanza)
+      ) {
+        this.WARN(
+          "Unexpected error retrieving the user's vcard, " +
+            "so we won't attempt to set it either."
+        );
+        return;
+      }
+      // Set this so that we don't get into an infinite loop trying to download
+      // the vcard again. The check in sendVCard is for hasOwnProperty.
+      this._userVCard = null;
+    }
+    this._sendVCard();
+  },
+
+  _cachingUserIcon: false,
+  _cacheUserIcon() {
+    if (this._cachingUserIcon) {
+      return;
+    }
+
+    let userIcon = this.imAccount.statusInfo.getUserIcon();
+    if (!userIcon) {
+      this._cachedUserIcon = null;
+      this._sendVCard();
+      return;
+    }
+
+    this._cachingUserIcon = true;
+    let channel = lazy.NetUtil.newChannel({
+      uri: userIcon,
+      loadingPrincipal: Services.scriptSecurityManager.getSystemPrincipal(),
+      securityFlags:
+        Ci.nsILoadInfo.SEC_REQUIRE_SAME_ORIGIN_INHERITS_SEC_CONTEXT,
+      contentPolicyType: Ci.nsIContentPolicy.TYPE_IMAGE,
+    });
+    lazy.NetUtil.asyncFetch(channel, (inputStream, resultCode) => {
+      if (!Components.isSuccessCode(resultCode)) {
+        return;
+      }
+      try {
+        let type = channel.contentType;
+        let buffer = lazy.NetUtil.readInputStreamToString(
+          inputStream,
+          inputStream.available()
+        );
+        let readImage = lazy.imgTools.decodeImageFromBuffer(
+          buffer,
+          buffer.length,
+          type
+        );
+        let scaledImage;
+        if (readImage.width <= 96 && readImage.height <= 96) {
+          scaledImage = lazy.imgTools.encodeImage(readImage, type);
+        } else {
+          if (type != "image/jpeg") {
+            type = "image/png";
+          }
+          scaledImage = lazy.imgTools.encodeScaledImage(
+            readImage,
+            type,
+            64,
+            64
+          );
+        }
+
+        let bstream = Cc["@mozilla.org/binaryinputstream;1"].createInstance(
+          Ci.nsIBinaryInputStream
+        );
+        bstream.setInputStream(scaledImage);
+
+        let data = bstream.readBytes(bstream.available());
+        this._cachedUserIcon = {
+          type,
+          binval: btoa(data).replace(/.{74}/g, "$&\n"),
+        };
+      } catch (e) {
+        console.error(e);
+        this._cachedUserIcon = null;
+      }
+      delete this._cachingUserIcon;
+      this._sendVCard();
+    });
+  },
+  _sendVCard() {
+    if (!this._connection) {
+      return;
+    }
+
+    // We have to download the user's existing vCard before updating it.
+    // This lets us preserve the fields that we don't change or don't know.
+    // Some servers may reject a new vCard if we don't do this first.
+    if (!this.hasOwnProperty("_userVCard")) {
+      // The download of the vCard is asynchronous and will call _sendVCard back
+      // when the user's vCard has been received.
+      this._downloadUserVCard();
+      return;
+    }
+
+    // Read the local user icon asynchronously from the disk.
+    // _cacheUserIcon will call _sendVCard back once the icon is ready.
+    if (!this.hasOwnProperty("_cachedUserIcon")) {
+      this._cacheUserIcon();
+      return;
+    }
+
+    // If the user currently doesn't have any vCard on the server or
+    // the download failed, an empty new one.
+    if (!this._userVCard) {
+      this._userVCard = Stanza.node("vCard", Stanza.NS.vcard);
+    }
+
+    // Keep a serialized copy of the existing user vCard so that we
+    // can avoid resending identical data to the server.
+    let existingVCard = this._userVCard.getXML();
+
+    let fn = this._userVCard.getElement(["FN"]);
+    let displayName = this.imAccount.statusInfo.displayName;
+    if (displayName) {
+      // If a display name is set locally, update or add an FN field to the vCard.
+      if (!fn) {
+        this._userVCard.addChild(
+          Stanza.node("FN", Stanza.NS.vcard, null, displayName)
+        );
+      } else if (fn.children.length) {
+        fn.children[0].text = displayName;
+      } else {
+        fn.addText(displayName);
+      }
+    } else if ("_forceUserDisplayNameUpdate" in this) {
+      // We remove a display name stored on the server without replacing
+      // it with a new value only if this _sendVCard call is the result of
+      // a user action. This is to avoid removing data from the server each
+      // time the user connects from a new profile.
+      this._userVCard.children = this._userVCard.children.filter(
+        n => n.qName != "FN"
+      );
+    }
+    delete this._forceUserDisplayNameUpdate;
+
+    if (this._cachedUserIcon) {
+      // If we have a local user icon, update or add it in the PHOTO field.
+      let photoChildren = [
+        Stanza.node("TYPE", Stanza.NS.vcard, null, this._cachedUserIcon.type),
+        Stanza.node(
+          "BINVAL",
+          Stanza.NS.vcard,
+          null,
+          this._cachedUserIcon.binval
+        ),
+      ];
+      let photo = this._userVCard.getElement(["PHOTO"]);
+      if (photo) {
+        photo.children = photoChildren;
+      } else {
+        this._userVCard.addChild(
+          Stanza.node("PHOTO", Stanza.NS.vcard, null, photoChildren)
+        );
+      }
+    } else if ("_forceUserIconUpdate" in this) {
+      // Like for the display name, we remove a photo without
+      // replacing it only if the call is caused by a user action.
+      this._userVCard.children = this._userVCard.children.filter(
+        n => n.qName != "PHOTO"
+      );
+    }
+    delete this._forceUserIconUpdate;
+
+    // Send the vCard only if it has really changed.
+    // We handle the result response from the server (it does not require
+    // any further action).
+    if (this._userVCard.getXML() != existingVCard) {
+      this.sendStanza(
+        Stanza.iq("set", null, null, this._userVCard),
+        this._handleResult()
+      );
+    } else {
+      this.LOG(
+        "Not sending the vCard because the server stored vCard is identical."
+      );
+    }
+  },
+};
diff --git a/comm/chat/protocols/xmpp/xmpp-commands.sys.mjs b/comm/chat/protocols/xmpp/xmpp-commands.sys.mjs
new file mode 100644
index 0000000000..fc02f3bc0e
--- /dev/null
+++ b/comm/chat/protocols/xmpp/xmpp-commands.sys.mjs
@@ -0,0 +1,347 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import { l10nHelper } from "resource:///modules/imXPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+XPCOMUtils.defineLazyGetter(lazy, "_", () =>
+  l10nHelper("chrome://chat/locale/xmpp.properties")
+);
+
+// Get conversation object.
+function getConv(aConv) {
+  return aConv.wrappedJSObject;
+}
+
+// Get account object.
+function getAccount(aConv) {
+  return getConv(aConv)._account;
+}
+
+function getMUC(aConv) {
+  let conv = getConv(aConv);
+  if (conv.left) {
+    conv.writeMessage(
+      conv.name,
+      lazy._("conversation.error.commandFailedNotInRoom"),
+      { system: true }
+    );
+    return null;
+  }
+  return conv;
+}
+
+// Trims the string and splits it in two parts on the first space
+// if there is one. Returns the non-empty parts in an array.
+function splitInput(aString) {
+  let params = aString.trim();
+  if (!params) {
+    return [];
+  }
+
+  let splitParams = [];
+  let offset = params.indexOf(" ");
+  if (offset != -1) {
+    splitParams.push(params.slice(0, offset));
+    splitParams.push(params.slice(offset + 1).trimLeft());
+  } else {
+    splitParams.push(params);
+  }
+  return splitParams;
+}
+
+// Trims the string and splits it in two parts (The first part is a nickname
+// and the second part is the rest of string) based on nicknames of current
+// participants. Returns the non-empty parts in an array.
+function splitByNick(aString, aConv) {
+  let params = aString.trim();
+  if (!params) {
+    return [];
+  }
+
+  // Match trimmed-string with the longest prefix of participant's nickname.
+  let nickName = "";
+  for (let participant of aConv._participants.keys()) {
+    if (
+      params.startsWith(participant + " ") &&
+      participant.length > nickName.length
+    ) {
+      nickName = participant;
+    }
+  }
+  if (!nickName) {
+    let offset = params.indexOf(" ");
+    let expectedNickName = offset != -1 ? params.slice(0, offset) : params;
+    aConv.writeMessage(
+      aConv.name,
+      lazy._("conversation.error.nickNotInRoom", expectedNickName),
+      { system: true }
+    );
+    return [];
+  }
+
+  let splitParams = [];
+  splitParams.push(nickName);
+
+  let msg = params.substring(nickName.length);
+  if (msg) {
+    splitParams.push(msg.trimLeft());
+  }
+  return splitParams;
+}
+
+// Splits aMsg in two entries and checks the first entry is a valid jid, then
+// passes it to aConv.invite().
+// Returns false if aMsg is empty, otherwise returns true.
+function invite(aMsg, aConv) {
+  let params = splitInput(aMsg);
+  if (!params.length) {
+    return false;
+  }
+
+  // Check user's jid is valid.
+  let account = getAccount(aConv);
+  let jid = account._parseJID(params[0]);
+  if (!jid) {
+    aConv.writeMessage(
+      aConv.name,
+      lazy._("conversation.error.invalidJID", params[0]),
+      { system: true }
+    );
+    return true;
+  }
+
+  aConv.invite(...params);
+  return true;
+}
+
+export var commands = [
+  {
+    name: "join",
+    get helpString() {
+      return lazy._("command.join3", "join");
+    },
+    run(aMsg, aConv, aReturnedConv) {
+      let account = getAccount(aConv);
+      let params = aMsg.trim();
+      let conv;
+
+      if (!params) {
+        conv = getConv(aConv);
+        if (!conv.isChat) {
+          return false;
+        }
+        if (!conv.left) {
+          return true;
+        }
+
+        // Rejoin the current conversation. If the conversation was explicitly
+        // parted by the user, chatRoomFields will have been deleted.
+        // Otherwise, make use of it.
+        if (conv.chatRoomFields) {
+          account.joinChat(conv.chatRoomFields);
+          return true;
+        }
+
+        params = conv.name;
+      }
+      let chatRoomFields = account.getChatRoomDefaultFieldValues(params);
+      conv = account.joinChat(chatRoomFields);
+
+      if (aReturnedConv) {
+        aReturnedConv.value = conv;
+      }
+      return true;
+    },
+  },
+  {
+    name: "part",
+    get helpString() {
+      return lazy._("command.part2", "part");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run(aMsg, aConv) {
+      let conv = getConv(aConv);
+      if (!conv.left) {
+        conv.part(aMsg);
+      }
+      return true;
+    },
+  },
+  {
+    name: "topic",
+    get helpString() {
+      return lazy._("command.topic", "topic");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run(aMsg, aConv) {
+      let conv = getMUC(aConv);
+      if (!conv) {
+        return true;
+      }
+      conv.topic = aMsg;
+      return true;
+    },
+  },
+  {
+    name: "ban",
+    get helpString() {
+      return lazy._("command.ban", "ban");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run(aMsg, aConv) {
+      let params = splitInput(aMsg);
+      if (!params.length) {
+        return false;
+      }
+
+      let conv = getMUC(aConv);
+      if (conv) {
+        conv.ban(...params);
+      }
+      return true;
+    },
+  },
+  {
+    name: "kick",
+    get helpString() {
+      return lazy._("command.kick", "kick");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run(aMsg, aConv) {
+      let conv = getMUC(aConv);
+      if (!conv) {
+        return true;
+      }
+
+      let params = splitByNick(aMsg, conv);
+      if (!params.length) {
+        return false;
+      }
+      conv.kick(...params);
+      return true;
+    },
+  },
+  {
+    name: "invite",
+    get helpString() {
+      return lazy._("command.invite", "invite");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run(aMsg, aConv) {
+      let conv = getMUC(aConv);
+      if (!conv) {
+        return true;
+      }
+
+      return invite(aMsg, conv);
+    },
+  },
+  {
+    name: "inviteto",
+    get helpString() {
+      return lazy._("command.inviteto", "inviteto");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_IM,
+    run: (aMsg, aConv) => invite(aMsg, getConv(aConv)),
+  },
+  {
+    name: "me",
+    get helpString() {
+      return lazy._("command.me", "me");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run(aMsg, aConv) {
+      let params = aMsg.trim();
+      if (!params) {
+        return false;
+      }
+
+      let conv = getConv(aConv);
+      conv.sendMsg(params, true);
+
+      return true;
+    },
+  },
+  {
+    name: "nick",
+    get helpString() {
+      return lazy._("command.nick", "nick");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run(aMsg, aConv) {
+      let params = aMsg.trim().split(/\s+/);
+      if (!params[0]) {
+        return false;
+      }
+
+      let conv = getMUC(aConv);
+      if (conv) {
+        conv.setNick(params[0]);
+      }
+      return true;
+    },
+  },
+  {
+    name: "msg",
+    get helpString() {
+      return lazy._("command.msg", "msg");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run(aMsg, aConv, aReturnedConv) {
+      let conv = getMUC(aConv);
+      if (!conv) {
+        return true;
+      }
+
+      let params = splitByNick(aMsg, conv);
+      if (params.length != 2) {
+        return false;
+      }
+      let [nickName, msg] = params;
+
+      let account = getAccount(aConv);
+      let privateConv = account.createConversation(conv.name + "/" + nickName);
+      if (!privateConv) {
+        return true;
+      }
+      privateConv.sendMsg(msg.trim());
+
+      if (aReturnedConv) {
+        aReturnedConv.value = privateConv;
+      }
+      return true;
+    },
+  },
+  {
+    name: "version",
+    get helpString() {
+      return lazy._("command.version", "version");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_IM,
+    run(aMsg, aConv, aReturnedConv) {
+      let conv = getConv(aConv);
+      if (conv.left) {
+        return true;
+      }
+
+      // We do not have user's resource.
+      if (!conv._targetResource) {
+        conv.writeMessage(
+          conv.name,
+          lazy._("conversation.error.resourceNotAvailable", conv.shortName),
+          {
+            system: true,
+          }
+        );
+        return true;
+      }
+
+      conv.getVersion();
+      return true;
+    },
+  },
+];
diff --git a/comm/chat/protocols/xmpp/xmpp-session.sys.mjs b/comm/chat/protocols/xmpp/xmpp-session.sys.mjs
new file mode 100644
index 0000000000..ca2fd4eebb
--- /dev/null
+++ b/comm/chat/protocols/xmpp/xmpp-session.sys.mjs
@@ -0,0 +1,764 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { DNS } = ChromeUtils.import("resource:///modules/DNS.jsm");
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import { l10nHelper } from "resource:///modules/imXPCOMUtils.sys.mjs";
+import { Socket } from "resource:///modules/socket.sys.mjs";
+import { Stanza, XMPPParser } from "resource:///modules/xmpp-xml.sys.mjs";
+import { XMPPAuthMechanisms } from "resource:///modules/xmpp-authmechs.sys.mjs";
+
+const lazy = {};
+
+XPCOMUtils.defineLazyGetter(lazy, "_", () =>
+  l10nHelper("chrome://chat/locale/xmpp.properties")
+);
+
+export function XMPPSession(
+  aHost,
+  aPort,
+  aSecurity,
+  aJID,
+  aPassword,
+  aAccount
+) {
+  this._host = aHost;
+  this._port = aPort;
+
+  this._connectionSecurity = aSecurity;
+  if (this._connectionSecurity == "old_ssl") {
+    this._security = ["ssl"];
+  } else if (this._connectionSecurity != "none") {
+    this._security = [aPort == 5223 || aPort == 443 ? "ssl" : "starttls"];
+  }
+
+  if (!aJID.node) {
+    aAccount.reportDisconnecting(
+      Ci.prplIAccount.ERROR_INVALID_USERNAME,
+      lazy._("connection.error.invalidUsername")
+    );
+    aAccount.reportDisconnected();
+    return;
+  }
+  this._jid = aJID;
+  this._domain = aJID.domain;
+  this._password = aPassword;
+  this._account = aAccount;
+  this._resource = aJID.resource;
+  this._handlers = new Map();
+  this._account.reportConnecting();
+
+  // The User has specified a certain server or port, so we should not do
+  // DNS SRV lookup or the preference of disabling DNS SRV part and use
+  // normal connect is set.
+  // RFC 6120 (Section 3.2.3): When Not to Use SRV.
+  if (
+    Services.prefs.getBoolPref("chat.dns.srv.disable") ||
+    this._account.prefs.prefHasUserValue("server") ||
+    this._account.prefs.prefHasUserValue("port")
+  ) {
+    this.connect(this._host, this._port, this._security);
+    return;
+  }
+
+  // RFC 6120 (Section 3.2.1): SRV lookup.
+  this._account.reportConnecting(lazy._("connection.srvLookup"));
+  DNS.srv("_xmpp-client._tcp." + this._host)
+    .then(aResult => this._handleSrvQuery(aResult))
+    .catch(aError => {
+      if (aError === this.SRV_ERROR_XMPP_NOT_SUPPORTED) {
+        this.LOG("SRV: XMPP is not supported on this domain.");
+
+        // RFC 6120 (Section 3.2.1) and RFC 2782 (Usage rules): Abort as the
+        // service is decidedly not available at this domain.
+        this._account.reportDisconnecting(
+          Ci.prplIAccount.ERROR_OTHER_ERROR,
+          lazy._("connection.error.XMPPNotSupported")
+        );
+        this._account.reportDisconnected();
+        return;
+      }
+
+      this.ERROR("Error during SRV lookup:", aError);
+
+      // Since we don't receive a response to SRV query, we SHOULD attempt the
+      // fallback process (use normal connect without SRV lookup).
+      this.connect(this._host, this._port, this._security);
+    });
+}
+
+XMPPSession.prototype = {
+  /* for the socket.jsm helper */
+  __proto__: Socket,
+  connectTimeout: 60,
+  readWriteTimeout: 300,
+
+  // Contains the remaining SRV records if we failed to connect the current one.
+  _srvRecords: [],
+
+  sendPing() {
+    this.sendStanza(
+      Stanza.iq("get", null, null, Stanza.node("ping", Stanza.NS.ping)),
+      this.cancelDisconnectTimer,
+      this
+    );
+  },
+  _lastReceiveTime: 0,
+  _lastSendTime: 0,
+  checkPingTimer(aJustSentSomething = false) {
+    // Don't start a ping timer if we're not fully connected yet.
+    if (this.onXmppStanza != this.stanzaListeners.accountListening) {
+      return;
+    }
+    let now = Date.now();
+    if (aJustSentSomething) {
+      this._lastSendTime = now;
+    } else {
+      this._lastReceiveTime = now;
+    }
+    // We only cancel the ping timer if we've both received and sent
+    // something in the last two minutes. This is because Openfire
+    // servers will disconnect us if we don't send anything for a
+    // couple of minutes.
+    if (
+      Math.min(this._lastSendTime, this._lastReceiveTime) >
+      now - this.kTimeBeforePing
+    ) {
+      this.resetPingTimer();
+    }
+  },
+
+  get DEBUG() {
+    return this._account.DEBUG;
+  },
+  get LOG() {
+    return this._account.LOG;
+  },
+  get WARN() {
+    return this._account.WARN;
+  },
+  get ERROR() {
+    return this._account.ERROR;
+  },
+
+  _security: null,
+  _encrypted: false,
+
+  // DNS SRV errors in XMPP.
+  SRV_ERROR_XMPP_NOT_SUPPORTED: -2,
+
+  // Handles result of DNS SRV query and saves sorted results if it's OK in _srvRecords,
+  // otherwise throws error.
+  _handleSrvQuery(aResult) {
+    this.LOG("SRV lookup: " + JSON.stringify(aResult));
+    if (aResult.length == 0) {
+      // RFC 6120 (Section 3.2.1) and RFC 2782 (Usage rules): No SRV records,
+      // try to login with the given domain name.
+      this.connect(this._host, this._port, this._security);
+      return;
+    } else if (aResult.length == 1 && aResult[0].host == ".") {
+      throw this.SRV_ERROR_XMPP_NOT_SUPPORTED;
+    }
+
+    // Sort results: Lower priority is more preferred and higher weight is
+    // more preferred in equal priorities.
+    aResult.sort(function (a, b) {
+      return a.prio - b.prio || b.weight - a.weight;
+    });
+
+    this._srvRecords = aResult;
+    this._connectNextRecord();
+  },
+
+  _connectNextRecord() {
+    if (!this._srvRecords.length) {
+      this.ERROR(
+        "_connectNextRecord is called and there are no more records " +
+          "to connect."
+      );
+      return;
+    }
+
+    let record = this._srvRecords.shift();
+
+    // RFC 3920 (Section 5.1): Certificates MUST be checked against the
+    // hostname as provided by the initiating entity (e.g. user).
+    this.connect(
+      this._domain,
+      this._port,
+      this._security,
+      null,
+      record.host,
+      record.port
+    );
+  },
+
+  /* Disconnect from the server */
+  disconnect() {
+    if (this.onXmppStanza == this.stanzaListeners.accountListening) {
+      this.send("</stream:stream>");
+    }
+    delete this.onXmppStanza;
+    Socket.disconnect.call(this);
+    if (this._parser) {
+      this._parser.destroy();
+      delete this._parser;
+    }
+    this.cancelDisconnectTimer();
+  },
+
+  /* Report errors to the account */
+  onError(aError, aException) {
+    // If we're trying to connect to SRV entries, then keep trying until a
+    // successful connection occurs or we run out of SRV entries to try.
+    if (this._srvRecords.length) {
+      this._connectNextRecord();
+      return;
+    }
+
+    this._account.onError(aError, aException);
+  },
+
+  /* Send a text message to the server */
+  send(aMsg, aLogString) {
+    this.sendString(aMsg, "UTF-8", aLogString);
+  },
+
+  /* Send a stanza to the server.
+   * Can set a callback if required, which will be called when the server
+   * responds to the stanza with a stanza of the same id. The callback should
+   * return true if the stanza was handled, false if not. Note that an
+   * undefined return value is treated as true.
+   */
+  sendStanza(aStanza, aCallback, aThis, aLogString) {
+    if (!aStanza.attributes.hasOwnProperty("id")) {
+      aStanza.attributes.id = this._account.generateId();
+    }
+    if (aCallback) {
+      this._handlers.set(aStanza.attributes.id, aCallback.bind(aThis));
+    }
+    this.send(aStanza.getXML(), aLogString);
+    this.checkPingTimer(true);
+    return aStanza.attributes.id;
+  },
+
+  /* This method handles callbacks for specific ids. */
+  execHandler(aId, aStanza) {
+    let handler = this._handlers.get(aId);
+    if (!handler) {
+      return false;
+    }
+    let isHandled = handler(aStanza);
+    // Treat undefined return values as handled.
+    if (isHandled === undefined) {
+      isHandled = true;
+    }
+    this._handlers.delete(aId);
+    return isHandled;
+  },
+
+  /* Start the XMPP stream */
+  startStream() {
+    if (this._parser) {
+      this._parser.destroy();
+    }
+    this._parser = new XMPPParser(this);
+    this.send(
+      '<?xml version="1.0"?><stream:stream to="' +
+        this._domain +
+        '" xmlns="jabber:client" xmlns:stream="http://etherx.jabber.org/streams" version="1.0">'
+    );
+  },
+
+  startSession() {
+    this.sendStanza(
+      Stanza.iq("set", null, null, Stanza.node("session", Stanza.NS.session)),
+      aStanza => aStanza.attributes.type == "result"
+    );
+    this.onXmppStanza = this.stanzaListeners.sessionStarted;
+  },
+
+  /* XEP-0078: Non-SASL Authentication */
+  startLegacyAuth() {
+    if (!this._encrypted && this._connectionSecurity == "require_tls") {
+      this.onError(
+        Ci.prplIAccount.ERROR_ENCRYPTION_ERROR,
+        lazy._("connection.error.startTLSNotSupported")
+      );
+      return;
+    }
+
+    this.onXmppStanza = this.stanzaListeners.legacyAuth;
+    let s = Stanza.iq(
+      "get",
+      null,
+      this._domain,
+      Stanza.node(
+        "query",
+        Stanza.NS.auth,
+        null,
+        Stanza.node("username", null, null, this._jid.node)
+      )
+    );
+    this.sendStanza(s);
+  },
+
+  // If aResource is null, it will request to bind a server-generated
+  // resourcepart, otherwise request to bind a client-submitted resourcepart.
+  _requestBind(aResource) {
+    let resourceNode = aResource
+      ? Stanza.node("resource", null, null, aResource)
+      : null;
+    this.sendStanza(
+      Stanza.iq(
+        "set",
+        null,
+        null,
+        Stanza.node("bind", Stanza.NS.bind, null, resourceNode)
+      )
+    );
+  },
+
+  /* Socket events */
+  /* The connection is established */
+  onConnection() {
+    if (this._security.includes("ssl")) {
+      this.onXmppStanza = this.stanzaListeners.startAuth;
+      this._encrypted = true;
+    } else {
+      this.onXmppStanza = this.stanzaListeners.initStream;
+    }
+
+    // Clear SRV results since we have connected.
+    this._srvRecords = [];
+
+    this._account.reportConnecting(lazy._("connection.initializingStream"));
+    this.startStream();
+  },
+
+  /* When incoming data is available to be parsed */
+  onDataReceived(aData) {
+    this.checkPingTimer();
+    this._lastReceivedData = aData;
+    try {
+      this._parser.onDataAvailable(aData);
+    } catch (e) {
+      console.error(e);
+      this.onXMLError("parser-exception", e);
+    }
+    delete this._lastReceivedData;
+  },
+
+  /* The connection got disconnected without us closing it. */
+  onConnectionClosed() {
+    this._networkError(lazy._("connection.error.serverClosedConnection"));
+  },
+  onConnectionSecurityError(aTLSError, aNSSErrorMessage) {
+    let error = this._account.handleConnectionSecurityError(this);
+    this.onError(error, aNSSErrorMessage);
+  },
+  onConnectionReset() {
+    this._networkError(lazy._("connection.error.resetByPeer"));
+  },
+  onConnectionTimedOut() {
+    this._networkError(lazy._("connection.error.timedOut"));
+  },
+  _networkError(aMessage) {
+    this.onError(Ci.prplIAccount.ERROR_NETWORK_ERROR, aMessage);
+  },
+
+  /* Methods called by the XMPPParser instance */
+  onXMLError(aError, aException) {
+    if (aError == "parsing-characters") {
+      this.WARN(aError + ": " + aException + "\n" + this._lastReceivedData);
+    } else {
+      this.ERROR(aError + ": " + aException + "\n" + this._lastReceivedData);
+    }
+    if (aError != "parse-warning" && aError != "parsing-characters") {
+      this._networkError(lazy._("connection.error.receivedUnexpectedData"));
+    }
+  },
+
+  // All the functions in stanzaListeners are used as onXmppStanza
+  // implementations at various steps of establishing the session.
+  stanzaListeners: {
+    initStream(aStanza) {
+      if (aStanza.localName != "features") {
+        this.ERROR(
+          "Unexpected stanza " + aStanza.localName + ", expected 'features'"
+        );
+        this._networkError(lazy._("connection.error.incorrectResponse"));
+        return;
+      }
+
+      let starttls = aStanza.getElement(["starttls"]);
+      if (starttls && this._security.includes("starttls")) {
+        this._account.reportConnecting(
+          lazy._("connection.initializingEncryption")
+        );
+        this.sendStanza(Stanza.node("starttls", Stanza.NS.tls));
+        this.onXmppStanza = this.stanzaListeners.startTLS;
+        return;
+      }
+      if (starttls && starttls.children.some(c => c.localName == "required")) {
+        this.onError(
+          Ci.prplIAccount.ERROR_ENCRYPTION_ERROR,
+          lazy._("connection.error.startTLSRequired")
+        );
+        return;
+      }
+      if (!starttls && this._connectionSecurity == "require_tls") {
+        this.onError(
+          Ci.prplIAccount.ERROR_ENCRYPTION_ERROR,
+          lazy._("connection.error.startTLSNotSupported")
+        );
+        return;
+      }
+
+      // If we aren't starting TLS, jump to the auth step.
+      this.onXmppStanza = this.stanzaListeners.startAuth;
+      this.onXmppStanza(aStanza);
+    },
+    startTLS(aStanza) {
+      if (aStanza.localName != "proceed") {
+        this._networkError(lazy._("connection.error.failedToStartTLS"));
+        return;
+      }
+
+      this.startTLS();
+      this._encrypted = true;
+      this.startStream();
+      this.onXmppStanza = this.stanzaListeners.startAuth;
+    },
+    startAuth(aStanza) {
+      if (aStanza.localName != "features") {
+        this.ERROR(
+          "Unexpected stanza " + aStanza.localName + ", expected 'features'"
+        );
+        this._networkError(lazy._("connection.error.incorrectResponse"));
+        return;
+      }
+
+      let mechs = aStanza.getElement(["mechanisms"]);
+      if (!mechs) {
+        let auth = aStanza.getElement(["auth"]);
+        if (auth && auth.uri == Stanza.NS.auth_feature) {
+          this.startLegacyAuth();
+        } else {
+          this._networkError(lazy._("connection.error.noAuthMec"));
+        }
+        return;
+      }
+
+      // Select the auth mechanism we will use. PLAIN will be treated
+      // a bit differently as we want to avoid it over an unencrypted
+      // connection, except if the user has explicitly allowed that
+      // behavior.
+      let authMechanisms = this._account.authMechanisms || XMPPAuthMechanisms;
+      let selectedMech = "";
+      let canUsePlain = false;
+      mechs = mechs.getChildren("mechanism");
+      for (let m of mechs) {
+        let mech = m.innerText;
+        if (mech == "PLAIN" && !this._encrypted) {
+          // If PLAIN is proposed over an unencrypted connection,
+          // remember that it's a possibility but don't bother
+          // checking if the user allowed it until we have verified
+          // that nothing more secure is available.
+          canUsePlain = true;
+        } else if (authMechanisms.hasOwnProperty(mech)) {
+          selectedMech = mech;
+          break;
+        }
+      }
+      if (!selectedMech && canUsePlain) {
+        if (this._connectionSecurity == "allow_unencrypted_plain_auth") {
+          selectedMech = "PLAIN";
+        } else {
+          this.onError(
+            Ci.prplIAccount.ERROR_AUTHENTICATION_IMPOSSIBLE,
+            lazy._("connection.error.notSendingPasswordInClear")
+          );
+          return;
+        }
+      }
+      if (!selectedMech) {
+        this.onError(
+          Ci.prplIAccount.ERROR_AUTHENTICATION_IMPOSSIBLE,
+          lazy._("connection.error.noCompatibleAuthMec")
+        );
+        return;
+      }
+      let authMec = authMechanisms[selectedMech](
+        this._jid.node,
+        this._password,
+        this._domain
+      );
+      this._password = null;
+
+      this._account.reportConnecting(lazy._("connection.authenticating"));
+      this.onXmppStanza = this.stanzaListeners.authDialog.bind(this, authMec);
+      this.onXmppStanza(null); // the first auth step doesn't read anything
+    },
+    authDialog(aAuthMec, aStanza) {
+      if (aStanza && aStanza.localName == "failure") {
+        let errorMsg = "authenticationFailure";
+        if (
+          aStanza.getElement(["not-authorized"]) ||
+          aStanza.getElement(["bad-auth"])
+        ) {
+          errorMsg = "notAuthorized";
+        }
+        this.onError(
+          Ci.prplIAccount.ERROR_AUTHENTICATION_FAILED,
+          lazy._("connection.error." + errorMsg)
+        );
+        return;
+      }
+
+      let result;
+      try {
+        result = aAuthMec.next(aStanza);
+      } catch (e) {
+        this.ERROR("Error in auth mechanism: " + e);
+        this.onError(
+          Ci.prplIAccount.ERROR_AUTHENTICATION_FAILED,
+          lazy._("connection.error.authenticationFailure")
+        );
+        return;
+      }
+
+      // The authentication mechanism can yield a promise which must resolve
+      // before sending data. If it rejects, abort.
+      if (result.value) {
+        Promise.resolve(result.value).then(
+          value => {
+            // Send the XML stanza that is returned.
+            if (value.send) {
+              this.send(value.send.getXML(), value.log);
+            }
+          },
+          e => {
+            this.ERROR("Error resolving auth mechanism result: " + e);
+            this.onError(
+              Ci.prplIAccount.ERROR_AUTHENTICATION_FAILED,
+              lazy._("connection.error.authenticationFailure")
+            );
+          }
+        );
+      }
+      if (result.done) {
+        this.startStream();
+        this.onXmppStanza = this.stanzaListeners.startBind;
+      }
+    },
+    startBind(aStanza) {
+      if (!aStanza.getElement(["bind"])) {
+        this.ERROR("Unexpected lack of the bind feature");
+        this._networkError(lazy._("connection.error.incorrectResponse"));
+        return;
+      }
+
+      this._account.reportConnecting(lazy._("connection.gettingResource"));
+      this._requestBind(this._resource);
+      this.onXmppStanza = this.stanzaListeners.bindResult;
+    },
+    bindResult(aStanza) {
+      if (aStanza.attributes.type == "error") {
+        let error = this._account.parseError(aStanza);
+        let message;
+        switch (error.condition) {
+          case "resource-constraint":
+            // RFC 6120 (7.6.2.1): Resource Constraint.
+            // The account has reached a limit on the number of simultaneous
+            // connected resources allowed.
+            message = "connection.error.failedMaxResourceLimit";
+            break;
+          case "bad-request":
+            // RFC 6120 (7.7.2.1): Bad Request.
+            // The provided resourcepart cannot be processed by the server.
+            message = "connection.error.failedResourceNotValid";
+            break;
+          case "conflict":
+            // RFC 6120 (7.7.2.2): Conflict.
+            // The provided resourcepart is already in use and the server
+            // disallowed the resource binding attempt.
+            this._requestBind();
+            return;
+          default:
+            this.WARN(`Unhandled bind result error ${error.condition}.`);
+            message = "connection.error.failedToGetAResource";
+        }
+        this._networkError(lazy._(message));
+        return;
+      }
+
+      let jid = aStanza.getElement(["bind", "jid"]);
+      if (!jid) {
+        this._networkError(lazy._("connection.error.failedToGetAResource"));
+        return;
+      }
+      jid = jid.innerText;
+      this.DEBUG("jid = " + jid);
+      this._jid = this._account._parseJID(jid);
+      this._resource = this._jid.resource;
+      this.startSession();
+    },
+    legacyAuth(aStanza) {
+      if (aStanza.attributes.type == "error") {
+        let error = aStanza.getElement(["error"]);
+        if (!error) {
+          this._networkError(lazy._("connection.error.incorrectResponse"));
+          return;
+        }
+
+        let code = parseInt(error.attributes.code, 10);
+        if (code == 401) {
+          // Failed Authentication (Incorrect Credentials)
+          this.onError(
+            Ci.prplIAccount.ERROR_AUTHENTICATION_FAILED,
+            lazy._("connection.error.notAuthorized")
+          );
+          return;
+        } else if (code == 406) {
+          // Failed Authentication (Required Information Not Provided)
+          this.onError(
+            Ci.prplIAccount.ERROR_AUTHENTICATION_FAILED,
+            lazy._("connection.error.authenticationFailure")
+          );
+          return;
+        }
+        // else if (code == 409) {
+        // Failed Authentication (Resource Conflict)
+        // XXX Flo The spec in XEP-0078 defines this error code, but
+        // I've yet to find a server sending it. The server I tested
+        // with just closed the first connection when a second
+        // connection was attempted with the same resource.
+        // libpurple's jabber prpl doesn't support this code either.
+        // }
+      }
+
+      if (aStanza.attributes.type != "result") {
+        this._networkError(lazy._("connection.error.incorrectResponse"));
+        return;
+      }
+
+      if (aStanza.children.length == 0) {
+        // Success!
+        this._password = null;
+        this.startSession();
+        return;
+      }
+
+      let query = aStanza.getElement(["query"]);
+      let values = {};
+      for (let c of query.children) {
+        values[c.qName] = c.innerText;
+      }
+
+      if (!("username" in values) || !("resource" in values)) {
+        this._networkError(lazy._("connection.error.incorrectResponse"));
+        return;
+      }
+
+      // If the resource is empty, we will fallback to brandShortName as
+      // resource is REQUIRED.
+      if (!this._resource) {
+        this._resource = Services.strings
+          .createBundle("chrome://branding/locale/brand.properties")
+          .GetStringFromName("brandShortName");
+        this._jid = this._setJID(
+          this._jid.domain,
+          this._jid.node,
+          this._resource
+        );
+      }
+
+      let children = [
+        Stanza.node("username", null, null, this._jid.node),
+        Stanza.node("resource", null, null, this._resource),
+      ];
+
+      let logString;
+      if ("digest" in values && this._streamId) {
+        let hashBase = this._streamId + this._password;
+
+        let ch = Cc["@mozilla.org/security/hash;1"].createInstance(
+          Ci.nsICryptoHash
+        );
+        ch.init(ch.SHA1);
+        // Non-US-ASCII characters MUST be encoded as UTF-8 since the
+        // SHA-1 hashing algorithm operates on byte arrays.
+        let data = [...new TextEncoder().encode(hashBase)];
+        ch.update(data, data.length);
+        let hash = ch.finish(false);
+        let toHexString = charCode => ("0" + charCode.toString(16)).slice(-2);
+        let digest = Object.keys(hash)
+          .map(i => toHexString(hash.charCodeAt(i)))
+          .join("");
+
+        children.push(Stanza.node("digest", null, null, digest));
+        logString =
+          "legacyAuth stanza containing SHA-1 hash of the password not logged";
+      } else if ("password" in values) {
+        if (
+          !this._encrypted &&
+          this._connectionSecurity != "allow_unencrypted_plain_auth"
+        ) {
+          this.onError(
+            Ci.prplIAccount.ERROR_AUTHENTICATION_IMPOSSIBLE,
+            lazy._("connection.error.notSendingPasswordInClear")
+          );
+          return;
+        }
+        children.push(Stanza.node("password", null, null, this._password));
+        logString = "legacyAuth stanza containing password not logged";
+      } else {
+        this.onError(
+          Ci.prplIAccount.ERROR_AUTHENTICATION_IMPOSSIBLE,
+          lazy._("connection.error.noCompatibleAuthMec")
+        );
+        return;
+      }
+
+      let s = Stanza.iq(
+        "set",
+        null,
+        this._domain,
+        Stanza.node("query", Stanza.NS.auth, null, children)
+      );
+      this.sendStanza(
+        s,
+        undefined,
+        undefined,
+        `<iq type="set".../> (${logString})`
+      );
+    },
+    sessionStarted(aStanza) {
+      this.resetPingTimer();
+      this._account.onConnection();
+      this.LOG("Account successfully connected.");
+      this.onXmppStanza = this.stanzaListeners.accountListening;
+    },
+    accountListening(aStanza) {
+      let id = aStanza.attributes.id;
+      if (id && this.execHandler(id, aStanza)) {
+        return;
+      }
+
+      this._account.onXmppStanza(aStanza);
+      let name = aStanza.qName;
+      if (name == "presence") {
+        this._account.onPresenceStanza(aStanza);
+      } else if (name == "message") {
+        this._account.onMessageStanza(aStanza);
+      } else if (name == "iq") {
+        this._account.onIQStanza(aStanza);
+      }
+    },
+  },
+  onXmppStanza(aStanza) {
+    this.ERROR("should not be reached\n");
+  },
+};
diff --git a/comm/chat/protocols/xmpp/xmpp-xml.sys.mjs b/comm/chat/protocols/xmpp/xmpp-xml.sys.mjs
new file mode 100644
index 0000000000..9d8c4ca523
--- /dev/null
+++ b/comm/chat/protocols/xmpp/xmpp-xml.sys.mjs
@@ -0,0 +1,508 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { SAX } from "resource:///modules/sax.sys.mjs";
+
+var NS = {
+  xml: "http://www.w3.org/XML/1998/namespace",
+  xhtml: "http://www.w3.org/1999/xhtml",
+  xhtml_im: "http://jabber.org/protocol/xhtml-im",
+
+  // auth
+  client: "jabber:client",
+  streams: "http://etherx.jabber.org/streams",
+  stream: "urn:ietf:params:xml:ns:xmpp-streams",
+  sasl: "urn:ietf:params:xml:ns:xmpp-sasl",
+  tls: "urn:ietf:params:xml:ns:xmpp-tls",
+  bind: "urn:ietf:params:xml:ns:xmpp-bind",
+  session: "urn:ietf:params:xml:ns:xmpp-session",
+  auth: "jabber:iq:auth",
+  auth_feature: "http://jabber.org/features/iq-auth",
+  http_bind: "http://jabber.org/protocol/httpbind",
+  http_auth: "http://jabber.org/protocol/http-auth",
+  xbosh: "urn:xmpp:xbosh",
+
+  private: "jabber:iq:private",
+  xdata: "jabber:x:data",
+
+  // roster
+  roster: "jabber:iq:roster",
+  roster_versioning: "urn:xmpp:features:rosterver",
+  roster_delimiter: "roster:delimiter",
+
+  // privacy lists
+  privacy: "jabber:iq:privacy",
+
+  // discovering
+  disco_info: "http://jabber.org/protocol/disco#info",
+  disco_items: "http://jabber.org/protocol/disco#items",
+  caps: "http://jabber.org/protocol/caps",
+
+  // addressing
+  address: "http://jabber.org/protocol/address",
+
+  muc_user: "http://jabber.org/protocol/muc#user",
+  muc_owner: "http://jabber.org/protocol/muc#owner",
+  muc_admin: "http://jabber.org/protocol/muc#admin",
+  muc_rooms: "http://jabber.org/protocol/muc#rooms",
+  conference: "jabber:x:conference",
+  muc: "http://jabber.org/protocol/muc",
+  register: "jabber:iq:register",
+  delay: "urn:xmpp:delay",
+  delay_legacy: "jabber:x:delay",
+  bookmarks: "storage:bookmarks",
+  chatstates: "http://jabber.org/protocol/chatstates",
+  event: "jabber:x:event",
+  stanzas: "urn:ietf:params:xml:ns:xmpp-stanzas",
+  vcard: "vcard-temp",
+  vcard_update: "vcard-temp:x:update",
+  ping: "urn:xmpp:ping",
+  carbons: "urn:xmpp:carbons:2",
+
+  geoloc: "http://jabber.org/protocol/geoloc",
+  geoloc_notify: "http://jabber.org/protocol/geoloc+notify",
+  mood: "http://jabber.org/protocol/mood",
+  tune: "http://jabber.org/protocol/tune",
+  nick: "http://jabber.org/protocol/nick",
+  nick_notify: "http://jabber.org/protocol/nick+notify",
+  activity: "http://jabber.org/protocol/activity",
+  rsm: "http://jabber.org/protocol/rsm",
+  last: "jabber:iq:last",
+  version: "jabber:iq:version",
+  avatar_data: "urn:xmpp:avatar:data",
+  avatar_data_notify: "urn:xmpp:avatar:data+notify",
+  avatar_metadata: "urn:xmpp:avatar:metadata",
+  avatar_metadata_notify: "urn:xmpp:avatar:metadata+notify",
+  pubsub: "http://jabber.org/protocol/pubsub",
+  pubsub_event: "http://jabber.org/protocol/pubsub#event",
+};
+
+var TOP_LEVEL_ELEMENTS = {
+  message: "jabber:client",
+  presence: "jabber:client",
+  iq: "jabber:client",
+  "stream:features": "http://etherx.jabber.org/streams",
+  proceed: "urn:ietf:params:xml:ns:xmpp-tls",
+  failure: [
+    "urn:ietf:params:xml:ns:xmpp-tls",
+    "urn:ietf:params:xml:ns:xmpp-sasl",
+  ],
+  success: "urn:ietf:params:xml:ns:xmpp-sasl",
+  challenge: "urn:ietf:params:xml:ns:xmpp-sasl",
+  error: "urn:ietf:params:xml:ns:xmpp-streams",
+};
+
+// Features that we support in XMPP.
+// Don't forget to add your new features here.
+export var SupportedFeatures = [
+  NS.chatstates,
+  NS.conference,
+  NS.disco_info,
+  NS.last,
+  NS.muc,
+  NS.ping,
+  NS.vcard,
+  NS.version,
+];
+
+/* Stanza Builder */
+export var Stanza = {
+  NS,
+
+  /* Create a presence stanza */
+  presence: (aAttr, aData) => Stanza.node("presence", null, aAttr, aData),
+
+  /* Create a message stanza */
+  message(aTo, aMsg, aState, aAttr = {}, aData = []) {
+    aAttr.to = aTo;
+    if (!("type" in aAttr)) {
+      aAttr.type = "chat";
+    }
+
+    if (aMsg) {
+      aData.push(Stanza.node("body", null, null, aMsg));
+    }
+
+    if (aState) {
+      aData.push(Stanza.node(aState, Stanza.NS.chatstates));
+    }
+
+    return Stanza.node("message", null, aAttr, aData);
+  },
+
+  /* Create a iq stanza */
+  iq(aType, aId, aTo, aData) {
+    let attrs = { type: aType };
+    if (aId) {
+      attrs.id = aId;
+    }
+    if (aTo) {
+      attrs.to = aTo;
+    }
+    return this.node("iq", null, attrs, aData);
+  },
+
+  /* Create a XML node */
+  node(aName, aNs, aAttr, aData) {
+    let node = new XMLNode(null, aNs, aName, aName, aAttr);
+    if (aData) {
+      if (!Array.isArray(aData)) {
+        aData = [aData];
+      }
+      for (let child of aData) {
+        node[typeof child == "string" ? "addText" : "addChild"](child);
+      }
+    }
+
+    return node;
+  },
+};
+
+/* Text node
+ * Contains a text */
+function TextNode(aText) {
+  this.text = aText;
+}
+TextNode.prototype = {
+  get type() {
+    return "text";
+  },
+
+  append(aText) {
+    this.text += aText;
+  },
+
+  /* For debug purposes, returns an indented (unencoded) string */
+  convertToString(aIndent) {
+    return aIndent + this.text + "\n";
+  },
+
+  /* Returns the encoded XML */
+  getXML() {
+    return Cc["@mozilla.org/txttohtmlconv;1"]
+      .getService(Ci.mozITXTToHTMLConv)
+      .scanTXT(this.text, Ci.mozITXTToHTMLConv.kEntities);
+  },
+
+  /* To read the unencoded data. */
+  get innerText() {
+    return this.text;
+  },
+};
+
+/* XML node */
+/* https://www.w3.org/TR/2008/REC-xml-20081126 */
+/* aUri is the namespace. */
+/* aLocalName must have value, otherwise throws. */
+/* aAttr is an object */
+/* Example: <f:a xmlns:f='g' d='1'> is parsed to
+   uri/namespace='g', localName='a', qName='f:a', attributes={d='1'} */
+function XMLNode(
+  aParentNode,
+  aUri,
+  aLocalName,
+  aQName = aLocalName,
+  aAttr = {}
+) {
+  if (!aLocalName) {
+    throw new Error("aLocalName must have value");
+  }
+
+  this._parentNode = aParentNode; // Used only for parsing
+  this.uri = aUri;
+  this.localName = aLocalName;
+  this.qName = aQName;
+  this.attributes = {};
+  this.children = [];
+
+  for (let attributeName in aAttr) {
+    // Each attribute specification has a name and a value.
+    if (aAttr[attributeName]) {
+      this.attributes[attributeName] = aAttr[attributeName];
+    }
+  }
+}
+XMLNode.prototype = {
+  get type() {
+    return "node";
+  },
+
+  /* Add a new child node */
+  addChild(aNode) {
+    this.children.push(aNode);
+  },
+
+  /* Add text node */
+  addText(aText) {
+    let lastIndex = this.children.length - 1;
+    if (lastIndex >= 0 && this.children[lastIndex] instanceof TextNode) {
+      this.children[lastIndex].append(aText);
+    } else {
+      this.children.push(new TextNode(aText));
+    }
+  },
+
+  /* Get child elements by namespace */
+  getChildrenByNS(aNS) {
+    return this.children.filter(c => c.uri == aNS);
+  },
+
+  /* Get the first element anywhere inside the node (including child nodes)
+     that matches the query.
+     A query consists of an array of localNames. */
+  getElement(aQuery) {
+    if (aQuery.length == 0) {
+      return this;
+    }
+
+    let nq = aQuery.slice(1);
+    for (let child of this.children) {
+      if (child.type == "text" || child.localName != aQuery[0]) {
+        continue;
+      }
+      let n = child.getElement(nq);
+      if (n) {
+        return n;
+      }
+    }
+
+    return null;
+  },
+
+  /* Get all elements of the node (including child nodes) that match the query.
+     A query consists of an array of localNames. */
+  getElements(aQuery) {
+    if (aQuery.length == 0) {
+      return [this];
+    }
+
+    let c = this.getChildren(aQuery[0]);
+    let nq = aQuery.slice(1);
+    let res = [];
+    for (let child of c) {
+      let n = child.getElements(nq);
+      res = res.concat(n);
+    }
+
+    return res;
+  },
+
+  /* Get immediate children by the node name */
+  getChildren(aName) {
+    return this.children.filter(c => c.type != "text" && c.localName == aName);
+  },
+
+  // Test if the node is a stanza and its namespace is valid.
+  isXmppStanza() {
+    if (!TOP_LEVEL_ELEMENTS.hasOwnProperty(this.qName)) {
+      return false;
+    }
+    let ns = TOP_LEVEL_ELEMENTS[this.qName];
+    return ns == this.uri || (Array.isArray(ns) && ns.includes(this.uri));
+  },
+
+  /* Returns indented XML */
+  convertToString(aIndent = "") {
+    let s =
+      aIndent + "<" + this.qName + this._getXmlns() + this._getAttributeText();
+    let content = "";
+    for (let child of this.children) {
+      content += child.convertToString(aIndent + " ");
+    }
+    return (
+      s +
+      (content ? ">\n" + content + aIndent + "</" + this.qName : "/") +
+      ">\n"
+    );
+  },
+
+  /* Returns the XML */
+  getXML() {
+    let s = "<" + this.qName + this._getXmlns() + this._getAttributeText();
+    let innerXML = this.innerXML;
+    return s + (innerXML ? ">" + innerXML + "</" + this.qName : "/") + ">";
+  },
+
+  get innerXML() {
+    return this.children.map(c => c.getXML()).join("");
+  },
+  get innerText() {
+    return this.children.map(c => c.innerText).join("");
+  },
+
+  /* Private methods */
+  _getXmlns() {
+    return this.uri ? ' xmlns="' + this.uri + '"' : "";
+  },
+  _getAttributeText() {
+    let s = "";
+    for (let name in this.attributes) {
+      s += " " + name + '="' + this.attributes[name] + '"';
+    }
+    return s;
+  },
+};
+
+export function XMPPParser(aListener) {
+  this._listener = aListener;
+
+  // We only get tagName from onclosetag callback, but we need more, so save the
+  // opening tags.
+  let tagStack = [];
+  this._parser = SAX.parser(true, { xmlns: true, lowercase: true });
+  this._parser.onopentag = node => {
+    if (this._parser.error) {
+      // sax-js doesn't stop on error, but we want to.
+      return;
+    }
+    let attrs = {};
+    for (let [name, attr] of Object.entries(node.attributes)) {
+      if (name == "xmlns") {
+        continue;
+      }
+      attrs[name] = attr.value;
+    }
+    this.startElement(node.uri, node.local, node.name, attrs);
+    tagStack.push(node);
+  };
+  this._parser.onclosetag = tagName => {
+    if (this._parser.error) {
+      return;
+    }
+    let node = tagStack.pop();
+    if (tagName == node.name) {
+      this.endElement(node.uri, node.local, node.name);
+    } else {
+      this.error(`Unexpected </${tagName}>, expecting </${node.name}>`);
+    }
+  };
+  this._parser.ontext = t => {
+    if (this._parser.error) {
+      return;
+    }
+    this.characters(t);
+  };
+  this._parser.onerror = this.error;
+}
+
+XMPPParser.prototype = {
+  _decoder: new TextDecoder(),
+  _destroyPending: false,
+  destroy() {
+    delete this._listener;
+
+    try {
+      this._parser.close();
+    } catch (e) {}
+    delete this._parser;
+  },
+
+  _logReceivedData(aData) {
+    this._listener.LOG("received:\n" + aData);
+  },
+  /**
+   * Decodes the byte string to UTF-8 (via byte array) before feeding it to the
+   * SAXML parser.
+   *
+   * @param {string} data - Raw XML byte string.
+   */
+  onDataAvailable(data) {
+    let bytes = new Uint8Array(data.length);
+    for (let i = 0; i < data.length; i++) {
+      bytes[i] = data.charCodeAt(i);
+    }
+    let utf8Data = this._decoder.decode(bytes);
+    this._parser.write(utf8Data);
+  },
+
+  startElement(aUri, aLocalName, aQName, aAttributes) {
+    if (aQName == "stream:stream") {
+      let node = new XMLNode(null, aUri, aLocalName, aQName, aAttributes);
+      // The node we created doesn't have children, but
+      // <stream:stream> isn't closed, so avoid displaying /> at the end.
+      this._logReceivedData(node.convertToString().slice(0, -3) + ">\n");
+
+      if ("_node" in this) {
+        this._listener.onXMLError(
+          "unexpected-stream-start",
+          "stream:stream inside an already started stream"
+        );
+        return;
+      }
+
+      this._listener._streamId = node.attributes.id;
+      if (!("version" in node.attributes)) {
+        this._listener.startLegacyAuth();
+      }
+
+      this._node = null;
+      return;
+    }
+
+    let node = new XMLNode(this._node, aUri, aLocalName, aQName, aAttributes);
+    if (this._node) {
+      this._node.addChild(node);
+    }
+
+    this._node = node;
+  },
+
+  characters(aCharacters) {
+    if (!this._node) {
+      // Ignore whitespace received on the stream to keep the connection alive.
+      if (aCharacters.trim()) {
+        this._listener.onXMLError(
+          "parsing-characters",
+          "No parent for characters: " + aCharacters
+        );
+      }
+      return;
+    }
+
+    this._node.addText(aCharacters);
+  },
+
+  endElement(aUri, aLocalName, aQName) {
+    if (aQName == "stream:stream") {
+      this._logReceivedData("</stream:stream>");
+      delete this._node;
+      return;
+    }
+
+    if (!this._node) {
+      this._listener.onXMLError(
+        "parsing-node",
+        "No parent for node : " + aLocalName
+      );
+      return;
+    }
+
+    // RFC 6120 (8): XML Stanzas.
+    // Checks if the node is the root and it's valid.
+    if (!this._node._parentNode) {
+      if (this._node.isXmppStanza()) {
+        this._logReceivedData(this._node.convertToString());
+        try {
+          this._listener.onXmppStanza(this._node);
+        } catch (e) {
+          console.error(e);
+          dump(e + "\n");
+        }
+      } else {
+        this._listener.onXMLError(
+          "parsing-node",
+          "Root node " + aLocalName + " is not valid."
+        );
+      }
+    }
+
+    this._node = this._node._parentNode;
+  },
+
+  error(aError) {
+    if (this._listener) {
+      this._listener.onXMLError("parse-error", aError);
+    }
+  },
+};
diff --git a/comm/chat/protocols/xmpp/xmpp.sys.mjs b/comm/chat/protocols/xmpp/xmpp.sys.mjs
new file mode 100644
index 0000000000..08fdcd5629
--- /dev/null
+++ b/comm/chat/protocols/xmpp/xmpp.sys.mjs
@@ -0,0 +1,106 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import { l10nHelper } from "resource:///modules/imXPCOMUtils.sys.mjs";
+import { GenericProtocolPrototype } from "resource:///modules/jsProtoHelper.sys.mjs";
+
+const lazy = {};
+
+XPCOMUtils.defineLazyGetter(lazy, "_", () =>
+  l10nHelper("chrome://chat/locale/xmpp.properties")
+);
+ChromeUtils.defineESModuleGetters(lazy, {
+  XMPPAccountPrototype: "resource:///modules/xmpp-base.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "XMPPAccount", () => {
+  function XMPPAccount(aProtoInstance, aImAccount) {
+    this._init(aProtoInstance, aImAccount);
+  }
+  XMPPAccount.prototype = lazy.XMPPAccountPrototype;
+  return XMPPAccount;
+});
+
+export function XMPPProtocol() {
+  this.commands = ChromeUtils.importESModule(
+    "resource:///modules/xmpp-commands.sys.mjs"
+  ).commands;
+  this.registerCommands();
+}
+
+XMPPProtocol.prototype = {
+  __proto__: GenericProtocolPrototype,
+  get normalizedName() {
+    return "jabber";
+  },
+  get name() {
+    return "XMPP";
+  },
+  get iconBaseURI() {
+    return "chrome://prpl-jabber/skin/";
+  },
+  getAccount(aImAccount) {
+    return new lazy.XMPPAccount(this, aImAccount);
+  },
+
+  usernameSplits: [
+    {
+      get label() {
+        return lazy._("options.domain");
+      },
+      separator: "@",
+      defaultValue: "jabber.org",
+    },
+  ],
+
+  options: {
+    resource: {
+      get label() {
+        return lazy._("options.resource");
+      },
+      default: "",
+    },
+    priority: {
+      get label() {
+        return lazy._("options.priority");
+      },
+      default: 0,
+    },
+    connection_security: {
+      get label() {
+        return lazy._("options.connectionSecurity");
+      },
+      listValues: {
+        get require_tls() {
+          return lazy._("options.connectionSecurity.requireEncryption");
+        },
+        get opportunistic_tls() {
+          return lazy._("options.connectionSecurity.opportunisticTLS");
+        },
+        get allow_unencrypted_plain_auth() {
+          return lazy._("options.connectionSecurity.allowUnencryptedAuth");
+        },
+        // "old_ssl" and "none" are also supported, but not exposed in the UI.
+        // Any unknown value will fallback to the opportunistic_tls behavior.
+      },
+      default: "require_tls",
+    },
+    server: {
+      get label() {
+        return lazy._("options.connectServer");
+      },
+      default: "",
+    },
+    port: {
+      get label() {
+        return lazy._("options.connectPort");
+      },
+      default: 5222,
+    },
+  },
+  get chatHasTopic() {
+    return true;
+  },
+};