@waku/core 0.0.22 → 0.0.23

package/bundle/{version_0-86411fdf.js → version_0-74b4b9db.js}

@@ -2,783 +2,838 @@ import { c as commonjsGlobal, g as getDefaultExportFromCjs, d as debug } from '.
 
 var minimal = {};
 
-var aspromise = asPromise;
+var aspromise;
+var hasRequiredAspromise;
+
+function requireAspromise () {
+	if (hasRequiredAspromise) return aspromise;
+	hasRequiredAspromise = 1;
+	aspromise = asPromise;
 
-/**
- * Callback as used by {@link util.asPromise}.
- * @typedef asPromiseCallback
- * @type {function}
- * @param {Error|null} error Error, if any
- * @param {...*} params Additional arguments
- * @returns {undefined}
- */
+	/**
+	 * Callback as used by {@link util.asPromise}.
+	 * @typedef asPromiseCallback
+	 * @type {function}
+	 * @param {Error|null} error Error, if any
+	 * @param {...*} params Additional arguments
+	 * @returns {undefined}
+	 */
 
-/**
- * Returns a promise from a node-style callback function.
- * @memberof util
- * @param {asPromiseCallback} fn Function to call
- * @param {*} ctx Function context
- * @param {...*} params Function arguments
- * @returns {Promise<*>} Promisified function
- */
-function asPromise(fn, ctx/*, varargs */) {
-    var params  = new Array(arguments.length - 1),
-        offset  = 0,
-        index   = 2,
-        pending = true;
-    while (index < arguments.length)
-        params[offset++] = arguments[index++];
-    return new Promise(function executor(resolve, reject) {
-        params[offset] = function callback(err/*, varargs */) {
-            if (pending) {
-                pending = false;
-                if (err)
-                    reject(err);
-                else {
-                    var params = new Array(arguments.length - 1),
-                        offset = 0;
-                    while (offset < params.length)
-                        params[offset++] = arguments[offset];
-                    resolve.apply(null, params);
-                }
-            }
-        };
-        try {
-            fn.apply(ctx || null, params);
-        } catch (err) {
-            if (pending) {
-                pending = false;
-                reject(err);
-            }
-        }
-    });
+	/**
+	 * Returns a promise from a node-style callback function.
+	 * @memberof util
+	 * @param {asPromiseCallback} fn Function to call
+	 * @param {*} ctx Function context
+	 * @param {...*} params Function arguments
+	 * @returns {Promise<*>} Promisified function
+	 */
+	function asPromise(fn, ctx/*, varargs */) {
+	    var params  = new Array(arguments.length - 1),
+	        offset  = 0,
+	        index   = 2,
+	        pending = true;
+	    while (index < arguments.length)
+	        params[offset++] = arguments[index++];
+	    return new Promise(function executor(resolve, reject) {
+	        params[offset] = function callback(err/*, varargs */) {
+	            if (pending) {
+	                pending = false;
+	                if (err)
+	                    reject(err);
+	                else {
+	                    var params = new Array(arguments.length - 1),
+	                        offset = 0;
+	                    while (offset < params.length)
+	                        params[offset++] = arguments[offset];
+	                    resolve.apply(null, params);
+	                }
+	            }
+	        };
+	        try {
+	            fn.apply(ctx || null, params);
+	        } catch (err) {
+	            if (pending) {
+	                pending = false;
+	                reject(err);
+	            }
+	        }
+	    });
+	}
+	return aspromise;
 }
 
 var base64$1 = {};
 
-(function (exports) {
+var hasRequiredBase64;
+
+function requireBase64 () {
+	if (hasRequiredBase64) return base64$1;
+	hasRequiredBase64 = 1;
+	(function (exports) {
 
-	/**
-	 * A minimal base64 implementation for number arrays.
-	 * @memberof util
-	 * @namespace
-	 */
-	var base64 = exports;
+		/**
+		 * A minimal base64 implementation for number arrays.
+		 * @memberof util
+		 * @namespace
+		 */
+		var base64 = exports;
 
-	/**
-	 * Calculates the byte length of a base64 encoded string.
-	 * @param {string} string Base64 encoded string
-	 * @returns {number} Byte length
-	 */
-	base64.length = function length(string) {
-	    var p = string.length;
-	    if (!p)
-	        return 0;
-	    var n = 0;
-	    while (--p % 4 > 1 && string.charAt(p) === "=")
-	        ++n;
-	    return Math.ceil(string.length * 3) / 4 - n;
-	};
+		/**
+		 * Calculates the byte length of a base64 encoded string.
+		 * @param {string} string Base64 encoded string
+		 * @returns {number} Byte length
+		 */
+		base64.length = function length(string) {
+		    var p = string.length;
+		    if (!p)
+		        return 0;
+		    var n = 0;
+		    while (--p % 4 > 1 && string.charAt(p) === "=")
+		        ++n;
+		    return Math.ceil(string.length * 3) / 4 - n;
+		};
+
+		// Base64 encoding table
+		var b64 = new Array(64);
+
+		// Base64 decoding table
+		var s64 = new Array(123);
+
+		// 65..90, 97..122, 48..57, 43, 47
+		for (var i = 0; i < 64;)
+		    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
+
+		/**
+		 * Encodes a buffer to a base64 encoded string.
+		 * @param {Uint8Array} buffer Source buffer
+		 * @param {number} start Source start
+		 * @param {number} end Source end
+		 * @returns {string} Base64 encoded string
+		 */
+		base64.encode = function encode(buffer, start, end) {
+		    var parts = null,
+		        chunk = [];
+		    var i = 0, // output index
+		        j = 0, // goto index
+		        t;     // temporary
+		    while (start < end) {
+		        var b = buffer[start++];
+		        switch (j) {
+		            case 0:
+		                chunk[i++] = b64[b >> 2];
+		                t = (b & 3) << 4;
+		                j = 1;
+		                break;
+		            case 1:
+		                chunk[i++] = b64[t | b >> 4];
+		                t = (b & 15) << 2;
+		                j = 2;
+		                break;
+		            case 2:
+		                chunk[i++] = b64[t | b >> 6];
+		                chunk[i++] = b64[b & 63];
+		                j = 0;
+		                break;
+		        }
+		        if (i > 8191) {
+		            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+		            i = 0;
+		        }
+		    }
+		    if (j) {
+		        chunk[i++] = b64[t];
+		        chunk[i++] = 61;
+		        if (j === 1)
+		            chunk[i++] = 61;
+		    }
+		    if (parts) {
+		        if (i)
+		            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+		        return parts.join("");
+		    }
+		    return String.fromCharCode.apply(String, chunk.slice(0, i));
+		};
 
-	// Base64 encoding table
-	var b64 = new Array(64);
+		var invalidEncoding = "invalid encoding";
 
-	// Base64 decoding table
-	var s64 = new Array(123);
+		/**
+		 * Decodes a base64 encoded string to a buffer.
+		 * @param {string} string Source string
+		 * @param {Uint8Array} buffer Destination buffer
+		 * @param {number} offset Destination offset
+		 * @returns {number} Number of bytes written
+		 * @throws {Error} If encoding is invalid
+		 */
+		base64.decode = function decode(string, buffer, offset) {
+		    var start = offset;
+		    var j = 0, // goto index
+		        t;     // temporary
+		    for (var i = 0; i < string.length;) {
+		        var c = string.charCodeAt(i++);
+		        if (c === 61 && j > 1)
+		            break;
+		        if ((c = s64[c]) === undefined)
+		            throw Error(invalidEncoding);
+		        switch (j) {
+		            case 0:
+		                t = c;
+		                j = 1;
+		                break;
+		            case 1:
+		                buffer[offset++] = t << 2 | (c & 48) >> 4;
+		                t = c;
+		                j = 2;
+		                break;
+		            case 2:
+		                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
+		                t = c;
+		                j = 3;
+		                break;
+		            case 3:
+		                buffer[offset++] = (t & 3) << 6 | c;
+		                j = 0;
+		                break;
+		        }
+		    }
+		    if (j === 1)
+		        throw Error(invalidEncoding);
+		    return offset - start;
+		};
 
-	// 65..90, 97..122, 48..57, 43, 47
-	for (var i = 0; i < 64;)
-	    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
+		/**
+		 * Tests if the specified string appears to be base64 encoded.
+		 * @param {string} string String to test
+		 * @returns {boolean} `true` if probably base64 encoded, otherwise false
+		 */
+		base64.test = function test(string) {
+		    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
+		}; 
+	} (base64$1));
+	return base64$1;
+}
+
+var eventemitter;
+var hasRequiredEventemitter;
+
+function requireEventemitter () {
+	if (hasRequiredEventemitter) return eventemitter;
+	hasRequiredEventemitter = 1;
+	eventemitter = EventEmitter;
 
 	/**
-	 * Encodes a buffer to a base64 encoded string.
-	 * @param {Uint8Array} buffer Source buffer
-	 * @param {number} start Source start
-	 * @param {number} end Source end
-	 * @returns {string} Base64 encoded string
+	 * Constructs a new event emitter instance.
+	 * @classdesc A minimal event emitter.
+	 * @memberof util
+	 * @constructor
 	 */
-	base64.encode = function encode(buffer, start, end) {
-	    var parts = null,
-	        chunk = [];
-	    var i = 0, // output index
-	        j = 0, // goto index
-	        t;     // temporary
-	    while (start < end) {
-	        var b = buffer[start++];
-	        switch (j) {
-	            case 0:
-	                chunk[i++] = b64[b >> 2];
-	                t = (b & 3) << 4;
-	                j = 1;
-	                break;
-	            case 1:
-	                chunk[i++] = b64[t | b >> 4];
-	                t = (b & 15) << 2;
-	                j = 2;
-	                break;
-	            case 2:
-	                chunk[i++] = b64[t | b >> 6];
-	                chunk[i++] = b64[b & 63];
-	                j = 0;
-	                break;
-	        }
-	        if (i > 8191) {
-	            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
-	            i = 0;
-	        }
-	    }
-	    if (j) {
-	        chunk[i++] = b64[t];
-	        chunk[i++] = 61;
-	        if (j === 1)
-	            chunk[i++] = 61;
-	    }
-	    if (parts) {
-	        if (i)
-	            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
-	        return parts.join("");
-	    }
-	    return String.fromCharCode.apply(String, chunk.slice(0, i));
-	};
+	function EventEmitter() {
 
-	var invalidEncoding = "invalid encoding";
+	    /**
+	     * Registered listeners.
+	     * @type {Object.<string,*>}
+	     * @private
+	     */
+	    this._listeners = {};
+	}
+
+	/**
+	 * Registers an event listener.
+	 * @param {string} evt Event name
+	 * @param {function} fn Listener
+	 * @param {*} [ctx] Listener context
+	 * @returns {util.EventEmitter} `this`
+	 */
+	EventEmitter.prototype.on = function on(evt, fn, ctx) {
+	    (this._listeners[evt] || (this._listeners[evt] = [])).push({
+	        fn  : fn,
+	        ctx : ctx || this
+	    });
+	    return this;
+	};
 
 	/**
-	 * Decodes a base64 encoded string to a buffer.
-	 * @param {string} string Source string
-	 * @param {Uint8Array} buffer Destination buffer
-	 * @param {number} offset Destination offset
-	 * @returns {number} Number of bytes written
-	 * @throws {Error} If encoding is invalid
+	 * Removes an event listener or any matching listeners if arguments are omitted.
+	 * @param {string} [evt] Event name. Removes all listeners if omitted.
+	 * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
+	 * @returns {util.EventEmitter} `this`
 	 */
-	base64.decode = function decode(string, buffer, offset) {
-	    var start = offset;
-	    var j = 0, // goto index
-	        t;     // temporary
-	    for (var i = 0; i < string.length;) {
-	        var c = string.charCodeAt(i++);
-	        if (c === 61 && j > 1)
-	            break;
-	        if ((c = s64[c]) === undefined)
-	            throw Error(invalidEncoding);
-	        switch (j) {
-	            case 0:
-	                t = c;
-	                j = 1;
-	                break;
-	            case 1:
-	                buffer[offset++] = t << 2 | (c & 48) >> 4;
-	                t = c;
-	                j = 2;
-	                break;
-	            case 2:
-	                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
-	                t = c;
-	                j = 3;
-	                break;
-	            case 3:
-	                buffer[offset++] = (t & 3) << 6 | c;
-	                j = 0;
-	                break;
+	EventEmitter.prototype.off = function off(evt, fn) {
+	    if (evt === undefined)
+	        this._listeners = {};
+	    else {
+	        if (fn === undefined)
+	            this._listeners[evt] = [];
+	        else {
+	            var listeners = this._listeners[evt];
+	            for (var i = 0; i < listeners.length;)
+	                if (listeners[i].fn === fn)
+	                    listeners.splice(i, 1);
+	                else
+	                    ++i;
 	        }
 	    }
-	    if (j === 1)
-	        throw Error(invalidEncoding);
-	    return offset - start;
+	    return this;
 	};
 
 	/**
-	 * Tests if the specified string appears to be base64 encoded.
-	 * @param {string} string String to test
-	 * @returns {boolean} `true` if probably base64 encoded, otherwise false
+	 * Emits an event by calling its listeners with the specified arguments.
+	 * @param {string} evt Event name
+	 * @param {...*} args Arguments
+	 * @returns {util.EventEmitter} `this`
 	 */
-	base64.test = function test(string) {
-	    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
-	}; 
-} (base64$1));
+	EventEmitter.prototype.emit = function emit(evt) {
+	    var listeners = this._listeners[evt];
+	    if (listeners) {
+	        var args = [],
+	            i = 1;
+	        for (; i < arguments.length;)
+	            args.push(arguments[i++]);
+	        for (i = 0; i < listeners.length;)
+	            listeners[i].fn.apply(listeners[i++].ctx, args);
+	    }
+	    return this;
+	};
+	return eventemitter;
+}
 
-var eventemitter = EventEmitter;
-
-/**
- * Constructs a new event emitter instance.
- * @classdesc A minimal event emitter.
- * @memberof util
- * @constructor
- */
-function EventEmitter() {
-
-    /**
-     * Registered listeners.
-     * @type {Object.<string,*>}
-     * @private
-     */
-    this._listeners = {};
-}
-
-/**
- * Registers an event listener.
- * @param {string} evt Event name
- * @param {function} fn Listener
- * @param {*} [ctx] Listener context
- * @returns {util.EventEmitter} `this`
- */
-EventEmitter.prototype.on = function on(evt, fn, ctx) {
-    (this._listeners[evt] || (this._listeners[evt] = [])).push({
-        fn  : fn,
-        ctx : ctx || this
-    });
-    return this;
-};
-
-/**
- * Removes an event listener or any matching listeners if arguments are omitted.
- * @param {string} [evt] Event name. Removes all listeners if omitted.
- * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
- * @returns {util.EventEmitter} `this`
- */
-EventEmitter.prototype.off = function off(evt, fn) {
-    if (evt === undefined)
-        this._listeners = {};
-    else {
-        if (fn === undefined)
-            this._listeners[evt] = [];
-        else {
-            var listeners = this._listeners[evt];
-            for (var i = 0; i < listeners.length;)
-                if (listeners[i].fn === fn)
-                    listeners.splice(i, 1);
-                else
-                    ++i;
-        }
-    }
-    return this;
-};
-
-/**
- * Emits an event by calling its listeners with the specified arguments.
- * @param {string} evt Event name
- * @param {...*} args Arguments
- * @returns {util.EventEmitter} `this`
- */
-EventEmitter.prototype.emit = function emit(evt) {
-    var listeners = this._listeners[evt];
-    if (listeners) {
-        var args = [],
-            i = 1;
-        for (; i < arguments.length;)
-            args.push(arguments[i++]);
-        for (i = 0; i < listeners.length;)
-            listeners[i].fn.apply(listeners[i++].ctx, args);
-    }
-    return this;
-};
+var float;
+var hasRequiredFloat;
 
-var float = factory(factory);
+function requireFloat () {
+	if (hasRequiredFloat) return float;
+	hasRequiredFloat = 1;
 
-/**
- * Reads / writes floats / doubles from / to buffers.
- * @name util.float
- * @namespace
- */
+	float = factory(factory);
 
-/**
- * Writes a 32 bit float to a buffer using little endian byte order.
- * @name util.float.writeFloatLE
- * @function
- * @param {number} val Value to write
- * @param {Uint8Array} buf Target buffer
- * @param {number} pos Target buffer offset
- * @returns {undefined}
- */
+	/**
+	 * Reads / writes floats / doubles from / to buffers.
+	 * @name util.float
+	 * @namespace
+	 */
 
-/**
- * Writes a 32 bit float to a buffer using big endian byte order.
- * @name util.float.writeFloatBE
- * @function
- * @param {number} val Value to write
- * @param {Uint8Array} buf Target buffer
- * @param {number} pos Target buffer offset
- * @returns {undefined}
- */
+	/**
+	 * Writes a 32 bit float to a buffer using little endian byte order.
+	 * @name util.float.writeFloatLE
+	 * @function
+	 * @param {number} val Value to write
+	 * @param {Uint8Array} buf Target buffer
+	 * @param {number} pos Target buffer offset
+	 * @returns {undefined}
+	 */
+
+	/**
+	 * Writes a 32 bit float to a buffer using big endian byte order.
+	 * @name util.float.writeFloatBE
+	 * @function
+	 * @param {number} val Value to write
+	 * @param {Uint8Array} buf Target buffer
+	 * @param {number} pos Target buffer offset
+	 * @returns {undefined}
+	 */
 
-/**
- * Reads a 32 bit float from a buffer using little endian byte order.
- * @name util.float.readFloatLE
- * @function
- * @param {Uint8Array} buf Source buffer
- * @param {number} pos Source buffer offset
- * @returns {number} Value read
- */
+	/**
+	 * Reads a 32 bit float from a buffer using little endian byte order.
+	 * @name util.float.readFloatLE
+	 * @function
+	 * @param {Uint8Array} buf Source buffer
+	 * @param {number} pos Source buffer offset
+	 * @returns {number} Value read
+	 */
 
-/**
- * Reads a 32 bit float from a buffer using big endian byte order.
- * @name util.float.readFloatBE
- * @function
- * @param {Uint8Array} buf Source buffer
- * @param {number} pos Source buffer offset
- * @returns {number} Value read
- */
+	/**
+	 * Reads a 32 bit float from a buffer using big endian byte order.
+	 * @name util.float.readFloatBE
+	 * @function
+	 * @param {Uint8Array} buf Source buffer
+	 * @param {number} pos Source buffer offset
+	 * @returns {number} Value read
+	 */
 
-/**
- * Writes a 64 bit double to a buffer using little endian byte order.
- * @name util.float.writeDoubleLE
- * @function
- * @param {number} val Value to write
- * @param {Uint8Array} buf Target buffer
- * @param {number} pos Target buffer offset
- * @returns {undefined}
- */
+	/**
+	 * Writes a 64 bit double to a buffer using little endian byte order.
+	 * @name util.float.writeDoubleLE
+	 * @function
+	 * @param {number} val Value to write
+	 * @param {Uint8Array} buf Target buffer
+	 * @param {number} pos Target buffer offset
+	 * @returns {undefined}
+	 */
 
-/**
- * Writes a 64 bit double to a buffer using big endian byte order.
- * @name util.float.writeDoubleBE
- * @function
- * @param {number} val Value to write
- * @param {Uint8Array} buf Target buffer
- * @param {number} pos Target buffer offset
- * @returns {undefined}
- */
+	/**
+	 * Writes a 64 bit double to a buffer using big endian byte order.
+	 * @name util.float.writeDoubleBE
+	 * @function
+	 * @param {number} val Value to write
+	 * @param {Uint8Array} buf Target buffer
+	 * @param {number} pos Target buffer offset
+	 * @returns {undefined}
+	 */
 
-/**
- * Reads a 64 bit double from a buffer using little endian byte order.
- * @name util.float.readDoubleLE
- * @function
- * @param {Uint8Array} buf Source buffer
- * @param {number} pos Source buffer offset
- * @returns {number} Value read
- */
+	/**
+	 * Reads a 64 bit double from a buffer using little endian byte order.
+	 * @name util.float.readDoubleLE
+	 * @function
+	 * @param {Uint8Array} buf Source buffer
+	 * @param {number} pos Source buffer offset
+	 * @returns {number} Value read
+	 */
 
-/**
- * Reads a 64 bit double from a buffer using big endian byte order.
- * @name util.float.readDoubleBE
- * @function
- * @param {Uint8Array} buf Source buffer
- * @param {number} pos Source buffer offset
- * @returns {number} Value read
- */
+	/**
+	 * Reads a 64 bit double from a buffer using big endian byte order.
+	 * @name util.float.readDoubleBE
+	 * @function
+	 * @param {Uint8Array} buf Source buffer
+	 * @param {number} pos Source buffer offset
+	 * @returns {number} Value read
+	 */
 
-// Factory function for the purpose of node-based testing in modified global environments
-function factory(exports) {
+	// Factory function for the purpose of node-based testing in modified global environments
+	function factory(exports) {
 
-    // float: typed array
-    if (typeof Float32Array !== "undefined") (function() {
+	    // float: typed array
+	    if (typeof Float32Array !== "undefined") (function() {
 
-        var f32 = new Float32Array([ -0 ]),
-            f8b = new Uint8Array(f32.buffer),
-            le  = f8b[3] === 128;
+	        var f32 = new Float32Array([ -0 ]),
+	            f8b = new Uint8Array(f32.buffer),
+	            le  = f8b[3] === 128;
 
-        function writeFloat_f32_cpy(val, buf, pos) {
-            f32[0] = val;
-            buf[pos    ] = f8b[0];
-            buf[pos + 1] = f8b[1];
-            buf[pos + 2] = f8b[2];
-            buf[pos + 3] = f8b[3];
-        }
+	        function writeFloat_f32_cpy(val, buf, pos) {
+	            f32[0] = val;
+	            buf[pos    ] = f8b[0];
+	            buf[pos + 1] = f8b[1];
+	            buf[pos + 2] = f8b[2];
+	            buf[pos + 3] = f8b[3];
+	        }
 
-        function writeFloat_f32_rev(val, buf, pos) {
-            f32[0] = val;
-            buf[pos    ] = f8b[3];
-            buf[pos + 1] = f8b[2];
-            buf[pos + 2] = f8b[1];
-            buf[pos + 3] = f8b[0];
-        }
+	        function writeFloat_f32_rev(val, buf, pos) {
+	            f32[0] = val;
+	            buf[pos    ] = f8b[3];
+	            buf[pos + 1] = f8b[2];
+	            buf[pos + 2] = f8b[1];
+	            buf[pos + 3] = f8b[0];
+	        }
 
-        /* istanbul ignore next */
-        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
-        /* istanbul ignore next */
-        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
+	        /* istanbul ignore next */
+	        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
+	        /* istanbul ignore next */
+	        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
 
-        function readFloat_f32_cpy(buf, pos) {
-            f8b[0] = buf[pos    ];
-            f8b[1] = buf[pos + 1];
-            f8b[2] = buf[pos + 2];
-            f8b[3] = buf[pos + 3];
-            return f32[0];
-        }
+	        function readFloat_f32_cpy(buf, pos) {
+	            f8b[0] = buf[pos    ];
+	            f8b[1] = buf[pos + 1];
+	            f8b[2] = buf[pos + 2];
+	            f8b[3] = buf[pos + 3];
+	            return f32[0];
+	        }
 
-        function readFloat_f32_rev(buf, pos) {
-            f8b[3] = buf[pos    ];
-            f8b[2] = buf[pos + 1];
-            f8b[1] = buf[pos + 2];
-            f8b[0] = buf[pos + 3];
-            return f32[0];
-        }
+	        function readFloat_f32_rev(buf, pos) {
+	            f8b[3] = buf[pos    ];
+	            f8b[2] = buf[pos + 1];
+	            f8b[1] = buf[pos + 2];
+	            f8b[0] = buf[pos + 3];
+	            return f32[0];
+	        }
 
-        /* istanbul ignore next */
-        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
-        /* istanbul ignore next */
-        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
+	        /* istanbul ignore next */
+	        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
+	        /* istanbul ignore next */
+	        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
 
-    // float: ieee754
-    })(); else (function() {
+	    // float: ieee754
+	    })(); else (function() {
 
-        function writeFloat_ieee754(writeUint, val, buf, pos) {
-            var sign = val < 0 ? 1 : 0;
-            if (sign)
-                val = -val;
-            if (val === 0)
-                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);
-            else if (isNaN(val))
-                writeUint(2143289344, buf, pos);
-            else if (val > 3.4028234663852886e+38) // +-Infinity
-                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
-            else if (val < 1.1754943508222875e-38) // denormal
-                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);
-            else {
-                var exponent = Math.floor(Math.log(val) / Math.LN2),
-                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
-                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
-            }
-        }
+	        function writeFloat_ieee754(writeUint, val, buf, pos) {
+	            var sign = val < 0 ? 1 : 0;
+	            if (sign)
+	                val = -val;
+	            if (val === 0)
+	                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);
+	            else if (isNaN(val))
+	                writeUint(2143289344, buf, pos);
+	            else if (val > 3.4028234663852886e+38) // +-Infinity
+	                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
+	            else if (val < 1.1754943508222875e-38) // denormal
+	                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);
+	            else {
+	                var exponent = Math.floor(Math.log(val) / Math.LN2),
+	                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
+	                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
+	            }
+	        }
 
-        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
-        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
+	        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
+	        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
 
-        function readFloat_ieee754(readUint, buf, pos) {
-            var uint = readUint(buf, pos),
-                sign = (uint >> 31) * 2 + 1,
-                exponent = uint >>> 23 & 255,
-                mantissa = uint & 8388607;
-            return exponent === 255
-                ? mantissa
-                ? NaN
-                : sign * Infinity
-                : exponent === 0 // denormal
-                ? sign * 1.401298464324817e-45 * mantissa
-                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
-        }
+	        function readFloat_ieee754(readUint, buf, pos) {
+	            var uint = readUint(buf, pos),
+	                sign = (uint >> 31) * 2 + 1,
+	                exponent = uint >>> 23 & 255,
+	                mantissa = uint & 8388607;
+	            return exponent === 255
+	                ? mantissa
+	                ? NaN
+	                : sign * Infinity
+	                : exponent === 0 // denormal
+	                ? sign * 1.401298464324817e-45 * mantissa
+	                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
+	        }
 
-        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
-        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
+	        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
+	        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
 
-    })();
+	    })();
 
-    // double: typed array
-    if (typeof Float64Array !== "undefined") (function() {
+	    // double: typed array
+	    if (typeof Float64Array !== "undefined") (function() {
 
-        var f64 = new Float64Array([-0]),
-            f8b = new Uint8Array(f64.buffer),
-            le  = f8b[7] === 128;
+	        var f64 = new Float64Array([-0]),
+	            f8b = new Uint8Array(f64.buffer),
+	            le  = f8b[7] === 128;
 
-        function writeDouble_f64_cpy(val, buf, pos) {
-            f64[0] = val;
-            buf[pos    ] = f8b[0];
-            buf[pos + 1] = f8b[1];
-            buf[pos + 2] = f8b[2];
-            buf[pos + 3] = f8b[3];
-            buf[pos + 4] = f8b[4];
-            buf[pos + 5] = f8b[5];
-            buf[pos + 6] = f8b[6];
-            buf[pos + 7] = f8b[7];
-        }
+	        function writeDouble_f64_cpy(val, buf, pos) {
+	            f64[0] = val;
+	            buf[pos    ] = f8b[0];
+	            buf[pos + 1] = f8b[1];
+	            buf[pos + 2] = f8b[2];
+	            buf[pos + 3] = f8b[3];
+	            buf[pos + 4] = f8b[4];
+	            buf[pos + 5] = f8b[5];
+	            buf[pos + 6] = f8b[6];
+	            buf[pos + 7] = f8b[7];
+	        }
 
-        function writeDouble_f64_rev(val, buf, pos) {
-            f64[0] = val;
-            buf[pos    ] = f8b[7];
-            buf[pos + 1] = f8b[6];
-            buf[pos + 2] = f8b[5];
-            buf[pos + 3] = f8b[4];
-            buf[pos + 4] = f8b[3];
-            buf[pos + 5] = f8b[2];
-            buf[pos + 6] = f8b[1];
-            buf[pos + 7] = f8b[0];
-        }
+	        function writeDouble_f64_rev(val, buf, pos) {
+	            f64[0] = val;
+	            buf[pos    ] = f8b[7];
+	            buf[pos + 1] = f8b[6];
+	            buf[pos + 2] = f8b[5];
+	            buf[pos + 3] = f8b[4];
+	            buf[pos + 4] = f8b[3];
+	            buf[pos + 5] = f8b[2];
+	            buf[pos + 6] = f8b[1];
+	            buf[pos + 7] = f8b[0];
+	        }
 
-        /* istanbul ignore next */
-        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
-        /* istanbul ignore next */
-        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
+	        /* istanbul ignore next */
+	        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
+	        /* istanbul ignore next */
+	        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
 
-        function readDouble_f64_cpy(buf, pos) {
-            f8b[0] = buf[pos    ];
-            f8b[1] = buf[pos + 1];
-            f8b[2] = buf[pos + 2];
-            f8b[3] = buf[pos + 3];
-            f8b[4] = buf[pos + 4];
-            f8b[5] = buf[pos + 5];
-            f8b[6] = buf[pos + 6];
-            f8b[7] = buf[pos + 7];
-            return f64[0];
-        }
+	        function readDouble_f64_cpy(buf, pos) {
+	            f8b[0] = buf[pos    ];
+	            f8b[1] = buf[pos + 1];
+	            f8b[2] = buf[pos + 2];
+	            f8b[3] = buf[pos + 3];
+	            f8b[4] = buf[pos + 4];
+	            f8b[5] = buf[pos + 5];
+	            f8b[6] = buf[pos + 6];
+	            f8b[7] = buf[pos + 7];
+	            return f64[0];
+	        }
 
-        function readDouble_f64_rev(buf, pos) {
-            f8b[7] = buf[pos    ];
-            f8b[6] = buf[pos + 1];
-            f8b[5] = buf[pos + 2];
-            f8b[4] = buf[pos + 3];
-            f8b[3] = buf[pos + 4];
-            f8b[2] = buf[pos + 5];
-            f8b[1] = buf[pos + 6];
-            f8b[0] = buf[pos + 7];
-            return f64[0];
-        }
+	        function readDouble_f64_rev(buf, pos) {
+	            f8b[7] = buf[pos    ];
+	            f8b[6] = buf[pos + 1];
+	            f8b[5] = buf[pos + 2];
+	            f8b[4] = buf[pos + 3];
+	            f8b[3] = buf[pos + 4];
+	            f8b[2] = buf[pos + 5];
+	            f8b[1] = buf[pos + 6];
+	            f8b[0] = buf[pos + 7];
+	            return f64[0];
+	        }
 
-        /* istanbul ignore next */
-        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
-        /* istanbul ignore next */
-        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
+	        /* istanbul ignore next */
+	        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
+	        /* istanbul ignore next */
+	        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
 
-    // double: ieee754
-    })(); else (function() {
+	    // double: ieee754
+	    })(); else (function() {
 
-        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
-            var sign = val < 0 ? 1 : 0;
-            if (sign)
-                val = -val;
-            if (val === 0) {
-                writeUint(0, buf, pos + off0);
-                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);
-            } else if (isNaN(val)) {
-                writeUint(0, buf, pos + off0);
-                writeUint(2146959360, buf, pos + off1);
-            } else if (val > 1.7976931348623157e+308) { // +-Infinity
-                writeUint(0, buf, pos + off0);
-                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
-            } else {
-                var mantissa;
-                if (val < 2.2250738585072014e-308) { // denormal
-                    mantissa = val / 5e-324;
-                    writeUint(mantissa >>> 0, buf, pos + off0);
-                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
-                } else {
-                    var exponent = Math.floor(Math.log(val) / Math.LN2);
-                    if (exponent === 1024)
-                        exponent = 1023;
-                    mantissa = val * Math.pow(2, -exponent);
-                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
-                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
-                }
-            }
-        }
+	        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
+	            var sign = val < 0 ? 1 : 0;
+	            if (sign)
+	                val = -val;
+	            if (val === 0) {
+	                writeUint(0, buf, pos + off0);
+	                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);
+	            } else if (isNaN(val)) {
+	                writeUint(0, buf, pos + off0);
+	                writeUint(2146959360, buf, pos + off1);
+	            } else if (val > 1.7976931348623157e+308) { // +-Infinity
+	                writeUint(0, buf, pos + off0);
+	                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
+	            } else {
+	                var mantissa;
+	                if (val < 2.2250738585072014e-308) { // denormal
+	                    mantissa = val / 5e-324;
+	                    writeUint(mantissa >>> 0, buf, pos + off0);
+	                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
+	                } else {
+	                    var exponent = Math.floor(Math.log(val) / Math.LN2);
+	                    if (exponent === 1024)
+	                        exponent = 1023;
+	                    mantissa = val * Math.pow(2, -exponent);
+	                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
+	                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
+	                }
+	            }
+	        }
 
-        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
-        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
+	        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
+	        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
 
-        function readDouble_ieee754(readUint, off0, off1, buf, pos) {
-            var lo = readUint(buf, pos + off0),
-                hi = readUint(buf, pos + off1);
-            var sign = (hi >> 31) * 2 + 1,
-                exponent = hi >>> 20 & 2047,
-                mantissa = 4294967296 * (hi & 1048575) + lo;
-            return exponent === 2047
-                ? mantissa
-                ? NaN
-                : sign * Infinity
-                : exponent === 0 // denormal
-                ? sign * 5e-324 * mantissa
-                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
-        }
+	        function readDouble_ieee754(readUint, off0, off1, buf, pos) {
+	            var lo = readUint(buf, pos + off0),
+	                hi = readUint(buf, pos + off1);
+	            var sign = (hi >> 31) * 2 + 1,
+	                exponent = hi >>> 20 & 2047,
+	                mantissa = 4294967296 * (hi & 1048575) + lo;
+	            return exponent === 2047
+	                ? mantissa
+	                ? NaN
+	                : sign * Infinity
+	                : exponent === 0 // denormal
+	                ? sign * 5e-324 * mantissa
+	                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
+	        }
 
-        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
-        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
+	        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
+	        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
 
-    })();
+	    })();
 
