quickblox 2.17.2-beta.2-logger → 2.17.3-logger

package/strophejs-1.4.0/src/md5.js

@@ -0,0 +1,204 @@
+/*
+ * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
+ * Digest Algorithm, as defined in RFC 1321.
+ * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for more info.
+ */
+/*
+ * Everything that isn't used by Strophe has been stripped here!
+ */
+
+/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+const safe_add = function (x, y) {
+    const lsw = (x & 0xFFFF) + (y & 0xFFFF);
+    const msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+    return (msw << 16) | (lsw & 0xFFFF);
+};
+
+/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+const bit_rol = function (num, cnt) {
+    return (num << cnt) | (num >>> (32 - cnt));
+};
+
+/*
+ * Convert a string to an array of little-endian words
+ */
+const str2binl = function (str) {
+    if (typeof str !== "string") {
+        throw new Error("str2binl was passed a non-string");
+    }
+    const bin = [];
+    for(let i = 0; i < str.length * 8; i += 8)
+    {
+        bin[i>>5] |= (str.charCodeAt(i / 8) & 255) << (i%32);
+    }
+    return bin;
+};
+
+/*
+ * Convert an array of little-endian words to a string
+ */
+const binl2str = function (bin) {
+    let str = "";
+    for(let i = 0; i < bin.length * 32; i += 8)
+    {
+        str += String.fromCharCode((bin[i>>5] >>> (i % 32)) & 255);
+    }
+    return str;
+};
+
+/*
+ * Convert an array of little-endian words to a hex string.
+ */
+const binl2hex = function (binarray) {
+    const hex_tab = "0123456789abcdef";
+    let str = "";
+    for(let i = 0; i < binarray.length * 4; i++)
+    {
+        str += hex_tab.charAt((binarray[i>>2] >> ((i%4)*8+4)) & 0xF) +
+            hex_tab.charAt((binarray[i>>2] >> ((i%4)*8  )) & 0xF);
+    }
+    return str;
+};
+
+/*
+ * These functions implement the four basic operations the algorithm uses.
+ */
+const md5_cmn = function (q, a, b, x, s, t) {
+    return safe_add(bit_rol(safe_add(safe_add(a, q),safe_add(x, t)), s),b);
+};
+
+const md5_ff = function (a, b, c, d, x, s, t) {
+    return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
+};
+
+const md5_gg = function (a, b, c, d, x, s, t) {
+    return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
+};
+
+const md5_hh = function (a, b, c, d, x, s, t) {
+    return md5_cmn(b ^ c ^ d, a, b, x, s, t);
+};
+
+const md5_ii = function (a, b, c, d, x, s, t) {
+    return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
+};
+
+/*
+ * Calculate the MD5 of an array of little-endian words, and a bit length
+ */
+const core_md5 = function (x, len) {
+    /* append padding */
+    x[len >> 5] |= 0x80 << ((len) % 32);
+    x[(((len + 64) >>> 9) << 4) + 14] = len;
+
+    let a =  1732584193;
+    let b = -271733879;
+    let c = -1732584194;
+    let d =  271733878;
+
+    let olda, oldb, oldc, oldd;
+    for (let i = 0; i < x.length; i += 16)
+    {
+        olda = a;
+        oldb = b;
+        oldc = c;
+        oldd = d;
+
+        a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
+        d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
+        c = md5_ff(c, d, a, b, x[i+ 2], 17,  606105819);
+        b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
+        a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
+        d = md5_ff(d, a, b, c, x[i+ 5], 12,  1200080426);
+        c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
+        b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
+        a = md5_ff(a, b, c, d, x[i+ 8], 7 ,  1770035416);
+        d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
+        c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
+        b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
+        a = md5_ff(a, b, c, d, x[i+12], 7 ,  1804603682);
+        d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
+        c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
+        b = md5_ff(b, c, d, a, x[i+15], 22,  1236535329);
+
+        a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
+        d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
+        c = md5_gg(c, d, a, b, x[i+11], 14,  643717713);
+        b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
+        a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
+        d = md5_gg(d, a, b, c, x[i+10], 9 ,  38016083);
+        c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
+        b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
+        a = md5_gg(a, b, c, d, x[i+ 9], 5 ,  568446438);
+        d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
+        c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
+        b = md5_gg(b, c, d, a, x[i+ 8], 20,  1163531501);
+        a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
+        d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
+        c = md5_gg(c, d, a, b, x[i+ 7], 14,  1735328473);
+        b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);
+
+        a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
+        d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
+        c = md5_hh(c, d, a, b, x[i+11], 16,  1839030562);
+        b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
+        a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
+        d = md5_hh(d, a, b, c, x[i+ 4], 11,  1272893353);
+        c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
+        b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
+        a = md5_hh(a, b, c, d, x[i+13], 4 ,  681279174);
+        d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
+        c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
+        b = md5_hh(b, c, d, a, x[i+ 6], 23,  76029189);
+        a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
+        d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
+        c = md5_hh(c, d, a, b, x[i+15], 16,  530742520);
+        b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);
+
+        a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
+        d = md5_ii(d, a, b, c, x[i+ 7], 10,  1126891415);
+        c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
+        b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
+        a = md5_ii(a, b, c, d, x[i+12], 6 ,  1700485571);
+        d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
+        c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
+        b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
+        a = md5_ii(a, b, c, d, x[i+ 8], 6 ,  1873313359);
+        d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
+        c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
+        b = md5_ii(b, c, d, a, x[i+13], 21,  1309151649);
+        a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
+        d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
+        c = md5_ii(c, d, a, b, x[i+ 2], 15,  718787259);
+        b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);
+
+        a = safe_add(a, olda);
+        b = safe_add(b, oldb);
+        c = safe_add(c, oldc);
+        d = safe_add(d, oldd);
+    }
+    return [a, b, c, d];
+};
+
+/*
+ * These are the functions you'll usually want to call.
+ * They take string arguments and return either hex or base-64 encoded
+ * strings.
+ */
+const MD5 = {
+    hexdigest: function (s) {
+        return binl2hex(core_md5(str2binl(s), s.length * 8));
+    },
+    hash: function (s) {
+        return binl2str(core_md5(str2binl(s), s.length * 8));
+    }
+};
+export { MD5 as default };

