@waku/core 0.0.22 → 0.0.24

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

@@ -1,784 +1,839 @@
-import { c as commonjsGlobal, g as getDefaultExportFromCjs, d as debug } from './browser-bde977a3.js';
+import { c as commonjsGlobal, a as getDefaultExportFromCjs, d as debug } from './browser-90197c87.js';
 
 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);
 
-	// Base64 encoding table
-	var b64 = new Array(64);
+		// 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++;
 
-	// Base64 decoding table
-	var s64 = new Array(123);
+		/**
+		 * 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));
+		};
 
-	// 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++;
+		var invalidEncoding = "invalid encoding";
+
+		/**
+		 * 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;
+		};
+
+		/**
+		 * 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() {
+
+	    /**
+	     * Registered listeners.
+	     * @type {Object.<string,*>}
+	     * @private
+	     */
+	    this._listeners = {};
+	}
 
-	var invalidEncoding = "invalid encoding";
+	/**
+	 * 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}
+	 */
 
-/**
- * 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
- */
+	/**
+	 * 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 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 little endian byte order.
+	 * @name util.float.readFloatLE
+	 * @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}
- */
+	/**
+	 * 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 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 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}
+	 */
 
-/**
- * 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
- */
+	/**
+	 * 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 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 little endian byte order.
+	 * @name util.float.readDoubleLE
+	 * @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) {
+	/**
+	 * 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
+	 */
 
-    // float: typed array
-    if (typeof Float32Array !== "undefined") (function() {
+	// Factory function for the purpose of node-based testing in modified global environments
+	function factory(exports) {
 
-        var f32 = new Float32Array([ -0 ]),
-            f8b = new Uint8Array(f32.buffer),
-            le  = f8b[3] === 128;
+	    // float: typed array
+	    if (typeof Float32Array !== "undefined") (function() {
 
-        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];
-        }
+	        var f32 = new Float32Array([ -0 ]),
+	            f8b = new Uint8Array(f32.buffer),
+	            le  = f8b[3] === 128;
 
-        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_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];
+	        }
 
-        /* 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 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 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];
-        }
+	        /* 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_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_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];
+	        }
 
-        /* istanbul ignore next */
-        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
-        /* istanbul ignore next */
-        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
+	        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];
+	        }
 
-    // float: ieee754
-    })(); else (function() {
+	        /* istanbul ignore next */
+	        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
+	        /* istanbul ignore next */
+	        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
 
-        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);
-            }
-        }
+	    // float: ieee754
+	    })(); else (function() {
 
-        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
-        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
+	        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 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.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
+	        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
 
-        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
-        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
+	        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);
 
-    // double: typed array
-    if (typeof Float64Array !== "undefined") (function() {
+	    })();
 
-        var f64 = new Float64Array([-0]),
-            f8b = new Uint8Array(f64.buffer),
-            le  = f8b[7] === 128;
+	    // double: typed array
+	    if (typeof Float64Array !== "undefined") (function() {
 
-        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];
-        }
+	        var f64 = new Float64Array([-0]),
+	            f8b = new Uint8Array(f64.buffer),
+	            le  = f8b[7] === 128;
 
-        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_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];
+	        }
 
-        /* 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 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 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];
-        }
+	        /* 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_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_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];
+	        }
 
-        /* istanbul ignore next */
-        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
-        /* istanbul ignore next */
-        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
+	        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];
+	        }
 
-    // double: ieee754
-    })(); else (function() {
+	        /* istanbul ignore next */
+	        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
+	        /* istanbul ignore next */
+	        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
 
-        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);
-                }
-            }
-        }
+	    // double: ieee754
+	    })(); else (function() {
 
-        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
-        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
+	        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 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.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
+	        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
 
-        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
-        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 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);
+	        }
 
-    })();
+	        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
+	        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
 
-    return exports;
-}
+	    })();
 
-// uint helpers
+	    return exports;
+	}
 
-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;
-}
+	// uint helpers
 
-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 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 readUintLE(buf, pos) {
-    return (buf[pos    ]
-          | buf[pos + 1] << 8
-          | buf[pos + 2] << 16
-          | buf[pos + 3] << 24) >>> 0;
-}
+	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 readUintBE(buf, pos) {
-    return (buf[pos    ] << 24
-          | buf[pos + 1] << 16
-          | buf[pos + 2] << 8
-          | buf[pos + 3]) >>> 0;
-}
-
-var inquire_1 = inquire;
+	function readUintLE(buf, pos) {
+	    return (buf[pos    ]
+	          | buf[pos + 1] << 8
+	          | buf[pos + 2] << 16
+	          | buf[pos + 3] << 24) >>> 0;
+	}
 