-    return exports;
-}
+	    return exports;
+	}
 
-// uint helpers
+	// uint helpers
 
-function writeUintLE(val, buf, pos) {
-    buf[pos    ] =  val        & 255;
-    buf[pos + 1] =  val >>> 8  & 255;
-    buf[pos + 2] =  val >>> 16 & 255;
-    buf[pos + 3] =  val >>> 24;
-}
+	function writeUintLE(val, buf, pos) {
+	    buf[pos    ] =  val        & 255;
+	    buf[pos + 1] =  val >>> 8  & 255;
+	    buf[pos + 2] =  val >>> 16 & 255;
+	    buf[pos + 3] =  val >>> 24;
+	}
 
-function writeUintBE(val, buf, pos) {
-    buf[pos    ] =  val >>> 24;
-    buf[pos + 1] =  val >>> 16 & 255;
-    buf[pos + 2] =  val >>> 8  & 255;
-    buf[pos + 3] =  val        & 255;
-}
+	function writeUintBE(val, buf, pos) {
+	    buf[pos    ] =  val >>> 24;
+	    buf[pos + 1] =  val >>> 16 & 255;
+	    buf[pos + 2] =  val >>> 8  & 255;
+	    buf[pos + 3] =  val        & 255;
+	}
 
-function readUintLE(buf, pos) {
-    return (buf[pos    ]
-          | buf[pos + 1] << 8
-          | buf[pos + 2] << 16
-          | buf[pos + 3] << 24) >>> 0;
-}
+	function readUintLE(buf, pos) {
+	    return (buf[pos    ]
+	          | buf[pos + 1] << 8
+	          | buf[pos + 2] << 16
+	          | buf[pos + 3] << 24) >>> 0;
+	}
 