package/strophejs-1.4.0/src/sha1.js

@@ -0,0 +1,172 @@
+/*
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
+ * in FIPS PUB 180-1
+ * Version 2.1a Copyright Paul Johnston 2000 - 2002.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for details.
+ */
+/* global define */
+
+/* Some functions and variables have been stripped for use with Strophe */
+
+/*
+ * Calculate the SHA-1 of an array of big-endian words, and a bit length
+ */
+function core_sha1(x, len) {
+    /* append padding */
+    x[len >> 5] |= 0x80 << (24 - len % 32);
+    x[((len + 64 >> 9) << 4) + 15] = len;
+
+    var w = new Array(80);
+    var a =  1732584193;
+    var b = -271733879;
+    var c = -1732584194;
+    var d =  271733878;
+    var e = -1009589776;
+
+    var i, j, t, olda, oldb, oldc, oldd, olde;
+    for (i = 0; i < x.length; i += 16) {
+        olda = a;
+        oldb = b;
+        oldc = c;
+        oldd = d;
+        olde = e;
+
+        for (j = 0; j < 80; j++) {
+            if (j < 16) {
+                w[j] = x[i + j];
+            } else {
+                w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);
+            }
+
+            t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)),
+                         safe_add(safe_add(e, w[j]), sha1_kt(j)));
+            e = d;
+            d = c;
+            c = rol(b, 30);
+            b = a;
+            a = t;
+        }
+
+        a = safe_add(a, olda);
+        b = safe_add(b, oldb);
+        c = safe_add(c, oldc);
+        d = safe_add(d, oldd);
+        e = safe_add(e, olde);
+    }
+    return [a, b, c, d, e];
+}
+
+/*
+ * Perform the appropriate triplet combination function for the current
+ * iteration
+ */
+function sha1_ft (t, b, c, d) {
+    if (t < 20) { return (b & c) | ((~b) & d); }
+    if (t < 40) { return b ^ c ^ d; }
+    if (t < 60) { return (b & c) | (b & d) | (c & d); }
+    return b ^ c ^ d;
+}
+
+/*
+ * Determine the appropriate additive constant for the current iteration
+ */
+function sha1_kt(t) {
+    return (t < 20) ?  1518500249 : (t < 40) ?  1859775393 : (t < 60) ? -1894007588 : -899497514;
+}
+
+/*
+ * Calculate the HMAC-SHA1 of a key and some data
+ */
+function core_hmac_sha1(key, data) {
+    var bkey = str2binb(key);
+    if (bkey.length > 16) {
+        bkey = core_sha1(bkey, key.length * 8);
+    }
+
+    var ipad = new Array(16), opad = new Array(16);
+    for (var i = 0; i < 16; i++) {
+        ipad[i] = bkey[i] ^ 0x36363636;
+        opad[i] = bkey[i] ^ 0x5C5C5C5C;
+    }
+
+    var hash = core_sha1(ipad.concat(str2binb(data)), 512 + data.length * 8);
+    return core_sha1(opad.concat(hash), 512 + 160);
+}
+
+/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+function safe_add(x, y) {
+    var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+    var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+    return (msw << 16) | (lsw & 0xFFFF);
+}
+
+/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+function rol(num, cnt) {
+    return (num << cnt) | (num >>> (32 - cnt));
+}
+
+/*
+ * Convert an 8-bit or 16-bit string to an array of big-endian words
+ * In 8-bit function, characters >255 have their hi-byte silently ignored.
+ */
+function str2binb(str) {
+    var bin = [];
+    var mask = 255;
+    for (var i = 0; i < str.length * 8; i += 8) {
+        bin[i>>5] |= (str.charCodeAt(i / 8) & mask) << (24 - i%32);
+    }
+    return bin;
+}
+
+/*
+ * Convert an array of big-endian words to a base-64 string
+ */
+function binb2b64 (binarray) {
+    var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    var str = "";
+    var triplet, j;
+    for (var i = 0; i < binarray.length * 4; i += 3) {
+        triplet = (((binarray[i   >> 2] >> 8 * (3 -  i   %4)) & 0xFF) << 16) |
+                  (((binarray[i+1 >> 2] >> 8 * (3 - (i+1)%4)) & 0xFF) << 8 ) |
+                  ((binarray[i+2 >> 2] >> 8 * (3 - (i+2)%4)) & 0xFF);
+
+        for (j = 0; j < 4; j++) {
+            if (i * 8 + j * 6 > binarray.length * 32) { str += "="; }
+            else { str += tab.charAt((triplet >> 6*(3-j)) & 0x3F); }
+        }
+    }
+    return str;
+}
+
+/*
+ * Convert an array of big-endian words to a string
+ */
+function binb2str(bin) {
+    var str = "";
+    var mask = 255;
+    for (var i = 0; i < bin.length * 32; i += 8) {
+        str += String.fromCharCode((bin[i>>5] >>> (24 - i%32)) & mask);
+    }
+    return str;
+}
+
+/*
+ * These are the functions you'll usually want to call
+ * They take string arguments and return either hex or base-64 encoded strings
+ */
+const SHA1 = {
+    b64_hmac_sha1:  function (key, data){ return binb2b64(core_hmac_sha1(key, data)); },
+    b64_sha1:       function (s) { return binb2b64(core_sha1(str2binb(s),s.length * 8)); },
+    binb2str:       binb2str,
+    core_hmac_sha1: core_hmac_sha1,
+    str_hmac_sha1:  function (key, data){ return binb2str(core_hmac_sha1(key, data)); },
+    str_sha1:       function (s) { return binb2str(core_sha1(str2binb(s),s.length * 8)); },
+};
+export { SHA1 as default };