-/**
- * 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;
+	function readUintBE(buf, pos) {
+	    return (buf[pos    ] << 24
+	          | buf[pos + 1] << 16
+	          | buf[pos + 2] << 8
+	          | buf[pos + 3]) >>> 0;
+	}
+	return float;
 }
 
-var utf8$2 = {};
+var inquire_1;
+var hasRequiredInquire;
 
-(function (exports) {
+function requireInquire () {
+	if (hasRequiredInquire) return inquire_1;
+	hasRequiredInquire = 1;
+	inquire_1 = inquire;
 
 	/**
-	 * A minimal UTF8 implementation for number arrays.
+	 * Requires a module only if available.
 	 * @memberof util
-	 * @namespace
+	 * @param {string} moduleName Module to require
+	 * @returns {?Object} Required module if available and not empty, otherwise `null`
 	 */
-	var utf8 = exports;
+	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 = {};
+
+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;
+
+		/**
+		 * 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();
@@ -1749,9 +1804,14 @@ Reader$1.prototype.bytes = function read_bytes() {
     this.pos += length;
     if (Array.isArray(this.buf)) // plain array
         return this.buf.slice(start, end);
-    return start === end // fix for IE 10/Win8 and others' subarray returning array of size 1
-        ? new this.buf.constructor(0)
-        : this._slice.call(this.buf, start, end);
+
+    if (start === end) { // fix for IE 10/Win8 and others' subarray returning array of size 1
+        var nativeBuffer = util$4.Buffer;
+        return nativeBuffer
+            ? nativeBuffer.alloc(0)
+            : new this.buf.constructor(0);
+    }
+    return this._slice.call(this.buf, start, end);
 };
 
 /**
@@ -2560,6 +2620,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 +2633,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 +2672,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 +2725,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 +2759,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 +2811,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 +2825,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 +2834,7 @@ var FilterRequest;
                     }
                 }, (reader, length) => {
                     const obj = {
-                        contentTopic: "",
+                        contentTopic: ''
                     };
                     const end = length == null ? reader.len : reader.pos + length;
                     while (reader.pos < end) {
@@ -2799,11 +2867,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 +2887,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 +2940,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 +2975,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 +2992,7 @@ var FilterRpc;
                 }
             }, (reader, length) => {
                 const obj = {
-                    requestId: "",
+                    requestId: ''
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -2965,31 +3033,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 +3072,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 +3125,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 +3159,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 +3205,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 +3218,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 +3227,7 @@ var TopicOnlyMessage;
                 }
             }, (reader, length) => {
                 const obj = {
-                    contentTopic: "",
+                    contentTopic: ''
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -3183,6 +3255,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 +3287,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 +3310,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 +3322,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 +3356,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 +3373,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 +3464,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 +3503,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 +3556,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 +3590,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 +3636,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 +3649,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 +3662,7 @@ var PushRequest;
                 }
             }, (reader, length) => {
                 const obj = {
-                    pubsubTopic: "",
+                    pubsubTopic: ''
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -3622,7 +3700,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 +3713,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 +3751,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 +3768,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 +3809,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 +3848,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 +3901,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 +3935,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 +3981,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 +3994,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 +4018,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 +4132,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 +4141,7 @@ var ContentFilter;
                 }
             }, (reader, length) => {
                 const obj = {
-                    contentTopic: "",
+                    contentTopic: ''
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -4121,7 +4203,7 @@ var HistoryQuery;
                 }
             }, (reader, length) => {
                 const obj = {
-                    contentFilters: [],
+                    contentFilters: []
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -4203,7 +4285,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 +4326,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 +4343,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 +4384,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 +4423,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 +4476,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 +4510,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 +4556,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 +4664,7 @@ var PeerExchangeResponse;
                 }
             }, (reader, length) => {
                 const obj = {
-                    peerInfos: [],
+                    peerInfos: []
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -4654,14 +4740,19 @@ var PeerExchangeRPC;
     };
 })(PeerExchangeRPC || (PeerExchangeRPC = {}));
 
+/**
+ * DefaultPubSubTopic is the default gossipsub topic to use for Waku.
+ */
+const DefaultPubSubTopic = "/waku/2/default-waku/proto";
+
 const log = debug("waku:message:version-0");
 const OneMillion = BigInt(1000000);
 const Version = 0;
 class DecodedMessage {
-    pubSubTopic;
+    pubsubTopic;
     proto;
-    constructor(pubSubTopic, proto) {
-        this.pubSubTopic = pubSubTopic;
+    constructor(pubsubTopic, proto) {
+        this.pubsubTopic = pubsubTopic;
         this.proto = proto;
     }
     get ephemeral() {
@@ -4706,10 +4797,12 @@ class DecodedMessage {
 class Encoder {
     contentTopic;
     ephemeral;
+    pubsubTopic;
     metaSetter;
-    constructor(contentTopic, ephemeral = false, metaSetter) {
+    constructor(contentTopic, ephemeral = false, pubsubTopic, metaSetter) {
         this.contentTopic = contentTopic;
         this.ephemeral = ephemeral;
+        this.pubsubTopic = pubsubTopic;
         this.metaSetter = metaSetter;
         if (!contentTopic || contentTopic === "") {
             throw new Error("Content topic must be specified");
@@ -4727,7 +4820,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);
@@ -4739,18 +4832,19 @@ class Encoder {
 /**
  * Creates an encoder that encode messages without Waku level encryption or signature.
  *
- * An encoder is used to encode messages in the [`14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/)
+ * An encoder is used to encode messages in the [14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/)
  * format to be sent over the Waku network. The resulting encoder can then be
- * pass to { @link @waku/interfaces.LightPush.push } or
- * { @link @waku/interfaces.Relay.send } to automatically encode outgoing
+ * pass to { @link @waku/interfaces!ISender.send } to automatically encode outgoing
  * messages.
  */
-function createEncoder({ contentTopic, ephemeral, metaSetter, }) {
-    return new Encoder(contentTopic, ephemeral, metaSetter);
+function createEncoder({ pubsubTopic = DefaultPubSubTopic, contentTopic, ephemeral, metaSetter }) {
+    return new Encoder(contentTopic, ephemeral, pubsubTopic, metaSetter);
 }
 class Decoder {
+    pubsubTopic;
     contentTopic;
-    constructor(contentTopic) {
+    constructor(pubsubTopic, contentTopic) {
+        this.pubsubTopic = pubsubTopic;
         this.contentTopic = contentTopic;
         if (!contentTopic || contentTopic === "") {
             throw new Error("Content topic must be specified");
@@ -4766,17 +4860,17 @@ 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) {
+    async fromProtoObj(pubsubTopic, proto) {
         // https://rfc.vac.dev/spec/14/
         // > If omitted, the value SHOULD be interpreted as version 0.
         if (proto.version ?? 0 !== Version) {
             log("Failed to decode due to incorrect version, expected:", Version, ", actual:", proto.version);
             return Promise.resolve(undefined);
         }
-        return new DecodedMessage(pubSubTopic, proto);
+        return new DecodedMessage(pubsubTopic, proto);
     }
 }
 /**
@@ -4784,14 +4878,13 @@ class Decoder {
  *
  * A decoder is used to decode messages from the [14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/)
  * format when received from the Waku network. The resulting decoder can then be
- * pass to { @link @waku/interfaces.Filter.subscribe } or
- * { @link @waku/interfaces.Relay.subscribe } to automatically decode incoming
+ * pass to { @link @waku/interfaces!IReceiver.subscribe } to automatically decode incoming
  * messages.
  *
  * @param contentTopic The resulting decoder will only decode messages with this content topic.
  */
-function createDecoder(contentTopic) {
-    return new Decoder(contentTopic);
+function createDecoder(contentTopic, pubsubTopic = DefaultPubSubTopic) {
+    return new Decoder(pubsubTopic, contentTopic);
 }
 
 var version_0 = /*#__PURE__*/Object.freeze({
@@ -4805,4 +4898,4 @@ var version_0 = /*#__PURE__*/Object.freeze({
     proto: message
 });
 
-export { DecodedMessage as D, Encoder as E, FilterSubscribeRequest as F, HistoryRpc$1 as H, MessagePush as M, PushRpc$1 as P, Version as V, FilterSubscribeResponse$1 as a, PushResponse as b, createEncoder as c, PagingInfo as d, HistoryResponse as e, createDecoder as f, Decoder as g, message as m, version_0 as v };
+export { DefaultPubSubTopic as D, Encoder as E, FilterSubscribeRequest as F, HistoryRpc$1 as H, MessagePush as M, PushRpc$1 as P, Version as V, encodeMessage as a, FilterSubscribeResponse$1 as b, createEncoder as c, decodeMessage as d, enumeration as e, PushResponse as f, PagingInfo as g, HistoryResponse as h, createDecoder as i, message as j, DecodedMessage as k, Decoder as l, message$1 as m, version_0 as v };