-function readUintBE(buf, pos) {
-    return (buf[pos    ] << 24
-          | buf[pos + 1] << 16
-          | buf[pos + 2] << 8
-          | buf[pos + 3]) >>> 0;
+	function readUintBE(buf, pos) {
+	    return (buf[pos    ] << 24
+	          | buf[pos + 1] << 16
+	          | buf[pos + 2] << 8
+	          | buf[pos + 3]) >>> 0;
+	}
+	return float;
 }
 
-var inquire_1 = inquire;
+var inquire_1;
+var hasRequiredInquire;
+
+function requireInquire () {
+	if (hasRequiredInquire) return inquire_1;
+	hasRequiredInquire = 1;
+	inquire_1 = inquire;
 
-/**
- * Requires a module only if available.
- * @memberof util
- * @param {string} moduleName Module to require
- * @returns {?Object} Required module if available and not empty, otherwise `null`
- */
-function inquire(moduleName) {
-    try {
-        var mod = eval("quire".replace(/^/,"re"))(moduleName); // eslint-disable-line no-eval
-        if (mod && (mod.length || Object.keys(mod).length))
-            return mod;
-    } catch (e) {} // eslint-disable-line no-empty
-    return null;
+	/**
+	 * Requires a module only if available.
+	 * @memberof util
+	 * @param {string} moduleName Module to require
+	 * @returns {?Object} Required module if available and not empty, otherwise `null`
+	 */
+	function inquire(moduleName) {
+	    try {
+	        var mod = eval("quire".replace(/^/,"re"))(moduleName); // eslint-disable-line no-eval
+	        if (mod && (mod.length || Object.keys(mod).length))
+	            return mod;
+	    } catch (e) {} // eslint-disable-line no-empty
+	    return null;
+	}
+	return inquire_1;
 }
 
 var utf8$2 = {};
 
-(function (exports) {
+var hasRequiredUtf8;
+
+function requireUtf8 () {
+	if (hasRequiredUtf8) return utf8$2;
+	hasRequiredUtf8 = 1;
+	(function (exports) {
 
-	/**
-	 * A minimal UTF8 implementation for number arrays.
-	 * @memberof util
-	 * @namespace
-	 */
-	var utf8 = exports;
+		/**
+		 * A minimal UTF8 implementation for number arrays.
+		 * @memberof util
+		 * @namespace
+		 */
+		var utf8 = exports;
+
+		/**
+		 * Calculates the UTF8 byte length of a string.
+		 * @param {string} string String
+		 * @returns {number} Byte length
+		 */
+		utf8.length = function utf8_length(string) {
+		    var len = 0,
+		        c = 0;
+		    for (var i = 0; i < string.length; ++i) {
+		        c = string.charCodeAt(i);
+		        if (c < 128)
+		            len += 1;
+		        else if (c < 2048)
+		            len += 2;
+		        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
+		            ++i;
+		            len += 4;
+		        } else
+		            len += 3;
+		    }
+		    return len;
+		};
+
+		/**
+		 * Reads UTF8 bytes as a string.
+		 * @param {Uint8Array} buffer Source buffer
+		 * @param {number} start Source start
+		 * @param {number} end Source end
+		 * @returns {string} String read
+		 */
+		utf8.read = function utf8_read(buffer, start, end) {
+		    var len = end - start;
+		    if (len < 1)
+		        return "";
+		    var parts = null,
+		        chunk = [],
+		        i = 0, // char offset
+		        t;     // temporary
+		    while (start < end) {
+		        t = buffer[start++];
+		        if (t < 128)
+		            chunk[i++] = t;
+		        else if (t > 191 && t < 224)
+		            chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
+		        else if (t > 239 && t < 365) {
+		            t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;
+		            chunk[i++] = 0xD800 + (t >> 10);
+		            chunk[i++] = 0xDC00 + (t & 1023);
+		        } else
+		            chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
+		        if (i > 8191) {
+		            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+		            i = 0;
+		        }
+		    }
+		    if (parts) {
+		        if (i)
+		            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+		        return parts.join("");
+		    }
+		    return String.fromCharCode.apply(String, chunk.slice(0, i));
+		};
+
+		/**
+		 * Writes a string as UTF8 bytes.
+		 * @param {string} string Source string
+		 * @param {Uint8Array} buffer Destination buffer
+		 * @param {number} offset Destination offset
+		 * @returns {number} Bytes written
+		 */
+		utf8.write = function utf8_write(string, buffer, offset) {
+		    var start = offset,
+		        c1, // character 1
+		        c2; // character 2
+		    for (var i = 0; i < string.length; ++i) {
+		        c1 = string.charCodeAt(i);
+		        if (c1 < 128) {
+		            buffer[offset++] = c1;
+		        } else if (c1 < 2048) {
+		            buffer[offset++] = c1 >> 6       | 192;
+		            buffer[offset++] = c1       & 63 | 128;
+		        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
+		            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
+		            ++i;
+		            buffer[offset++] = c1 >> 18      | 240;
+		            buffer[offset++] = c1 >> 12 & 63 | 128;
+		            buffer[offset++] = c1 >> 6  & 63 | 128;
+		            buffer[offset++] = c1       & 63 | 128;
+		        } else {
+		            buffer[offset++] = c1 >> 12      | 224;
+		            buffer[offset++] = c1 >> 6  & 63 | 128;
+		            buffer[offset++] = c1       & 63 | 128;
+		        }
+		    }
+		    return offset - start;
+		}; 
+	} (utf8$2));
+	return utf8$2;
+}
+
+var pool_1;
+var hasRequiredPool;
+
+function requirePool () {
+	if (hasRequiredPool) return pool_1;
+	hasRequiredPool = 1;
+	pool_1 = pool;
 
 	/**
-	 * Calculates the UTF8 byte length of a string.
-	 * @param {string} string String
-	 * @returns {number} Byte length
+	 * An allocator as used by {@link util.pool}.
+	 * @typedef PoolAllocator
+	 * @type {function}
+	 * @param {number} size Buffer size
+	 * @returns {Uint8Array} Buffer
 	 */
-	utf8.length = function utf8_length(string) {
-	    var len = 0,
-	        c = 0;
-	    for (var i = 0; i < string.length; ++i) {
-	        c = string.charCodeAt(i);
-	        if (c < 128)
-	            len += 1;
-	        else if (c < 2048)
-	            len += 2;
-	        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
-	            ++i;
-	            len += 4;
-	        } else
-	            len += 3;
-	    }
-	    return len;
-	};
 
 	/**
-	 * Reads UTF8 bytes as a string.
-	 * @param {Uint8Array} buffer Source buffer
-	 * @param {number} start Source start
-	 * @param {number} end Source end
-	 * @returns {string} String read
+	 * A slicer as used by {@link util.pool}.
+	 * @typedef PoolSlicer
+	 * @type {function}
+	 * @param {number} start Start offset
+	 * @param {number} end End offset
+	 * @returns {Uint8Array} Buffer slice
+	 * @this {Uint8Array}
 	 */
-	utf8.read = function utf8_read(buffer, start, end) {
-	    var len = end - start;
-	    if (len < 1)
-	        return "";
-	    var parts = null,
-	        chunk = [],
-	        i = 0, // char offset
-	        t;     // temporary
-	    while (start < end) {
-	        t = buffer[start++];
-	        if (t < 128)
-	            chunk[i++] = t;
-	        else if (t > 191 && t < 224)
-	            chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
-	        else if (t > 239 && t < 365) {
-	            t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;
-	            chunk[i++] = 0xD800 + (t >> 10);
-	            chunk[i++] = 0xDC00 + (t & 1023);
-	        } else
-	            chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
-	        if (i > 8191) {
-	            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
-	            i = 0;
-	        }
-	    }
-	    if (parts) {
-	        if (i)
-	            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
-	        return parts.join("");
-	    }
-	    return String.fromCharCode.apply(String, chunk.slice(0, i));
-	};
 
 	/**
-	 * Writes a string as UTF8 bytes.
-	 * @param {string} string Source string
-	 * @param {Uint8Array} buffer Destination buffer
-	 * @param {number} offset Destination offset
-	 * @returns {number} Bytes written
+	 * A general purpose buffer pool.
+	 * @memberof util
+	 * @function
+	 * @param {PoolAllocator} alloc Allocator
+	 * @param {PoolSlicer} slice Slicer
+	 * @param {number} [size=8192] Slab size
+	 * @returns {PoolAllocator} Pooled allocator
 	 */
-	utf8.write = function utf8_write(string, buffer, offset) {
-	    var start = offset,
-	        c1, // character 1
-	        c2; // character 2
-	    for (var i = 0; i < string.length; ++i) {
-	        c1 = string.charCodeAt(i);
-	        if (c1 < 128) {
-	            buffer[offset++] = c1;
-	        } else if (c1 < 2048) {
-	            buffer[offset++] = c1 >> 6       | 192;
-	            buffer[offset++] = c1       & 63 | 128;
-	        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
-	            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
-	            ++i;
-	            buffer[offset++] = c1 >> 18      | 240;
-	            buffer[offset++] = c1 >> 12 & 63 | 128;
-	            buffer[offset++] = c1 >> 6  & 63 | 128;
-	            buffer[offset++] = c1       & 63 | 128;
-	        } else {
-	            buffer[offset++] = c1 >> 12      | 224;
-	            buffer[offset++] = c1 >> 6  & 63 | 128;
-	            buffer[offset++] = c1       & 63 | 128;
+	function pool(alloc, slice, size) {
+	    var SIZE   = size || 8192;
+	    var MAX    = SIZE >>> 1;
+	    var slab   = null;
+	    var offset = SIZE;
+	    return function pool_alloc(size) {
+	        if (size < 1 || size > MAX)
+	            return alloc(size);
+	        if (offset + size > SIZE) {
+	            slab = alloc(SIZE);
+	            offset = 0;
 	        }
-	    }
-	    return offset - start;
-	}; 
-} (utf8$2));
-
-var pool_1 = pool;
-
-/**
- * An allocator as used by {@link util.pool}.
- * @typedef PoolAllocator
- * @type {function}
- * @param {number} size Buffer size
- * @returns {Uint8Array} Buffer
- */
-
-/**
- * A slicer as used by {@link util.pool}.
- * @typedef PoolSlicer
- * @type {function}
- * @param {number} start Start offset
- * @param {number} end End offset
- * @returns {Uint8Array} Buffer slice
- * @this {Uint8Array}
- */
-
-/**
- * A general purpose buffer pool.
- * @memberof util
- * @function
- * @param {PoolAllocator} alloc Allocator
- * @param {PoolSlicer} slice Slicer
- * @param {number} [size=8192] Slab size
- * @returns {PoolAllocator} Pooled allocator
- */
-function pool(alloc, slice, size) {
-    var SIZE   = size || 8192;
-    var MAX    = SIZE >>> 1;
-    var slab   = null;
-    var offset = SIZE;
-    return function pool_alloc(size) {
-        if (size < 1 || size > MAX)
-            return alloc(size);
-        if (offset + size > SIZE) {
-            slab = alloc(SIZE);
-            offset = 0;
-        }
-        var buf = slice.call(slab, offset, offset += size);
-        if (offset & 7) // align to 32 bit
-            offset = (offset | 7) + 1;
-        return buf;
-    };
+	        var buf = slice.call(slab, offset, offset += size);
+	        if (offset & 7) // align to 32 bit
+	            offset = (offset | 7) + 1;
+	        return buf;
+	    };
+	}
+	return pool_1;
 }
 
 var longbits;
@@ -998,25 +1053,25 @@ function requireMinimal () {
 		var util = exports;
 
 		// used to return a Promise where callback is omitted
-		util.asPromise = aspromise;
+		util.asPromise = requireAspromise();
 
 		// converts to / from base64 encoded strings
-		util.base64 = base64$1;
+		util.base64 = requireBase64();
 
 		// base class of rpc.Service
-		util.EventEmitter = eventemitter;
+		util.EventEmitter = requireEventemitter();
 
 		// float handling accross browsers
-		util.float = float;
+		util.float = requireFloat();
 
 		// requires modules optionally and hides the call from bundlers
-		util.inquire = inquire_1;
+		util.inquire = requireInquire();
 
 		// converts to / from utf8 encoded strings
-		util.utf8 = utf8$2;
+		util.utf8 = requireUtf8();
 
 		// provides a node-like buffer pool in the browser
-		util.pool = pool_1;
+		util.pool = requirePool();
 
 		// utility to work with the low and high bits of a 64 bit value
 		util.LongBits = requireLongbits();
@@ -2560,6 +2615,10 @@ function message$1(encode, decode) {
 }
 
 /* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
 var RateLimitProof$4;
 (function (RateLimitProof) {
     let _codec;
@@ -2569,31 +2628,31 @@ var RateLimitProof$4;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.proof != null && obj.proof.byteLength > 0) {
+                if ((obj.proof != null && obj.proof.byteLength > 0)) {
                     w.uint32(10);
                     w.bytes(obj.proof);
                 }
-                if (obj.merkleRoot != null && obj.merkleRoot.byteLength > 0) {
+                if ((obj.merkleRoot != null && obj.merkleRoot.byteLength > 0)) {
                     w.uint32(18);
                     w.bytes(obj.merkleRoot);
                 }
-                if (obj.epoch != null && obj.epoch.byteLength > 0) {
+                if ((obj.epoch != null && obj.epoch.byteLength > 0)) {
                     w.uint32(26);
                     w.bytes(obj.epoch);
                 }
-                if (obj.shareX != null && obj.shareX.byteLength > 0) {
+                if ((obj.shareX != null && obj.shareX.byteLength > 0)) {
                     w.uint32(34);
                     w.bytes(obj.shareX);
                 }
-                if (obj.shareY != null && obj.shareY.byteLength > 0) {
+                if ((obj.shareY != null && obj.shareY.byteLength > 0)) {
                     w.uint32(42);
                     w.bytes(obj.shareY);
                 }
-                if (obj.nullifier != null && obj.nullifier.byteLength > 0) {
+                if ((obj.nullifier != null && obj.nullifier.byteLength > 0)) {
                     w.uint32(50);
                     w.bytes(obj.nullifier);
                 }
-                if (obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0) {
+                if ((obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0)) {
                     w.uint32(58);
                     w.bytes(obj.rlnIdentifier);
                 }
@@ -2608,7 +2667,7 @@ var RateLimitProof$4;
                     shareX: new Uint8Array(0),
                     shareY: new Uint8Array(0),
                     nullifier: new Uint8Array(0),
-                    rlnIdentifier: new Uint8Array(0),
+                    rlnIdentifier: new Uint8Array(0)
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -2661,11 +2720,11 @@ var WakuMessage$4;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.payload != null && obj.payload.byteLength > 0) {
+                if ((obj.payload != null && obj.payload.byteLength > 0)) {
                     w.uint32(10);
                     w.bytes(obj.payload);
                 }
-                if (obj.contentTopic != null && obj.contentTopic !== "") {
+                if ((obj.contentTopic != null && obj.contentTopic !== '')) {
                     w.uint32(18);
                     w.string(obj.contentTopic);
                 }
@@ -2695,7 +2754,7 @@ var WakuMessage$4;
             }, (reader, length) => {
                 const obj = {
                     payload: new Uint8Array(0),
-                    contentTopic: "",
+                    contentTopic: ''
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -2747,6 +2806,10 @@ var message = /*#__PURE__*/Object.freeze({
 });
 
 /* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
 var FilterRequest;
 (function (FilterRequest) {
     (function (ContentFilter) {
@@ -2757,7 +2820,7 @@ var FilterRequest;
                     if (opts.lengthDelimited !== false) {
                         w.fork();
                     }
-                    if (obj.contentTopic != null && obj.contentTopic !== "") {
+                    if ((obj.contentTopic != null && obj.contentTopic !== '')) {
                         w.uint32(10);
                         w.string(obj.contentTopic);
                     }
@@ -2766,7 +2829,7 @@ var FilterRequest;
                     }
                 }, (reader, length) => {
                     const obj = {
-                        contentTopic: "",
+                        contentTopic: ''
                     };
                     const end = length == null ? reader.len : reader.pos + length;
                     while (reader.pos < end) {
@@ -2799,11 +2862,11 @@ var FilterRequest;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.subscribe != null && obj.subscribe !== false) {
+                if ((obj.subscribe != null && obj.subscribe !== false)) {
                     w.uint32(8);
                     w.bool(obj.subscribe);
                 }
-                if (obj.topic != null && obj.topic !== "") {
+                if ((obj.topic != null && obj.topic !== '')) {
                     w.uint32(18);
                     w.string(obj.topic);
                 }
@@ -2819,8 +2882,8 @@ var FilterRequest;
             }, (reader, length) => {
                 const obj = {
                     subscribe: false,
-                    topic: "",
-                    contentFilters: [],
+                    topic: '',
+                    contentFilters: []
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -2872,7 +2935,7 @@ var MessagePush$1;
                 }
             }, (reader, length) => {
                 const obj = {
-                    messages: [],
+                    messages: []
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -2907,7 +2970,7 @@ var FilterRpc;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.requestId != null && obj.requestId !== "") {
+                if ((obj.requestId != null && obj.requestId !== '')) {
                     w.uint32(10);
                     w.string(obj.requestId);
                 }
@@ -2924,7 +2987,7 @@ var FilterRpc;
                 }
             }, (reader, length) => {
                 const obj = {
-                    requestId: "",
+                    requestId: ''
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -2965,31 +3028,31 @@ var RateLimitProof$3;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.proof != null && obj.proof.byteLength > 0) {
+                if ((obj.proof != null && obj.proof.byteLength > 0)) {
                     w.uint32(10);
                     w.bytes(obj.proof);
                 }
-                if (obj.merkleRoot != null && obj.merkleRoot.byteLength > 0) {
+                if ((obj.merkleRoot != null && obj.merkleRoot.byteLength > 0)) {
                     w.uint32(18);
                     w.bytes(obj.merkleRoot);
                 }
-                if (obj.epoch != null && obj.epoch.byteLength > 0) {
+                if ((obj.epoch != null && obj.epoch.byteLength > 0)) {
                     w.uint32(26);
                     w.bytes(obj.epoch);
                 }
-                if (obj.shareX != null && obj.shareX.byteLength > 0) {
+                if ((obj.shareX != null && obj.shareX.byteLength > 0)) {
                     w.uint32(34);
                     w.bytes(obj.shareX);
                 }
-                if (obj.shareY != null && obj.shareY.byteLength > 0) {
+                if ((obj.shareY != null && obj.shareY.byteLength > 0)) {
                     w.uint32(42);
                     w.bytes(obj.shareY);
                 }
-                if (obj.nullifier != null && obj.nullifier.byteLength > 0) {
+                if ((obj.nullifier != null && obj.nullifier.byteLength > 0)) {
                     w.uint32(50);
                     w.bytes(obj.nullifier);
                 }
-                if (obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0) {
+                if ((obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0)) {
                     w.uint32(58);
                     w.bytes(obj.rlnIdentifier);
                 }
@@ -3004,7 +3067,7 @@ var RateLimitProof$3;
                     shareX: new Uint8Array(0),
                     shareY: new Uint8Array(0),
                     nullifier: new Uint8Array(0),
-                    rlnIdentifier: new Uint8Array(0),
+                    rlnIdentifier: new Uint8Array(0)
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -3057,11 +3120,11 @@ var WakuMessage$3;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.payload != null && obj.payload.byteLength > 0) {
+                if ((obj.payload != null && obj.payload.byteLength > 0)) {
                     w.uint32(10);
                     w.bytes(obj.payload);
                 }
-                if (obj.contentTopic != null && obj.contentTopic !== "") {
+                if ((obj.contentTopic != null && obj.contentTopic !== '')) {
                     w.uint32(18);
                     w.string(obj.contentTopic);
                 }
@@ -3091,7 +3154,7 @@ var WakuMessage$3;
             }, (reader, length) => {
                 const obj = {
                     payload: new Uint8Array(0),
-                    contentTopic: "",
+                    contentTopic: ''
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -3137,6 +3200,10 @@ var WakuMessage$3;
 })(WakuMessage$3 || (WakuMessage$3 = {}));
 
 /* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
 var TopicOnlyMessage;
 (function (TopicOnlyMessage) {
     let _codec;
@@ -3146,7 +3213,7 @@ var TopicOnlyMessage;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.contentTopic != null && obj.contentTopic !== "") {
+                if ((obj.contentTopic != null && obj.contentTopic !== '')) {
                     w.uint32(18);
                     w.string(obj.contentTopic);
                 }
@@ -3155,7 +3222,7 @@ var TopicOnlyMessage;
                 }
             }, (reader, length) => {
                 const obj = {
-                    contentTopic: "",
+                    contentTopic: ''
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -3183,6 +3250,10 @@ var TopicOnlyMessage;
 })(TopicOnlyMessage || (TopicOnlyMessage = {}));
 
 /* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
 var FilterSubscribeRequest;
 (function (FilterSubscribeRequest) {
     let FilterSubscribeType;
@@ -3211,12 +3282,11 @@ var FilterSubscribeRequest;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.requestId != null && obj.requestId !== "") {
+                if ((obj.requestId != null && obj.requestId !== '')) {
                     w.uint32(10);
                     w.string(obj.requestId);
                 }
-                if (obj.filterSubscribeType != null &&
-                    __FilterSubscribeTypeValues[obj.filterSubscribeType] !== 0) {
+                if (obj.filterSubscribeType != null && __FilterSubscribeTypeValues[obj.filterSubscribeType] !== 0) {
                     w.uint32(16);
                     FilterSubscribeRequest.FilterSubscribeType.codec().encode(obj.filterSubscribeType, w);
                 }
@@ -3235,9 +3305,9 @@ var FilterSubscribeRequest;
                 }
             }, (reader, length) => {
                 const obj = {
-                    requestId: "",
+                    requestId: '',
                     filterSubscribeType: FilterSubscribeType.SUBSCRIBER_PING,
-                    contentTopics: [],
+                    contentTopics: []
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -3247,8 +3317,7 @@ var FilterSubscribeRequest;
                             obj.requestId = reader.string();
                             break;
                         case 2:
-                            obj.filterSubscribeType =
-                                FilterSubscribeRequest.FilterSubscribeType.codec().decode(reader);
+                            obj.filterSubscribeType = FilterSubscribeRequest.FilterSubscribeType.codec().decode(reader);
                             break;
                         case 10:
                             obj.pubsubTopic = reader.string();
@@ -3282,11 +3351,11 @@ var FilterSubscribeResponse$1;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.requestId != null && obj.requestId !== "") {
+                if ((obj.requestId != null && obj.requestId !== '')) {
                     w.uint32(10);
                     w.string(obj.requestId);
                 }
-                if (obj.statusCode != null && obj.statusCode !== 0) {
+                if ((obj.statusCode != null && obj.statusCode !== 0)) {
                     w.uint32(80);
                     w.uint32(obj.statusCode);
                 }
@@ -3299,8 +3368,8 @@ var FilterSubscribeResponse$1;
                 }
             }, (reader, length) => {
                 const obj = {
-                    requestId: "",
-                    statusCode: 0,
+                    requestId: '',
+                    statusCode: 0
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -3390,31 +3459,31 @@ var RateLimitProof$2;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.proof != null && obj.proof.byteLength > 0) {
+                if ((obj.proof != null && obj.proof.byteLength > 0)) {
                     w.uint32(10);
                     w.bytes(obj.proof);
                 }
-                if (obj.merkleRoot != null && obj.merkleRoot.byteLength > 0) {
+                if ((obj.merkleRoot != null && obj.merkleRoot.byteLength > 0)) {
                     w.uint32(18);
                     w.bytes(obj.merkleRoot);
                 }
-                if (obj.epoch != null && obj.epoch.byteLength > 0) {
+                if ((obj.epoch != null && obj.epoch.byteLength > 0)) {
                     w.uint32(26);
                     w.bytes(obj.epoch);
                 }
-                if (obj.shareX != null && obj.shareX.byteLength > 0) {
+                if ((obj.shareX != null && obj.shareX.byteLength > 0)) {
                     w.uint32(34);
                     w.bytes(obj.shareX);
                 }
-                if (obj.shareY != null && obj.shareY.byteLength > 0) {
+                if ((obj.shareY != null && obj.shareY.byteLength > 0)) {
                     w.uint32(42);
                     w.bytes(obj.shareY);
                 }
-                if (obj.nullifier != null && obj.nullifier.byteLength > 0) {
+                if ((obj.nullifier != null && obj.nullifier.byteLength > 0)) {
                     w.uint32(50);
                     w.bytes(obj.nullifier);
                 }
-                if (obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0) {
+                if ((obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0)) {
                     w.uint32(58);
                     w.bytes(obj.rlnIdentifier);
                 }
@@ -3429,7 +3498,7 @@ var RateLimitProof$2;
                     shareX: new Uint8Array(0),
                     shareY: new Uint8Array(0),
                     nullifier: new Uint8Array(0),
-                    rlnIdentifier: new Uint8Array(0),
+                    rlnIdentifier: new Uint8Array(0)
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -3482,11 +3551,11 @@ var WakuMessage$2;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.payload != null && obj.payload.byteLength > 0) {
+                if ((obj.payload != null && obj.payload.byteLength > 0)) {
                     w.uint32(10);
                     w.bytes(obj.payload);
                 }
-                if (obj.contentTopic != null && obj.contentTopic !== "") {
+                if ((obj.contentTopic != null && obj.contentTopic !== '')) {
                     w.uint32(18);
                     w.string(obj.contentTopic);
                 }
@@ -3516,7 +3585,7 @@ var WakuMessage$2;
             }, (reader, length) => {
                 const obj = {
                     payload: new Uint8Array(0),
-                    contentTopic: "",
+                    contentTopic: ''
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -3562,6 +3631,10 @@ var WakuMessage$2;
 })(WakuMessage$2 || (WakuMessage$2 = {}));
 
 /* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
 var PushRequest;
 (function (PushRequest) {
     let _codec;
@@ -3571,7 +3644,7 @@ var PushRequest;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.pubsubTopic != null && obj.pubsubTopic !== "") {
+                if ((obj.pubsubTopic != null && obj.pubsubTopic !== '')) {
                     w.uint32(10);
                     w.string(obj.pubsubTopic);
                 }
@@ -3584,7 +3657,7 @@ var PushRequest;
                 }
             }, (reader, length) => {
                 const obj = {
-                    pubsubTopic: "",
+                    pubsubTopic: ''
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -3622,7 +3695,7 @@ var PushResponse;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.isSuccess != null && obj.isSuccess !== false) {
+                if ((obj.isSuccess != null && obj.isSuccess !== false)) {
                     w.uint32(8);
                     w.bool(obj.isSuccess);
                 }
@@ -3635,7 +3708,7 @@ var PushResponse;
                 }
             }, (reader, length) => {
                 const obj = {
-                    isSuccess: false,
+                    isSuccess: false
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -3673,7 +3746,7 @@ var PushRpc$1;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.requestId != null && obj.requestId !== "") {
+                if ((obj.requestId != null && obj.requestId !== '')) {
                     w.uint32(10);
                     w.string(obj.requestId);
                 }
@@ -3690,7 +3763,7 @@ var PushRpc$1;
                 }
             }, (reader, length) => {
                 const obj = {
-                    requestId: "",
+                    requestId: ''
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -3731,31 +3804,31 @@ var RateLimitProof$1;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.proof != null && obj.proof.byteLength > 0) {
+                if ((obj.proof != null && obj.proof.byteLength > 0)) {
                     w.uint32(10);
                     w.bytes(obj.proof);
                 }
-                if (obj.merkleRoot != null && obj.merkleRoot.byteLength > 0) {
+                if ((obj.merkleRoot != null && obj.merkleRoot.byteLength > 0)) {
                     w.uint32(18);
                     w.bytes(obj.merkleRoot);
                 }
-                if (obj.epoch != null && obj.epoch.byteLength > 0) {
+                if ((obj.epoch != null && obj.epoch.byteLength > 0)) {
                     w.uint32(26);
                     w.bytes(obj.epoch);
                 }
-                if (obj.shareX != null && obj.shareX.byteLength > 0) {
+                if ((obj.shareX != null && obj.shareX.byteLength > 0)) {
                     w.uint32(34);
                     w.bytes(obj.shareX);
                 }
-                if (obj.shareY != null && obj.shareY.byteLength > 0) {
+                if ((obj.shareY != null && obj.shareY.byteLength > 0)) {
                     w.uint32(42);
                     w.bytes(obj.shareY);
                 }
-                if (obj.nullifier != null && obj.nullifier.byteLength > 0) {
+                if ((obj.nullifier != null && obj.nullifier.byteLength > 0)) {
                     w.uint32(50);
                     w.bytes(obj.nullifier);
                 }
-                if (obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0) {
+                if ((obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0)) {
                     w.uint32(58);
                     w.bytes(obj.rlnIdentifier);
                 }
@@ -3770,7 +3843,7 @@ var RateLimitProof$1;
                     shareX: new Uint8Array(0),
                     shareY: new Uint8Array(0),
                     nullifier: new Uint8Array(0),
-                    rlnIdentifier: new Uint8Array(0),
+                    rlnIdentifier: new Uint8Array(0)
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -3823,11 +3896,11 @@ var WakuMessage$1;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.payload != null && obj.payload.byteLength > 0) {
+                if ((obj.payload != null && obj.payload.byteLength > 0)) {
                     w.uint32(10);
                     w.bytes(obj.payload);
                 }
-                if (obj.contentTopic != null && obj.contentTopic !== "") {
+                if ((obj.contentTopic != null && obj.contentTopic !== '')) {
                     w.uint32(18);
                     w.string(obj.contentTopic);
                 }
@@ -3857,7 +3930,7 @@ var WakuMessage$1;
             }, (reader, length) => {
                 const obj = {
                     payload: new Uint8Array(0),
-                    contentTopic: "",
+                    contentTopic: ''
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -3903,6 +3976,10 @@ var WakuMessage$1;
 })(WakuMessage$1 || (WakuMessage$1 = {}));
 
 /* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
 var Index;
 (function (Index) {
     let _codec;
@@ -3912,19 +3989,19 @@ var Index;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.digest != null && obj.digest.byteLength > 0) {
+                if ((obj.digest != null && obj.digest.byteLength > 0)) {
                     w.uint32(10);
                     w.bytes(obj.digest);
                 }
-                if (obj.receiverTime != null && obj.receiverTime !== 0n) {
+                if ((obj.receiverTime != null && obj.receiverTime !== 0n)) {
                     w.uint32(16);
                     w.sint64(obj.receiverTime);
                 }
-                if (obj.senderTime != null && obj.senderTime !== 0n) {
+                if ((obj.senderTime != null && obj.senderTime !== 0n)) {
                     w.uint32(24);
                     w.sint64(obj.senderTime);
                 }
-                if (obj.pubsubTopic != null && obj.pubsubTopic !== "") {
+                if ((obj.pubsubTopic != null && obj.pubsubTopic !== '')) {
                     w.uint32(34);
                     w.string(obj.pubsubTopic);
                 }
@@ -3936,7 +4013,7 @@ var Index;
                     digest: new Uint8Array(0),
                     receiverTime: 0n,
                     senderTime: 0n,
-                    pubsubTopic: "",
+                    pubsubTopic: ''
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -4050,7 +4127,7 @@ var ContentFilter;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.contentTopic != null && obj.contentTopic !== "") {
+                if ((obj.contentTopic != null && obj.contentTopic !== '')) {
                     w.uint32(10);
                     w.string(obj.contentTopic);
                 }
@@ -4059,7 +4136,7 @@ var ContentFilter;
                 }
             }, (reader, length) => {
                 const obj = {
-                    contentTopic: "",
+                    contentTopic: ''
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -4121,7 +4198,7 @@ var HistoryQuery;
                 }
             }, (reader, length) => {
                 const obj = {
-                    contentFilters: [],
+                    contentFilters: []
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -4203,7 +4280,7 @@ var HistoryResponse;
             }, (reader, length) => {
                 const obj = {
                     messages: [],
-                    error: HistoryError.NONE,
+                    error: HistoryError.NONE
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -4244,7 +4321,7 @@ var HistoryRpc$1;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.requestId != null && obj.requestId !== "") {
+                if ((obj.requestId != null && obj.requestId !== '')) {
                     w.uint32(10);
                     w.string(obj.requestId);
                 }
@@ -4261,7 +4338,7 @@ var HistoryRpc$1;
                 }
             }, (reader, length) => {
                 const obj = {
-                    requestId: "",
+                    requestId: ''
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -4302,31 +4379,31 @@ var RateLimitProof;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.proof != null && obj.proof.byteLength > 0) {
+                if ((obj.proof != null && obj.proof.byteLength > 0)) {
                     w.uint32(10);
                     w.bytes(obj.proof);
                 }
-                if (obj.merkleRoot != null && obj.merkleRoot.byteLength > 0) {
+                if ((obj.merkleRoot != null && obj.merkleRoot.byteLength > 0)) {
                     w.uint32(18);
                     w.bytes(obj.merkleRoot);
                 }
-                if (obj.epoch != null && obj.epoch.byteLength > 0) {
+                if ((obj.epoch != null && obj.epoch.byteLength > 0)) {
                     w.uint32(26);
                     w.bytes(obj.epoch);
                 }
-                if (obj.shareX != null && obj.shareX.byteLength > 0) {
+                if ((obj.shareX != null && obj.shareX.byteLength > 0)) {
                     w.uint32(34);
                     w.bytes(obj.shareX);
                 }
-                if (obj.shareY != null && obj.shareY.byteLength > 0) {
+                if ((obj.shareY != null && obj.shareY.byteLength > 0)) {
                     w.uint32(42);
                     w.bytes(obj.shareY);
                 }
-                if (obj.nullifier != null && obj.nullifier.byteLength > 0) {
+                if ((obj.nullifier != null && obj.nullifier.byteLength > 0)) {
                     w.uint32(50);
                     w.bytes(obj.nullifier);
                 }
-                if (obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0) {
+                if ((obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0)) {
                     w.uint32(58);
                     w.bytes(obj.rlnIdentifier);
                 }
@@ -4341,7 +4418,7 @@ var RateLimitProof;
                     shareX: new Uint8Array(0),
                     shareY: new Uint8Array(0),
                     nullifier: new Uint8Array(0),
-                    rlnIdentifier: new Uint8Array(0),
+                    rlnIdentifier: new Uint8Array(0)
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -4394,11 +4471,11 @@ var WakuMessage;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.payload != null && obj.payload.byteLength > 0) {
+                if ((obj.payload != null && obj.payload.byteLength > 0)) {
                     w.uint32(10);
                     w.bytes(obj.payload);
                 }
-                if (obj.contentTopic != null && obj.contentTopic !== "") {
+                if ((obj.contentTopic != null && obj.contentTopic !== '')) {
                     w.uint32(18);
                     w.string(obj.contentTopic);
                 }
@@ -4428,7 +4505,7 @@ var WakuMessage;
             }, (reader, length) => {
                 const obj = {
                     payload: new Uint8Array(0),
-                    contentTopic: "",
+                    contentTopic: ''
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -4474,6 +4551,10 @@ var WakuMessage;
 })(WakuMessage || (WakuMessage = {}));
 
 /* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
 var PeerInfo;
 (function (PeerInfo) {
     let _codec;
@@ -4578,7 +4659,7 @@ var PeerExchangeResponse;
                 }
             }, (reader, length) => {
                 const obj = {
-                    peerInfos: [],
+                    peerInfos: []
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -4727,7 +4808,7 @@ class Encoder {
             timestamp: BigInt(timestamp.valueOf()) * OneMillion,
             meta: undefined,
             rateLimitProof: message.rateLimitProof,
-            ephemeral: this.ephemeral,
+            ephemeral: this.ephemeral
         };
         if (this.metaSetter) {
             const meta = this.metaSetter(protoMessage);
@@ -4745,7 +4826,7 @@ class Encoder {
  * { @link @waku/interfaces.Relay.send } to automatically encode outgoing
  * messages.
  */
-function createEncoder({ contentTopic, ephemeral, metaSetter, }) {
+function createEncoder({ contentTopic, ephemeral, metaSetter }) {
     return new Encoder(contentTopic, ephemeral, metaSetter);
 }
 class Decoder {
@@ -4766,7 +4847,7 @@ class Decoder {
             timestamp: protoMessage.timestamp ?? undefined,
             meta: protoMessage.meta ?? undefined,
             rateLimitProof: protoMessage.rateLimitProof ?? undefined,
-            ephemeral: protoMessage.ephemeral ?? false,
+            ephemeral: protoMessage.ephemeral ?? false
         });
     }
     async fromProtoObj(pubSubTopic, proto) {