package/strophejs-1.4.0/src/shared-connection-worker.js

@@ -0,0 +1,114 @@
+let manager;
+
+
+const Status = {
+    ERROR: 0,
+    CONNECTING: 1,
+    CONNFAIL: 2,
+    AUTHENTICATING: 3,
+    AUTHFAIL: 4,
+    CONNECTED: 5,
+    DISCONNECTED: 6,
+    DISCONNECTING: 7,
+    ATTACHED: 8,
+    REDIRECT: 9,
+    CONNTIMEOUT: 10,
+    BINDREQUIRED: 11,
+    ATTACHFAIL: 12
+}
+
+
+/** Class: ConnectionManager
+ *
+ * Manages the shared websocket connection as well as the ports of the
+ * connected tabs.
+ */
+class ConnectionManager {
+
+    constructor () {
+        this.ports = [];
+    }
+
+    addPort (port) {
+        this.ports.push(port);
+        port.addEventListener('message', e => {
+            const method = e.data[0];
+            try {
+                this[method](e.data.splice(1))
+            } catch (e) {
+                console?.error(e);
+            }
+        });
+        port.start();
+    }
+
+    _connect (data) {
+        this.jid = data[1];
+        this._closeSocket();
+        this.socket = new WebSocket(data[0], "xmpp");
+        this.socket.onopen = () => this._onOpen();
+        this.socket.onerror = (e) => this._onError(e);
+        this.socket.onclose = (e) => this._onClose(e);
+        this.socket.onmessage = (message) => this._onMessage(message);
+    }
+
+    _attach () {
+        if (this.socket && this.socket.readyState !== WebSocket.CLOSED) {
+            this.ports.forEach(p => p.postMessage(['_attachCallback', Status.ATTACHED, this.jid]));
+        } else {
+            this.ports.forEach(p => p.postMessage(['_attachCallback', Status.ATTACHFAIL]));
+        }
+    }
+
+    send (str) {
+        this.socket.send(str);
+    }
+
+    close (str) {
+        if (this.socket && this.socket.readyState !== WebSocket.CLOSED) {
+            try {
+                this.socket.send(str);
+            } catch (e) {
+                this.ports.forEach(p => p.postMessage(['log', 'error', e]));
+                this.ports.forEach(p => p.postMessage(
+                    ['log', 'error', "Couldn't send <close /> tag."]));
+            }
+        }
+    }
+
+    _onOpen () {
+        this.ports.forEach(p => p.postMessage(['_onOpen']));
+    }
+
+    _onClose (e) {
+        this.ports.forEach(p => p.postMessage(['_onClose', e.reason]));
+    }
+
+    _onMessage (message) {
+        const o = { 'data': message.data }
+        this.ports.forEach(p => p.postMessage(['_onMessage', o]));
+    }
+
+    _onError (error) {
+        this.ports.forEach(p => p.postMessage(['_onError', error.reason]));
+    }
+
+    _closeSocket () {
+        if (this.socket) {
+            try {
+                this.socket.onclose = null;
+                this.socket.onerror = null;
+                this.socket.onmessage = null;
+                this.socket.close();
+            } catch (e) {
+                this.ports.forEach(p => p.postMessage(['log', 'error', e]));
+            }
+        }
+        this.socket = null;
+    }
+}
+
+onconnect = function (e) {  // eslint-disable-line no-undef
+    manager = manager || new ConnectionManager();
+    manager.addPort(e.ports[0]);
+}

package/strophejs-1.4.0/src/shims.js

@@ -0,0 +1,123 @@
+/*
+ * This module provides uniform
+ * Shims APIs and globals that are not present in all JS environments,
+ * the most common example for Strophe being browser APIs like WebSocket
+ * and DOM that don't exist under nodejs.
+ *
+ * Usually these will be supplied in nodejs by conditionally requiring a
+ * NPM module that provides a compatible implementation.
+ */
+
+/* global global */
+
+/**
+ * WHATWG WebSockets API
+ * https://www.w3.org/TR/websockets/
+ *
+ * Interface to use the web socket protocol
+ *
+ * Used implementations:
+ * - supported browsers: built-in in WebSocket global
+ *   https://developer.mozilla.org/en-US/docs/Web/API/WebSocket#Browser_compatibility
+ * - nodejs: use standard-compliant 'ws' module
+ *   https://www.npmjs.com/package/ws
+ */
+function getWebSocketImplementation () {
+    let WebSocketImplementation = global.WebSocket
+    if (typeof WebSocketImplementation === 'undefined') {
+        try {
+            WebSocketImplementation = require('ws');
+        } catch (err) {
+            throw new Error('You must install the "ws" package to use Strophe in nodejs.');
+        }
+    }
+    return WebSocketImplementation
+}
+export const WebSocket = getWebSocketImplementation()
+
+/**
+ * DOMParser
+ * https://w3c.github.io/DOM-Parsing/#the-domparser-interface
+ *
+ * Interface to parse XML strings into Document objects
+ *
+ * Used implementations:
+ * - supported browsers: built-in in DOMParser global
+ *   https://developer.mozilla.org/en-US/docs/Web/API/DOMParser#Browser_compatibility
+ * - nodejs: use 'xmldom' module
+ *   https://www.npmjs.com/package/xmldom
+ */
+function getDOMParserImplementation () {
+    let DOMParserImplementation = global.DOMParser
+    if (typeof DOMParserImplementation === 'undefined') {
+        try {
+            DOMParserImplementation = require('xmldom').DOMParser;
+        } catch (err) {
+            throw new Error('You must install the "xmldom" package to use Strophe in nodejs.');
+        }
+    }
+    return DOMParserImplementation
+}
+export const DOMParser = getDOMParserImplementation()
+
+/**
+ *  Gets IE xml doc object. Used by getDummyXMLDocument shim.
+ *
+ *  Returns:
+ *    A Microsoft XML DOM Object
+ *  See Also:
+ *    http://msdn.microsoft.com/en-us/library/ms757837%28VS.85%29.aspx
+ */
+function _getIEXmlDom () {
+    const docStrings = [
+        "Msxml2.DOMDocument.6.0",
+        "Msxml2.DOMDocument.5.0",
+        "Msxml2.DOMDocument.4.0",
+        "MSXML2.DOMDocument.3.0",
+        "MSXML2.DOMDocument",
+        "MSXML.DOMDocument",
+        "Microsoft.XMLDOM"
+    ];
+    for (let d = 0; d < docStrings.length; d++) {
+        try {
+            // eslint-disable-next-line no-undef
+            const doc = new ActiveXObject(docStrings[d]);
+            return doc
+        } catch (e) {
+            // Try next one
+        }
+    }
+}
+
+/**
+ * Creates a dummy XML DOM document to serve as an element and text node generator.
+ *
+ * Used implementations:
+ *  - IE < 10: avoid using createDocument() due to a memory leak, use ie-specific
+ *    workaround
+ *  - other supported browsers: use document's createDocument
+ *  - nodejs: use 'xmldom'
+ */
+export function getDummyXMLDOMDocument () {
+    // nodejs
+    if (typeof document === 'undefined') {
+        try {
+            const DOMImplementation = require('xmldom').DOMImplementation;
+            return new DOMImplementation().createDocument('jabber:client', 'strophe', null);
+        } catch (err) {
+            throw new Error('You must install the "xmldom" package to use Strophe in nodejs.');
+        }
+    }
+    // IE < 10
+    if (
+        document.implementation.createDocument === undefined ||
+        document.implementation.createDocument && document.documentMode && document.documentMode < 10
+    ) {
+        const doc = _getIEXmlDom();
+        doc.appendChild(doc.createElement('strophe'));
+        return doc
+    }
+    // All other supported browsers
+    return document.implementation.createDocument('jabber:client', 'strophe', null)
+}
+

package/strophejs-1.4.0/src/strophe.js

@@ -0,0 +1,14 @@
+/*global global*/
+
+import './bosh';
+import './websocket';
+import './worker-websocket';
+import * as strophe from './core';
+
+global.$build = strophe.default.$build;
+global.$iq = strophe.default.$iq;
+global.$msg = strophe.default.$msg;
+global.$pres = strophe.default.$pres;
+global.Strophe = strophe.default.Strophe;
+
+export { Strophe, $build, $iq, $msg, $pres } from './core';

package/strophejs-1.4.0/src/utils.js

@@ -0,0 +1,63 @@
+const utils = {
+
+    utf16to8: function (str) {
+        var i, c;
+        var out = "";
+        var len = str.length;
+        for (i = 0; i < len; i++) {
+            c = str.charCodeAt(i);
+            if ((c >= 0x0000) && (c <= 0x007F)) {
+                out += str.charAt(i);
+            } else if (c > 0x07FF) {
+                out += String.fromCharCode(0xE0 | ((c >> 12) & 0x0F));
+                out += String.fromCharCode(0x80 | ((c >>  6) & 0x3F));
+                out += String.fromCharCode(0x80 | ((c >>  0) & 0x3F));
+            } else {
+                out += String.fromCharCode(0xC0 | ((c >>  6) & 0x1F));
+                out += String.fromCharCode(0x80 | ((c >>  0) & 0x3F));
+            }
+        }
+        return out;
+    },
+
+    addCookies: function (cookies) {
+        /* Parameters:
+         *  (Object) cookies - either a map of cookie names
+         *    to string values or to maps of cookie values.
+         *
+         * For example:
+         * { "myCookie": "1234" }
+         *
+         * or:
+         * { "myCookie": {
+         *      "value": "1234",
+         *      "domain": ".example.org",
+         *      "path": "/",
+         *      "expires": expirationDate
+         *      }
+         *  }
+         *
+         *  These values get passed to Strophe.Connection via
+         *   options.cookies
+         */
+        cookies = cookies || {};
+        for (const cookieName in cookies) {
+            if (Object.prototype.hasOwnProperty.call(cookies, cookieName)) {
+                let expires = '';
+                let domain = '';
+                let path = '';
+                const cookieObj = cookies[cookieName];
+                const isObj = typeof cookieObj === "object";
+                const cookieValue = escape(unescape(isObj ? cookieObj.value : cookieObj));
+                if (isObj) {
+                    expires = cookieObj.expires ? ";expires="+cookieObj.expires : '';
+                    domain = cookieObj.domain ? ";domain="+cookieObj.domain : '';
+                    path = cookieObj.path ? ";path="+cookieObj.path : '';
+                }
+                document.cookie = cookieName+'='+cookieValue + expires + domain + path;
+            }
+        }
+    }
+};
+
+export { utils as default };