@waku/core 0.0.26-7eb3375.0 → 0.0.27

package/bundle/{version_0-7190df43.js → version_0-FXfzO8Km.js}

@@ -1,2145 +1,1292 @@
-import { d as commonjsGlobal, f as getDefaultExportFromCjs } from './browser-9a6558bb.js';
-import { L as Logger } from './index-7581d519.js';
-
-var minimal = {};
-
-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}
-	 */
-
-	/**
-	 * 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;
+import { d as allocUnsafe, i as fromString, L as Logger, j as determinePubsubTopic } from './index-8YyfzF9R.js';
+
+/* eslint-disable no-fallthrough */
+const N1 = Math.pow(2, 7);
+const N2 = Math.pow(2, 14);
+const N3 = Math.pow(2, 21);
+const N4 = Math.pow(2, 28);
+const N5 = Math.pow(2, 35);
+const N6 = Math.pow(2, 42);
+const N7 = Math.pow(2, 49);
+/** Most significant bit of a byte */
+const MSB = 0x80;
+/** Rest of the bits in a byte */
+const REST = 0x7f;
+function encodingLength(value) {
+    if (value < N1) {
+        return 1;
+    }
+    if (value < N2) {
+        return 2;
+    }
+    if (value < N3) {
+        return 3;
+    }
+    if (value < N4) {
+        return 4;
+    }
+    if (value < N5) {
+        return 5;
+    }
+    if (value < N6) {
+        return 6;
+    }
+    if (value < N7) {
+        return 7;
+    }
+    if (Number.MAX_SAFE_INTEGER != null && value > Number.MAX_SAFE_INTEGER) {
+        throw new RangeError('Could not encode varint');
+    }
+    return 8;
 }
-
-var base64$1 = {};
-
-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;
-
-		/**
-		 * 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));
-		};
-
-		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;
+function encodeUint8Array(value, buf, offset = 0) {
+    switch (encodingLength(value)) {
+        case 8: {
+            buf[offset++] = (value & 0xFF) | MSB;
+            value /= 128;
+        }
+        case 7: {
+            buf[offset++] = (value & 0xFF) | MSB;
+            value /= 128;
+        }
+        case 6: {
+            buf[offset++] = (value & 0xFF) | MSB;
+            value /= 128;
+        }
+        case 5: {
+            buf[offset++] = (value & 0xFF) | MSB;
+            value /= 128;
+        }
+        case 4: {
+            buf[offset++] = (value & 0xFF) | MSB;
+            value >>>= 7;
+        }
+        case 3: {
+            buf[offset++] = (value & 0xFF) | MSB;
+            value >>>= 7;
+        }
+        case 2: {
+            buf[offset++] = (value & 0xFF) | MSB;
+            value >>>= 7;
+        }
+        case 1: {
+            buf[offset++] = (value & 0xFF);
+            value >>>= 7;
+            break;
+        }
+        default: throw new Error('unreachable');
+    }
+    return buf;
 }
-
-var eventemitter;
-var hasRequiredEventemitter;
-
-function requireEventemitter () {
-	if (hasRequiredEventemitter) return eventemitter;
-	hasRequiredEventemitter = 1;
-	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;
-	};
-	return eventemitter;
+function encodeUint8ArrayList(value, buf, offset = 0) {
+    switch (encodingLength(value)) {
+        case 8: {
+            buf.set(offset++, (value & 0xFF) | MSB);
+            value /= 128;
+        }
+        case 7: {
+            buf.set(offset++, (value & 0xFF) | MSB);
+            value /= 128;
+        }
+        case 6: {
+            buf.set(offset++, (value & 0xFF) | MSB);
+            value /= 128;
+        }
+        case 5: {
+            buf.set(offset++, (value & 0xFF) | MSB);
+            value /= 128;
+        }
+        case 4: {
+            buf.set(offset++, (value & 0xFF) | MSB);
+            value >>>= 7;
+        }
+        case 3: {
+            buf.set(offset++, (value & 0xFF) | MSB);
+            value >>>= 7;
+        }
+        case 2: {
+            buf.set(offset++, (value & 0xFF) | MSB);
+            value >>>= 7;
+        }
+        case 1: {
+            buf.set(offset++, (value & 0xFF));
+            value >>>= 7;
+            break;
+        }
+        default: throw new Error('unreachable');
+    }
+    return buf;
 }
-
-var float;
-var hasRequiredFloat;
-
-function requireFloat () {
-	if (hasRequiredFloat) return float;
-	hasRequiredFloat = 1;
-
-	float = factory(factory);
-
-	/**
-	 * Reads / writes floats / doubles from / to buffers.
-	 * @name util.float
-	 * @namespace
-	 */
-
-	/**
-	 * 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 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 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 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) {
-
-	    // float: typed array
-	    if (typeof Float32Array !== "undefined") (function() {
-
-	        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_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;
-
-	        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];
-	        }
-
-	        /* 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() {
-
-	        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);
-
-	        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;
-
-	        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];
-	        }
-
-	        /* 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_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;
-
-	    // 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);
-	                }
-	            }
-	        }
-
-	        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);
-	        }
-
-	        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
-	        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
-
-	    })();
-
-	    return exports;
-	}
-
-	// 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 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 readUintBE(buf, pos) {
-	    return (buf[pos    ] << 24
-	          | buf[pos + 1] << 16
-	          | buf[pos + 2] << 8
-	          | buf[pos + 3]) >>> 0;
-	}
-	return float;
+function decodeUint8Array(buf, offset) {
+    let b = buf[offset];
+    let res = 0;
+    res += b & REST;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf[offset + 1];
+    res += (b & REST) << 7;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf[offset + 2];
+    res += (b & REST) << 14;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf[offset + 3];
+    res += (b & REST) << 21;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf[offset + 4];
+    res += (b & REST) * N4;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf[offset + 5];
+    res += (b & REST) * N5;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf[offset + 6];
+    res += (b & REST) * N6;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf[offset + 7];
+    res += (b & REST) * N7;
+    if (b < MSB) {
+        return res;
+    }
+    throw new RangeError('Could not decode varint');
 }
-
-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;
-	}
-	return inquire_1;
+function decodeUint8ArrayList(buf, offset) {
+    let b = buf.get(offset);
+    let res = 0;
+    res += b & REST;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf.get(offset + 1);
+    res += (b & REST) << 7;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf.get(offset + 2);
+    res += (b & REST) << 14;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf.get(offset + 3);
+    res += (b & REST) << 21;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf.get(offset + 4);
+    res += (b & REST) * N4;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf.get(offset + 5);
+    res += (b & REST) * N5;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf.get(offset + 6);
+    res += (b & REST) * N6;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf.get(offset + 7);
+    res += (b & REST) * N7;
+    if (b < MSB) {
+        return res;
+    }
+    throw new RangeError('Could not decode varint');
 }
-
-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;
+function encode(value, buf, offset = 0) {
+    if (buf == null) {
+        buf = allocUnsafe(encodingLength(value));
+    }
+    if (buf instanceof Uint8Array) {
+        return encodeUint8Array(value, buf, offset);
+    }
+    else {
+        return encodeUint8ArrayList(value, buf, offset);
+    }
 }
-
-var pool_1;
-var hasRequiredPool;
-
-function requirePool () {
-	if (hasRequiredPool) return pool_1;
-	hasRequiredPool = 1;
-	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;
-	    };
-	}
-	return pool_1;
+function decode(buf, offset = 0) {
+    if (buf instanceof Uint8Array) {
+        return decodeUint8Array(buf, offset);
+    }
+    else {
+        return decodeUint8ArrayList(buf, offset);
+    }
 }
 
-var longbits;
-var hasRequiredLongbits;
-
-function requireLongbits () {
-	if (hasRequiredLongbits) return longbits;
-	hasRequiredLongbits = 1;
-	longbits = LongBits;
-
-	var util = requireMinimal();
-
-	/**
-	 * Constructs new long bits.
-	 * @classdesc Helper class for working with the low and high bits of a 64 bit value.
-	 * @memberof util
-	 * @constructor
-	 * @param {number} lo Low 32 bits, unsigned
-	 * @param {number} hi High 32 bits, unsigned
-	 */
-	function LongBits(lo, hi) {
-
-	    // note that the casts below are theoretically unnecessary as of today, but older statically
-	    // generated converter code might still call the ctor with signed 32bits. kept for compat.
-
-	    /**
-	     * Low bits.
-	     * @type {number}
-	     */
-	    this.lo = lo >>> 0;
-
-	    /**
-	     * High bits.
-	     * @type {number}
-	     */
-	    this.hi = hi >>> 0;
-	}
-
-	/**
-	 * Zero bits.
-	 * @memberof util.LongBits
-	 * @type {util.LongBits}
-	 */
-	var zero = LongBits.zero = new LongBits(0, 0);
-
-	zero.toNumber = function() { return 0; };
-	zero.zzEncode = zero.zzDecode = function() { return this; };
-	zero.length = function() { return 1; };
-
-	/**
-	 * Zero hash.
-	 * @memberof util.LongBits
-	 * @type {string}
-	 */
-	var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";
-
-	/**
-	 * Constructs new long bits from the specified number.
-	 * @param {number} value Value
-	 * @returns {util.LongBits} Instance
-	 */
-	LongBits.fromNumber = function fromNumber(value) {
-	    if (value === 0)
-	        return zero;
-	    var sign = value < 0;
-	    if (sign)
-	        value = -value;
-	    var lo = value >>> 0,
-	        hi = (value - lo) / 4294967296 >>> 0;
-	    if (sign) {
-	        hi = ~hi >>> 0;
-	        lo = ~lo >>> 0;
-	        if (++lo > 4294967295) {
-	            lo = 0;
-	            if (++hi > 4294967295)
-	                hi = 0;
-	        }
-	    }
-	    return new LongBits(lo, hi);
-	};
-
-	/**
-	 * Constructs new long bits from a number, long or string.
-	 * @param {Long|number|string} value Value
-	 * @returns {util.LongBits} Instance
-	 */
-	LongBits.from = function from(value) {
-	    if (typeof value === "number")
-	        return LongBits.fromNumber(value);
-	    if (util.isString(value)) {
-	        /* istanbul ignore else */
-	        if (util.Long)
-	            value = util.Long.fromString(value);
-	        else
-	            return LongBits.fromNumber(parseInt(value, 10));
-	    }
-	    return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
-	};
-
-	/**
-	 * Converts this long bits to a possibly unsafe JavaScript number.
-	 * @param {boolean} [unsigned=false] Whether unsigned or not
-	 * @returns {number} Possibly unsafe number
-	 */
-	LongBits.prototype.toNumber = function toNumber(unsigned) {
-	    if (!unsigned && this.hi >>> 31) {
-	        var lo = ~this.lo + 1 >>> 0,
-	            hi = ~this.hi     >>> 0;
-	        if (!lo)
-	            hi = hi + 1 >>> 0;
-	        return -(lo + hi * 4294967296);
-	    }
-	    return this.lo + this.hi * 4294967296;
-	};
-
-	/**
-	 * Converts this long bits to a long.
-	 * @param {boolean} [unsigned=false] Whether unsigned or not
-	 * @returns {Long} Long
-	 */
-	LongBits.prototype.toLong = function toLong(unsigned) {
-	    return util.Long
-	        ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned))
-	        /* istanbul ignore next */
-	        : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };
-	};
-
-	var charCodeAt = String.prototype.charCodeAt;
-
-	/**
-	 * Constructs new long bits from the specified 8 characters long hash.
-	 * @param {string} hash Hash
-	 * @returns {util.LongBits} Bits
-	 */
-	LongBits.fromHash = function fromHash(hash) {
-	    if (hash === zeroHash)
-	        return zero;
-	    return new LongBits(
-	        ( charCodeAt.call(hash, 0)
-	        | charCodeAt.call(hash, 1) << 8
-	        | charCodeAt.call(hash, 2) << 16
-	        | charCodeAt.call(hash, 3) << 24) >>> 0
-	    ,
-	        ( charCodeAt.call(hash, 4)
-	        | charCodeAt.call(hash, 5) << 8
-	        | charCodeAt.call(hash, 6) << 16
-	        | charCodeAt.call(hash, 7) << 24) >>> 0
-	    );
-	};
-
-	/**
-	 * Converts this long bits to a 8 characters long hash.
-	 * @returns {string} Hash
-	 */
-	LongBits.prototype.toHash = function toHash() {
-	    return String.fromCharCode(
-	        this.lo        & 255,
-	        this.lo >>> 8  & 255,
-	        this.lo >>> 16 & 255,
-	        this.lo >>> 24      ,
-	        this.hi        & 255,
-	        this.hi >>> 8  & 255,
-	        this.hi >>> 16 & 255,
-	        this.hi >>> 24
-	    );
-	};
-
-	/**
-	 * Zig-zag encodes this long bits.
-	 * @returns {util.LongBits} `this`
-	 */
-	LongBits.prototype.zzEncode = function zzEncode() {
-	    var mask =   this.hi >> 31;
-	    this.hi  = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
-	    this.lo  = ( this.lo << 1                   ^ mask) >>> 0;
-	    return this;
-	};
-
-	/**
-	 * Zig-zag decodes this long bits.
-	 * @returns {util.LongBits} `this`
-	 */
-	LongBits.prototype.zzDecode = function zzDecode() {
-	    var mask = -(this.lo & 1);
-	    this.lo  = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
-	    this.hi  = ( this.hi >>> 1                  ^ mask) >>> 0;
-	    return this;
-	};
-
-	/**
-	 * Calculates the length of this longbits when encoded as a varint.
-	 * @returns {number} Length
-	 */
-	LongBits.prototype.length = function length() {
-	    var part0 =  this.lo,
-	        part1 = (this.lo >>> 28 | this.hi << 4) >>> 0,
-	        part2 =  this.hi >>> 24;
-	    return part2 === 0
-	         ? part1 === 0
-	           ? part0 < 16384
-	             ? part0 < 128 ? 1 : 2
-	             : part0 < 2097152 ? 3 : 4
-	           : part1 < 16384
-	             ? part1 < 128 ? 5 : 6
-	             : part1 < 2097152 ? 7 : 8
-	         : part2 < 128 ? 9 : 10;
-	};
-	return longbits;
+const f32 = new Float32Array([-0]);
+const f8b = new Uint8Array(f32.buffer);
+/**
+ * Writes a 32 bit float to a buffer using little endian byte order
+ */
+function writeFloatLE(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 hasRequiredMinimal;
-
-function requireMinimal () {
-	if (hasRequiredMinimal) return minimal;
-	hasRequiredMinimal = 1;
-	(function (exports) {
-		var util = exports;
-
-		// used to return a Promise where callback is omitted
-		util.asPromise = requireAspromise();
-
-		// converts to / from base64 encoded strings
-		util.base64 = requireBase64();
-
-		// base class of rpc.Service
-		util.EventEmitter = requireEventemitter();
-
-		// float handling accross browsers
-		util.float = requireFloat();
-
-		// requires modules optionally and hides the call from bundlers
-		util.inquire = requireInquire();
-
-		// converts to / from utf8 encoded strings
-		util.utf8 = requireUtf8();
-
-		// provides a node-like buffer pool in the browser
-		util.pool = requirePool();
-
-		// utility to work with the low and high bits of a 64 bit value
-		util.LongBits = requireLongbits();
-
-		/**
-		 * Whether running within node or not.
-		 * @memberof util
-		 * @type {boolean}
-		 */
-		util.isNode = Boolean(typeof commonjsGlobal !== "undefined"
-		                   && commonjsGlobal
-		                   && commonjsGlobal.process
-		                   && commonjsGlobal.process.versions
-		                   && commonjsGlobal.process.versions.node);
-
-		/**
-		 * Global object reference.
-		 * @memberof util
-		 * @type {Object}
-		 */
-		util.global = util.isNode && commonjsGlobal
-		           || typeof window !== "undefined" && window
-		           || typeof self   !== "undefined" && self
-		           || commonjsGlobal; // eslint-disable-line no-invalid-this
-
-		/**
-		 * An immuable empty array.
-		 * @memberof util
-		 * @type {Array.<*>}
-		 * @const
-		 */
-		util.emptyArray = Object.freeze ? Object.freeze([]) : /* istanbul ignore next */ []; // used on prototypes
-
-		/**
-		 * An immutable empty object.
-		 * @type {Object}
-		 * @const
-		 */
-		util.emptyObject = Object.freeze ? Object.freeze({}) : /* istanbul ignore next */ {}; // used on prototypes
-
-		/**
-		 * Tests if the specified value is an integer.
-		 * @function
-		 * @param {*} value Value to test
-		 * @returns {boolean} `true` if the value is an integer
-		 */
-		util.isInteger = Number.isInteger || /* istanbul ignore next */ function isInteger(value) {
-		    return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
-		};
-
-		/**
-		 * Tests if the specified value is a string.
-		 * @param {*} value Value to test
-		 * @returns {boolean} `true` if the value is a string
-		 */
-		util.isString = function isString(value) {
-		    return typeof value === "string" || value instanceof String;
-		};
-
-		/**
-		 * Tests if the specified value is a non-null object.
-		 * @param {*} value Value to test
-		 * @returns {boolean} `true` if the value is a non-null object
-		 */
-		util.isObject = function isObject(value) {
-		    return value && typeof value === "object";
-		};
-
-		/**
-		 * Checks if a property on a message is considered to be present.
-		 * This is an alias of {@link util.isSet}.
-		 * @function
-		 * @param {Object} obj Plain object or message instance
-		 * @param {string} prop Property name
-		 * @returns {boolean} `true` if considered to be present, otherwise `false`
-		 */
-		util.isset =
-
-		/**
-		 * Checks if a property on a message is considered to be present.
-		 * @param {Object} obj Plain object or message instance
-		 * @param {string} prop Property name
-		 * @returns {boolean} `true` if considered to be present, otherwise `false`
-		 */
-		util.isSet = function isSet(obj, prop) {
-		    var value = obj[prop];
-		    if (value != null && obj.hasOwnProperty(prop)) // eslint-disable-line eqeqeq, no-prototype-builtins
-		        return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
-		    return false;
-		};
-
-		/**
-		 * Any compatible Buffer instance.
-		 * This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.
-		 * @interface Buffer
-		 * @extends Uint8Array
-		 */
-
-		/**
-		 * Node's Buffer class if available.
-		 * @type {Constructor<Buffer>}
-		 */
-		util.Buffer = (function() {
-		    try {
-		        var Buffer = util.inquire("buffer").Buffer;
-		        // refuse to use non-node buffers if not explicitly assigned (perf reasons):
-		        return Buffer.prototype.utf8Write ? Buffer : /* istanbul ignore next */ null;
-		    } catch (e) {
-		        /* istanbul ignore next */
-		        return null;
-		    }
-		})();
-
-		// Internal alias of or polyfull for Buffer.from.
-		util._Buffer_from = null;
-
-		// Internal alias of or polyfill for Buffer.allocUnsafe.
-		util._Buffer_allocUnsafe = null;
-
-		/**
-		 * Creates a new buffer of whatever type supported by the environment.
-		 * @param {number|number[]} [sizeOrArray=0] Buffer size or number array
-		 * @returns {Uint8Array|Buffer} Buffer
-		 */
-		util.newBuffer = function newBuffer(sizeOrArray) {
-		    /* istanbul ignore next */
-		    return typeof sizeOrArray === "number"
-		        ? util.Buffer
-		            ? util._Buffer_allocUnsafe(sizeOrArray)
-		            : new util.Array(sizeOrArray)
-		        : util.Buffer
-		            ? util._Buffer_from(sizeOrArray)
-		            : typeof Uint8Array === "undefined"
-		                ? sizeOrArray
-		                : new Uint8Array(sizeOrArray);
-		};
-
-		/**
-		 * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.
-		 * @type {Constructor<Uint8Array>}
-		 */
-		util.Array = typeof Uint8Array !== "undefined" ? Uint8Array /* istanbul ignore next */ : Array;
-
-		/**
-		 * Any compatible Long instance.
-		 * This is a minimal stand-alone definition of a Long instance. The actual type is that exported by long.js.
-		 * @interface Long
-		 * @property {number} low Low bits
-		 * @property {number} high High bits
-		 * @property {boolean} unsigned Whether unsigned or not
-		 */
-
-		/**
-		 * Long.js's Long class if available.
-		 * @type {Constructor<Long>}
-		 */
-		util.Long = /* istanbul ignore next */ util.global.dcodeIO && /* istanbul ignore next */ util.global.dcodeIO.Long
-		         || /* istanbul ignore next */ util.global.Long
-		         || util.inquire("long");
-
-		/**
-		 * Regular expression used to verify 2 bit (`bool`) map keys.
-		 * @type {RegExp}
-		 * @const
-		 */
-		util.key2Re = /^true|false|0|1$/;
-
-		/**
-		 * Regular expression used to verify 32 bit (`int32` etc.) map keys.
-		 * @type {RegExp}
-		 * @const
-		 */
-		util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
-
-		/**
-		 * Regular expression used to verify 64 bit (`int64` etc.) map keys.
-		 * @type {RegExp}
-		 * @const
-		 */
-		util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
-
-		/**
-		 * Converts a number or long to an 8 characters long hash string.
-		 * @param {Long|number} value Value to convert
-		 * @returns {string} Hash
-		 */
-		util.longToHash = function longToHash(value) {
-		    return value
-		        ? util.LongBits.from(value).toHash()
-		        : util.LongBits.zeroHash;
-		};
-
-		/**
-		 * Converts an 8 characters long hash string to a long or number.
-		 * @param {string} hash Hash
-		 * @param {boolean} [unsigned=false] Whether unsigned or not
-		 * @returns {Long|number} Original value
-		 */
-		util.longFromHash = function longFromHash(hash, unsigned) {
-		    var bits = util.LongBits.fromHash(hash);
-		    if (util.Long)
-		        return util.Long.fromBits(bits.lo, bits.hi, unsigned);
-		    return bits.toNumber(Boolean(unsigned));
-		};
-
-		/**
-		 * Merges the properties of the source object into the destination object.
-		 * @memberof util
-		 * @param {Object.<string,*>} dst Destination object
-		 * @param {Object.<string,*>} src Source object
-		 * @param {boolean} [ifNotSet=false] Merges only if the key is not already set
-		 * @returns {Object.<string,*>} Destination object
-		 */
-		function merge(dst, src, ifNotSet) { // used by converters
-		    for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
-		        if (dst[keys[i]] === undefined || !ifNotSet)
-		            dst[keys[i]] = src[keys[i]];
-		    return dst;
-		}
-
-		util.merge = merge;
-
-		/**
-		 * Converts the first character of a string to lower case.
-		 * @param {string} str String to convert
-		 * @returns {string} Converted string
-		 */
-		util.lcFirst = function lcFirst(str) {
-		    return str.charAt(0).toLowerCase() + str.substring(1);
-		};
-
-		/**
-		 * Creates a custom error constructor.
-		 * @memberof util
-		 * @param {string} name Error name
-		 * @returns {Constructor<Error>} Custom error constructor
-		 */
-		function newError(name) {
-
-		    function CustomError(message, properties) {
-
-		        if (!(this instanceof CustomError))
-		            return new CustomError(message, properties);
-
-		        // Error.call(this, message);
-		        // ^ just returns a new error instance because the ctor can be called as a function
-
-		        Object.defineProperty(this, "message", { get: function() { return message; } });
-
-		        /* istanbul ignore next */
-		        if (Error.captureStackTrace) // node
-		            Error.captureStackTrace(this, CustomError);
-		        else
-		            Object.defineProperty(this, "stack", { value: new Error().stack || "" });
-
-		        if (properties)
-		            merge(this, properties);
-		    }
-
-		    CustomError.prototype = Object.create(Error.prototype, {
-		        constructor: {
-		            value: CustomError,
-		            writable: true,
-		            enumerable: false,
-		            configurable: true,
-		        },
-		        name: {
-		            get: function get() { return name; },
-		            set: undefined,
-		            enumerable: false,
-		            // configurable: false would accurately preserve the behavior of
-		            // the original, but I'm guessing that was not intentional.
-		            // For an actual error subclass, this property would
-		            // be configurable.
-		            configurable: true,
-		        },
-		        toString: {
-		            value: function value() { return this.name + ": " + this.message; },
-		            writable: true,
-		            enumerable: false,
-		            configurable: true,
-		        },
-		    });
-
-		    return CustomError;
-		}
-
-		util.newError = newError;
-
-		/**
-		 * Constructs a new protocol error.
-		 * @classdesc Error subclass indicating a protocol specifc error.
-		 * @memberof util
-		 * @extends Error
-		 * @template T extends Message<T>
-		 * @constructor
-		 * @param {string} message Error message
-		 * @param {Object.<string,*>} [properties] Additional properties
-		 * @example
-		 * try {
-		 *     MyMessage.decode(someBuffer); // throws if required fields are missing
-		 * } catch (e) {
-		 *     if (e instanceof ProtocolError && e.instance)
-		 *         console.log("decoded so far: " + JSON.stringify(e.instance));
-		 * }
-		 */
-		util.ProtocolError = newError("ProtocolError");
-
-		/**
-		 * So far decoded message instance.
-		 * @name util.ProtocolError#instance
-		 * @type {Message<T>}
-		 */
-
-		/**
-		 * A OneOf getter as returned by {@link util.oneOfGetter}.
-		 * @typedef OneOfGetter
-		 * @type {function}
-		 * @returns {string|undefined} Set field name, if any
-		 */
-
-		/**
-		 * Builds a getter for a oneof's present field name.
-		 * @param {string[]} fieldNames Field names
-		 * @returns {OneOfGetter} Unbound getter
-		 */
-		util.oneOfGetter = function getOneOf(fieldNames) {
-		    var fieldMap = {};
-		    for (var i = 0; i < fieldNames.length; ++i)
-		        fieldMap[fieldNames[i]] = 1;
-
-		    /**
-		     * @returns {string|undefined} Set field name, if any
-		     * @this Object
-		     * @ignore
-		     */
-		    return function() { // eslint-disable-line consistent-return
-		        for (var keys = Object.keys(this), i = keys.length - 1; i > -1; --i)
-		            if (fieldMap[keys[i]] === 1 && this[keys[i]] !== undefined && this[keys[i]] !== null)
-		                return keys[i];
-		    };
-		};
-
-		/**
-		 * A OneOf setter as returned by {@link util.oneOfSetter}.
-		 * @typedef OneOfSetter
-		 * @type {function}
-		 * @param {string|undefined} value Field name
-		 * @returns {undefined}
-		 */
-
-		/**
-		 * Builds a setter for a oneof's present field name.
-		 * @param {string[]} fieldNames Field names
-		 * @returns {OneOfSetter} Unbound setter
-		 */
-		util.oneOfSetter = function setOneOf(fieldNames) {
-
-		    /**
-		     * @param {string} name Field name
-		     * @returns {undefined}
-		     * @this Object
-		     * @ignore
-		     */
-		    return function(name) {
-		        for (var i = 0; i < fieldNames.length; ++i)
-		            if (fieldNames[i] !== name)
-		                delete this[fieldNames[i]];
-		    };
-		};
-
-		/**
-		 * Default conversion options used for {@link Message#toJSON} implementations.
-		 *
-		 * These options are close to proto3's JSON mapping with the exception that internal types like Any are handled just like messages. More precisely:
-		 *
-		 * - Longs become strings
-		 * - Enums become string keys
-		 * - Bytes become base64 encoded strings
-		 * - (Sub-)Messages become plain objects
-		 * - Maps become plain objects with all string keys
-		 * - Repeated fields become arrays
-		 * - NaN and Infinity for float and double fields become strings
-		 *
-		 * @type {IConversionOptions}
-		 * @see https://developers.google.com/protocol-buffers/docs/proto3?hl=en#json
-		 */
-		util.toJSONOptions = {
-		    longs: String,
-		    enums: String,
-		    bytes: String,
-		    json: true
-		};
-
-		// Sets up buffer utility according to the environment (called in index-minimal)
-		util._configure = function() {
-		    var Buffer = util.Buffer;
-		    /* istanbul ignore if */
-		    if (!Buffer) {
-		        util._Buffer_from = util._Buffer_allocUnsafe = null;
-		        return;
-		    }
-		    // because node 4.x buffers are incompatible & immutable
-		    // see: https://github.com/dcodeIO/protobuf.js/pull/665
-		    util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from ||
-		        /* istanbul ignore next */
-		        function Buffer_from(value, encoding) {
-		            return new Buffer(value, encoding);
-		        };
-		    util._Buffer_allocUnsafe = Buffer.allocUnsafe ||
-		        /* istanbul ignore next */
-		        function Buffer_allocUnsafe(size) {
-		            return new Buffer(size);
-		        };
-		}; 
-	} (minimal));
-	return minimal;
+/**
+ * Reads a 32 bit float from a buffer using little endian byte order
+ */
+function readFloatLE(buf, pos) {
+    f8b[0] = buf[pos];
+    f8b[1] = buf[pos + 1];
+    f8b[2] = buf[pos + 2];
+    f8b[3] = buf[pos + 3];
+    return f32[0];
 }
-
-var reader$1 = Reader$1;
-
-var util$4      = requireMinimal();
-
-var BufferReader$1; // cyclic
-
-var LongBits$1  = util$4.LongBits,
-    utf8$1      = util$4.utf8;
-
-/* istanbul ignore next */
-function indexOutOfRange(reader, writeLength) {
-    return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
+const f64 = new Float64Array([-0]);
+const d8b = new Uint8Array(f64.buffer);
+/**
+ * Writes a 64 bit double to a buffer using little endian byte order
+ */
+function writeDoubleLE(val, buf, pos) {
+    f64[0] = val;
+    buf[pos] = d8b[0];
+    buf[pos + 1] = d8b[1];
+    buf[pos + 2] = d8b[2];
+    buf[pos + 3] = d8b[3];
+    buf[pos + 4] = d8b[4];
+    buf[pos + 5] = d8b[5];
+    buf[pos + 6] = d8b[6];
+    buf[pos + 7] = d8b[7];
 }
-
 /**
- * Constructs a new reader instance using the specified buffer.
- * @classdesc Wire format reader using `Uint8Array` if available, otherwise `Array`.
- * @constructor
- * @param {Uint8Array} buffer Buffer to read from
+ * Reads a 64 bit double from a buffer using little endian byte order
  */
-function Reader$1(buffer) {
+function readDoubleLE(buf, pos) {
+    d8b[0] = buf[pos];
+    d8b[1] = buf[pos + 1];
+    d8b[2] = buf[pos + 2];
+    d8b[3] = buf[pos + 3];
+    d8b[4] = buf[pos + 4];
+    d8b[5] = buf[pos + 5];
+    d8b[6] = buf[pos + 6];
+    d8b[7] = buf[pos + 7];
+    return f64[0];
+}
 
+// the largest BigInt we can safely downcast to a Number
+const MAX_SAFE_NUMBER_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+const MIN_SAFE_NUMBER_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
+/**
+ * Constructs new long bits.
+ *
+ * @classdesc Helper class for working with the low and high bits of a 64 bit value.
+ * @memberof util
+ * @function Object() { [native code] }
+ * @param {number} lo - Low 32 bits, unsigned
+ * @param {number} hi - High 32 bits, unsigned
+ */
+class LongBits {
+    lo;
+    hi;
+    constructor(lo, hi) {
+        // note that the casts below are theoretically unnecessary as of today, but older statically
+        // generated converter code might still call the ctor with signed 32bits. kept for compat.
+        /**
+         * Low bits
+         */
+        this.lo = lo | 0;
+        /**
+         * High bits
+         */
+        this.hi = hi | 0;
+    }
     /**
-     * Read buffer.
-     * @type {Uint8Array}
+     * Converts this long bits to a possibly unsafe JavaScript number
      */
-    this.buf = buffer;
-
+    toNumber(unsigned = false) {
+        if (!unsigned && (this.hi >>> 31) > 0) {
+            const lo = ~this.lo + 1 >>> 0;
+            let hi = ~this.hi >>> 0;
+            if (lo === 0) {
+                hi = hi + 1 >>> 0;
+            }
+            return -(lo + hi * 4294967296);
+        }
+        return this.lo + this.hi * 4294967296;
+    }
     /**
-     * Read buffer position.
-     * @type {number}
+     * Converts this long bits to a bigint
      */
-    this.pos = 0;
-
+    toBigInt(unsigned = false) {
+        if (unsigned) {
+            return BigInt(this.lo >>> 0) + (BigInt(this.hi >>> 0) << 32n);
+        }
+        if ((this.hi >>> 31) !== 0) {
+            const lo = ~this.lo + 1 >>> 0;
+            let hi = ~this.hi >>> 0;
+            if (lo === 0) {
+                hi = hi + 1 >>> 0;
+            }
+            return -(BigInt(lo) + (BigInt(hi) << 32n));
+        }
+        return BigInt(this.lo >>> 0) + (BigInt(this.hi >>> 0) << 32n);
+    }
     /**
-     * Read buffer length.
-     * @type {number}
+     * Converts this long bits to a string
      */
-    this.len = buffer.length;
-}
-
-var create_array = typeof Uint8Array !== "undefined"
-    ? function create_typed_array(buffer) {
-        if (buffer instanceof Uint8Array || Array.isArray(buffer))
-            return new Reader$1(buffer);
-        throw Error("illegal buffer");
-    }
-    /* istanbul ignore next */
-    : function create_array(buffer) {
-        if (Array.isArray(buffer))
-            return new Reader$1(buffer);
-        throw Error("illegal buffer");
-    };
-
-var create$1 = function create() {
-    return util$4.Buffer
-        ? function create_buffer_setup(buffer) {
-            return (Reader$1.create = function create_buffer(buffer) {
-                return util$4.Buffer.isBuffer(buffer)
-                    ? new BufferReader$1(buffer)
-                    /* istanbul ignore next */
-                    : create_array(buffer);
-            })(buffer);
+    toString(unsigned = false) {
+        return this.toBigInt(unsigned).toString();
+    }
+    /**
+     * Zig-zag encodes this long bits
+     */
+    zzEncode() {
+        const mask = this.hi >> 31;
+        this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
+        this.lo = (this.lo << 1 ^ mask) >>> 0;
+        return this;
+    }
+    /**
+     * Zig-zag decodes this long bits
+     */
+    zzDecode() {
+        const mask = -(this.lo & 1);
+        this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
+        this.hi = (this.hi >>> 1 ^ mask) >>> 0;
+        return this;
+    }
+    /**
+     * Calculates the length of this longbits when encoded as a varint.
+     */
+    length() {
+        const part0 = this.lo;
+        const part1 = (this.lo >>> 28 | this.hi << 4) >>> 0;
+        const part2 = this.hi >>> 24;
+        return part2 === 0
+            ? part1 === 0
+                ? part0 < 16384
+                    ? part0 < 128 ? 1 : 2
+                    : part0 < 2097152 ? 3 : 4
+                : part1 < 16384
+                    ? part1 < 128 ? 5 : 6
+                    : part1 < 2097152 ? 7 : 8
+            : part2 < 128 ? 9 : 10;
+    }
+    /**
+     * Constructs new long bits from the specified number
+     */
+    static fromBigInt(value) {
+        if (value === 0n) {
+            return zero;
         }
-        /* istanbul ignore next */
-        : create_array;
-};
-
-/**
- * Creates a new reader using the specified buffer.
- * @function
- * @param {Uint8Array|Buffer} buffer Buffer to read from
- * @returns {Reader|BufferReader} A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}
- * @throws {Error} If `buffer` is not a valid buffer
- */
-Reader$1.create = create$1();
-
-Reader$1.prototype._slice = util$4.Array.prototype.subarray || /* istanbul ignore next */ util$4.Array.prototype.slice;
-
-/**
- * Reads a varint as an unsigned 32 bit value.
- * @function
- * @returns {number} Value read
- */
-Reader$1.prototype.uint32 = (function read_uint32_setup() {
-    var value = 4294967295; // optimizer type-hint, tends to deopt otherwise (?!)
-    return function read_uint32() {
-        value = (         this.buf[this.pos] & 127       ) >>> 0; if (this.buf[this.pos++] < 128) return value;
-        value = (value | (this.buf[this.pos] & 127) <<  7) >>> 0; if (this.buf[this.pos++] < 128) return value;
-        value = (value | (this.buf[this.pos] & 127) << 14) >>> 0; if (this.buf[this.pos++] < 128) return value;
-        value = (value | (this.buf[this.pos] & 127) << 21) >>> 0; if (this.buf[this.pos++] < 128) return value;
-        value = (value | (this.buf[this.pos] &  15) << 28) >>> 0; if (this.buf[this.pos++] < 128) return value;
-
-        /* istanbul ignore if */
-        if ((this.pos += 5) > this.len) {
-            this.pos = this.len;
-            throw indexOutOfRange(this, 10);
+        if (value < MAX_SAFE_NUMBER_INTEGER && value > MIN_SAFE_NUMBER_INTEGER) {
+            return this.fromNumber(Number(value));
         }
-        return value;
-    };
-})();
+        const negative = value < 0n;
+        if (negative) {
+            value = -value;
+        }
+        let hi = value >> 32n;
+        let lo = value - (hi << 32n);
+        if (negative) {
+            hi = ~hi | 0n;
+            lo = ~lo | 0n;
+            if (++lo > TWO_32) {
+                lo = 0n;
+                if (++hi > TWO_32) {
+                    hi = 0n;
+                }
+            }
+        }
+        return new LongBits(Number(lo), Number(hi));
+    }
+    /**
+     * Constructs new long bits from the specified number
+     */
+    static fromNumber(value) {
+        if (value === 0) {
+            return zero;
+        }
+        const sign = value < 0;
+        if (sign) {
+            value = -value;
+        }
+        let lo = value >>> 0;
+        let hi = (value - lo) / 4294967296 >>> 0;
+        if (sign) {
+            hi = ~hi >>> 0;
+            lo = ~lo >>> 0;
+            if (++lo > 4294967295) {
+                lo = 0;
+                if (++hi > 4294967295) {
+                    hi = 0;
+                }
+            }
+        }
+        return new LongBits(lo, hi);
+    }
+    /**
+     * Constructs new long bits from a number, long or string
+     */
+    static from(value) {
+        if (typeof value === 'number') {
+            return LongBits.fromNumber(value);
+        }
+        if (typeof value === 'bigint') {
+            return LongBits.fromBigInt(value);
+        }
+        if (typeof value === 'string') {
+            return LongBits.fromBigInt(BigInt(value));
+        }
+        return value.low != null || value.high != null ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
+    }
+}
+const zero = new LongBits(0, 0);
+zero.toBigInt = function () { return 0n; };
+zero.zzEncode = zero.zzDecode = function () { return this; };
+zero.length = function () { return 1; };
+const TWO_32 = 4294967296n;
 
 /**
- * Reads a varint as a signed 32 bit value.
- * @returns {number} Value read
+ * Calculates the UTF8 byte length of a string
  */
-Reader$1.prototype.int32 = function read_int32() {
-    return this.uint32() | 0;
-};
-
+function length(string) {
+    let len = 0;
+    let c = 0;
+    for (let 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 a zig-zag encoded varint as a signed 32 bit value.
- * @returns {number} Value read
+ * Reads UTF8 bytes as a string
  */
-Reader$1.prototype.sint32 = function read_sint32() {
-    var value = this.uint32();
-    return value >>> 1 ^ -(value & 1) | 0;
-};
-
-/* eslint-disable no-invalid-this */
-
-function readLongVarint() {
-    // tends to deopt with local vars for octet etc.
-    var bits = new LongBits$1(0, 0);
-    var i = 0;
-    if (this.len - this.pos > 4) { // fast route (lo)
-        for (; i < 4; ++i) {
-            // 1st..4th
-            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
-            if (this.buf[this.pos++] < 128)
-                return bits;
+function read(buffer, start, end) {
+    const len = end - start;
+    if (len < 1) {
+        return '';
+    }
+    let parts;
+    const chunk = [];
+    let i = 0; // char offset
+    let t; // temporary
+    while (start < end) {
+        t = buffer[start++];
+        if (t < 128) {
+            chunk[i++] = t;
         }
-        // 5th
-        bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
-        bits.hi = (bits.hi | (this.buf[this.pos] & 127) >>  4) >>> 0;
-        if (this.buf[this.pos++] < 128)
-            return bits;
-        i = 0;
-    } else {
-        for (; i < 3; ++i) {
-            /* istanbul ignore if */
-            if (this.pos >= this.len)
-                throw indexOutOfRange(this);
-            // 1st..3th
-            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
-            if (this.buf[this.pos++] < 128)
-                return bits;
+        else if (t > 191 && t < 224) {
+            chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
         }
-        // 4th
-        bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
-        return bits;
-    }
-    if (this.len - this.pos > 4) { // fast route (hi)
-        for (; i < 5; ++i) {
-            // 6th..10th
-            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
-            if (this.buf[this.pos++] < 128)
-                return bits;
+        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 {
-        for (; i < 5; ++i) {
-            /* istanbul ignore if */
-            if (this.pos >= this.len)
-                throw indexOutOfRange(this);
-            // 6th..10th
-            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
-            if (this.buf[this.pos++] < 128)
-                return bits;
+        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;
         }
     }
-    /* istanbul ignore next */
-    throw Error("invalid varint encoding");
+    if (parts != null) {
+        if (i > 0) {
+            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+        }
+        return parts.join('');
+    }
+    return String.fromCharCode.apply(String, chunk.slice(0, i));
 }
-
-/* eslint-enable no-invalid-this */
-
 /**
- * Reads a varint as a signed 64 bit value.
- * @name Reader#int64
- * @function
- * @returns {Long} Value read
+ * Writes a string as UTF8 bytes
  */
+function write(string, buffer, offset) {
+    const start = offset;
+    let c1; // character 1
+    let c2; // character 2
+    for (let 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;
+}
 
+/* istanbul ignore next */
+function indexOutOfRange(reader, writeLength) {
+    return RangeError(`index out of range: ${reader.pos} + ${writeLength ?? 1} > ${reader.len}`);
+}
+function readFixed32End(buf, end) {
+    return (buf[end - 4] |
+        buf[end - 3] << 8 |
+        buf[end - 2] << 16 |
+        buf[end - 1] << 24) >>> 0;
+}
 /**
- * Reads a varint as an unsigned 64 bit value.
- * @name Reader#uint64
- * @function
- * @returns {Long} Value read
+ * Constructs a new reader instance using the specified buffer.
  */
-
-/**
- * Reads a zig-zag encoded varint as a signed 64 bit value.
- * @name Reader#sint64
- * @function
- * @returns {Long} Value read
- */
-
-/**
- * Reads a varint as a boolean.
- * @returns {boolean} Value read
- */
-Reader$1.prototype.bool = function read_bool() {
-    return this.uint32() !== 0;
-};
-
-function readFixed32_end(buf, end) { // note that this uses `end`, not `pos`
-    return (buf[end - 4]
-          | buf[end - 3] << 8
-          | buf[end - 2] << 16
-          | buf[end - 1] << 24) >>> 0;
-}
-
-/**
- * Reads fixed 32 bits as an unsigned 32 bit integer.
- * @returns {number} Value read
- */
-Reader$1.prototype.fixed32 = function read_fixed32() {
-
-    /* istanbul ignore if */
-    if (this.pos + 4 > this.len)
-        throw indexOutOfRange(this, 4);
-
-    return readFixed32_end(this.buf, this.pos += 4);
-};
-
-/**
- * Reads fixed 32 bits as a signed 32 bit integer.
- * @returns {number} Value read
- */
-Reader$1.prototype.sfixed32 = function read_sfixed32() {
-
-    /* istanbul ignore if */
-    if (this.pos + 4 > this.len)
-        throw indexOutOfRange(this, 4);
-
-    return readFixed32_end(this.buf, this.pos += 4) | 0;
-};
-
-/* eslint-disable no-invalid-this */
-
-function readFixed64(/* this: Reader */) {
-
-    /* istanbul ignore if */
-    if (this.pos + 8 > this.len)
-        throw indexOutOfRange(this, 8);
-
-    return new LongBits$1(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));
-}
-
-/* eslint-enable no-invalid-this */
-
-/**
- * Reads fixed 64 bits.
- * @name Reader#fixed64
- * @function
- * @returns {Long} Value read
- */
-
-/**
- * Reads zig-zag encoded fixed 64 bits.
- * @name Reader#sfixed64
- * @function
- * @returns {Long} Value read
- */
-
-/**
- * Reads a float (32 bit) as a number.
- * @function
- * @returns {number} Value read
- */
-Reader$1.prototype.float = function read_float() {
-
-    /* istanbul ignore if */
-    if (this.pos + 4 > this.len)
-        throw indexOutOfRange(this, 4);
-
-    var value = util$4.float.readFloatLE(this.buf, this.pos);
-    this.pos += 4;
-    return value;
-};
-
-/**
- * Reads a double (64 bit float) as a number.
- * @function
- * @returns {number} Value read
- */
-Reader$1.prototype.double = function read_double() {
-
-    /* istanbul ignore if */
-    if (this.pos + 8 > this.len)
-        throw indexOutOfRange(this, 4);
-
-    var value = util$4.float.readDoubleLE(this.buf, this.pos);
-    this.pos += 8;
-    return value;
-};
-
-/**
- * Reads a sequence of bytes preceeded by its length as a varint.
- * @returns {Uint8Array} Value read
- */
-Reader$1.prototype.bytes = function read_bytes() {
-    var length = this.uint32(),
-        start  = this.pos,
-        end    = this.pos + length;
-
-    /* istanbul ignore if */
-    if (end > this.len)
-        throw indexOutOfRange(this, length);
-
-    this.pos += length;
-    if (Array.isArray(this.buf)) // plain array
-        return this.buf.slice(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);
-};
-
-/**
- * Reads a string preceeded by its byte length as a varint.
- * @returns {string} Value read
- */
-Reader$1.prototype.string = function read_string() {
-    var bytes = this.bytes();
-    return utf8$1.read(bytes, 0, bytes.length);
-};
-
-/**
- * Skips the specified number of bytes if specified, otherwise skips a varint.
- * @param {number} [length] Length if known, otherwise a varint is assumed
- * @returns {Reader} `this`
- */
-Reader$1.prototype.skip = function skip(length) {
-    if (typeof length === "number") {
+class Uint8ArrayReader {
+    buf;
+    pos;
+    len;
+    _slice = Uint8Array.prototype.subarray;
+    constructor(buffer) {
+        /**
+         * Read buffer
+         */
+        this.buf = buffer;
+        /**
+         * Read buffer position
+         */
+        this.pos = 0;
+        /**
+         * Read buffer length
+         */
+        this.len = buffer.length;
+    }
+    /**
+     * Reads a varint as an unsigned 32 bit value
+     */
+    uint32() {
+        let value = 4294967295;
+        value = (this.buf[this.pos] & 127) >>> 0;
+        if (this.buf[this.pos++] < 128)
+            return value;
+        value = (value | (this.buf[this.pos] & 127) << 7) >>> 0;
+        if (this.buf[this.pos++] < 128)
+            return value;
+        value = (value | (this.buf[this.pos] & 127) << 14) >>> 0;
+        if (this.buf[this.pos++] < 128)
+            return value;
+        value = (value | (this.buf[this.pos] & 127) << 21) >>> 0;
+        if (this.buf[this.pos++] < 128)
+            return value;
+        value = (value | (this.buf[this.pos] & 15) << 28) >>> 0;
+        if (this.buf[this.pos++] < 128)
+            return value;
+        if ((this.pos += 5) > this.len) {
+            this.pos = this.len;
+            throw indexOutOfRange(this, 10);
+        }
+        return value;
+    }
+    /**
+     * Reads a varint as a signed 32 bit value
+     */
+    int32() {
+        return this.uint32() | 0;
+    }
+    /**
+     * Reads a zig-zag encoded varint as a signed 32 bit value
+     */
+    sint32() {
+        const value = this.uint32();
+        return value >>> 1 ^ -(value & 1) | 0;
+    }
+    /**
+     * Reads a varint as a boolean
+     */
+    bool() {
+        return this.uint32() !== 0;
+    }
+    /**
+     * Reads fixed 32 bits as an unsigned 32 bit integer
+     */
+    fixed32() {
+        if (this.pos + 4 > this.len) {
+            throw indexOutOfRange(this, 4);
+        }
+        const res = readFixed32End(this.buf, this.pos += 4);
+        return res;
+    }
+    /**
+     * Reads fixed 32 bits as a signed 32 bit integer
+     */
+    sfixed32() {
+        if (this.pos + 4 > this.len) {
+            throw indexOutOfRange(this, 4);
+        }
+        const res = readFixed32End(this.buf, this.pos += 4) | 0;
+        return res;
+    }
+    /**
+     * Reads a float (32 bit) as a number
+     */
+    float() {
+        if (this.pos + 4 > this.len) {
+            throw indexOutOfRange(this, 4);
+        }
+        const value = readFloatLE(this.buf, this.pos);
+        this.pos += 4;
+        return value;
+    }
+    /**
+     * Reads a double (64 bit float) as a number
+     */
+    double() {
+        /* istanbul ignore if */
+        if (this.pos + 8 > this.len) {
+            throw indexOutOfRange(this, 4);
+        }
+        const value = readDoubleLE(this.buf, this.pos);
+        this.pos += 8;
+        return value;
+    }
+    /**
+     * Reads a sequence of bytes preceded by its length as a varint
+     */
+    bytes() {
+        const length = this.uint32();
+        const start = this.pos;
+        const end = this.pos + length;
         /* istanbul ignore if */
-        if (this.pos + length > this.len)
+        if (end > this.len) {
             throw indexOutOfRange(this, length);
+        }
         this.pos += length;
-    } else {
-        do {
+        return start === end // fix for IE 10/Win8 and others' subarray returning array of size 1
+            ? new Uint8Array(0)
+            : this.buf.subarray(start, end);
+    }
+    /**
+     * Reads a string preceded by its byte length as a varint
+     */
+    string() {
+        const bytes = this.bytes();
+        return read(bytes, 0, bytes.length);
+    }
+    /**
+     * Skips the specified number of bytes if specified, otherwise skips a varint
+     */
+    skip(length) {
+        if (typeof length === 'number') {
             /* istanbul ignore if */
-            if (this.pos >= this.len)
-                throw indexOutOfRange(this);
-        } while (this.buf[this.pos++] & 128);
+            if (this.pos + length > this.len) {
+                throw indexOutOfRange(this, length);
+            }
+            this.pos += length;
+        }
+        else {
+            do {
+                /* istanbul ignore if */
+                if (this.pos >= this.len) {
+                    throw indexOutOfRange(this);
+                }
+            } while ((this.buf[this.pos++] & 128) !== 0);
+        }
+        return this;
     }
-    return this;
-};
-
-/**
- * Skips the next element of the specified wire type.
- * @param {number} wireType Wire type received
- * @returns {Reader} `this`
- */
-Reader$1.prototype.skipType = function(wireType) {
-    switch (wireType) {
-        case 0:
-            this.skip();
-            break;
-        case 1:
-            this.skip(8);
-            break;
-        case 2:
-            this.skip(this.uint32());
-            break;
-        case 3:
-            while ((wireType = this.uint32() & 7) !== 4) {
-                this.skipType(wireType);
+    /**
+     * Skips the next element of the specified wire type
+     */
+    skipType(wireType) {
+        switch (wireType) {
+            case 0:
+                this.skip();
+                break;
+            case 1:
+                this.skip(8);
+                break;
+            case 2:
+                this.skip(this.uint32());
+                break;
+            case 3:
+                while ((wireType = this.uint32() & 7) !== 4) {
+                    this.skipType(wireType);
+                }
+                break;
+            case 5:
+                this.skip(4);
+                break;
+            /* istanbul ignore next */
+            default:
+                throw Error(`invalid wire type ${wireType} at offset ${this.pos}`);
+        }
+        return this;
+    }
+    readLongVarint() {
+        // tends to deopt with local vars for octet etc.
+        const bits = new LongBits(0, 0);
+        let i = 0;
+        if (this.len - this.pos > 4) { // fast route (lo)
+            for (; i < 4; ++i) {
+                // 1st..4th
+                bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+                if (this.buf[this.pos++] < 128) {
+                    return bits;
+                }
             }
-            break;
-        case 5:
-            this.skip(4);
-            break;
-
-        /* istanbul ignore next */
-        default:
-            throw Error("invalid wire type " + wireType + " at offset " + this.pos);
+            // 5th
+            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
+            bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0;
+            if (this.buf[this.pos++] < 128) {
+                return bits;
+            }
+            i = 0;
+        }
+        else {
+            for (; i < 3; ++i) {
+                /* istanbul ignore if */
+                if (this.pos >= this.len) {
+                    throw indexOutOfRange(this);
+                }
+                // 1st..3th
+                bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+                if (this.buf[this.pos++] < 128) {
+                    return bits;
+                }
+            }
+            // 4th
+            bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
+            return bits;
+        }
+        if (this.len - this.pos > 4) { // fast route (hi)
+            for (; i < 5; ++i) {
+                // 6th..10th
+                bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+                if (this.buf[this.pos++] < 128) {
+                    return bits;
+                }
+            }
+        }
+        else {
+            for (; i < 5; ++i) {
+                if (this.pos >= this.len) {
+                    throw indexOutOfRange(this);
+                }
+                // 6th..10th
+                bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+                if (this.buf[this.pos++] < 128) {
+                    return bits;
+                }
+            }
+        }
+        throw Error('invalid varint encoding');
     }
-    return this;
-};
-
-Reader$1._configure = function(BufferReader_) {
-    BufferReader$1 = BufferReader_;
-    Reader$1.create = create$1();
-    BufferReader$1._configure();
-
-    var fn = util$4.Long ? "toLong" : /* istanbul ignore next */ "toNumber";
-    util$4.merge(Reader$1.prototype, {
-
-        int64: function read_int64() {
-            return readLongVarint.call(this)[fn](false);
-        },
-
-        uint64: function read_uint64() {
-            return readLongVarint.call(this)[fn](true);
-        },
-
-        sint64: function read_sint64() {
-            return readLongVarint.call(this).zzDecode()[fn](false);
-        },
-
-        fixed64: function read_fixed64() {
-            return readFixed64.call(this)[fn](true);
-        },
-
-        sfixed64: function read_sfixed64() {
-            return readFixed64.call(this)[fn](false);
+    readFixed64() {
+        if (this.pos + 8 > this.len) {
+            throw indexOutOfRange(this, 8);
         }
+        const lo = readFixed32End(this.buf, this.pos += 4);
+        const hi = readFixed32End(this.buf, this.pos += 4);
+        return new LongBits(lo, hi);
+    }
+    /**
+     * Reads a varint as a signed 64 bit value
+     */
+    int64() {
+        return this.readLongVarint().toBigInt();
+    }
+    /**
+     * Reads a varint as a signed 64 bit value returned as a possibly unsafe
+     * JavaScript number
+     */
+    int64Number() {
+        return this.readLongVarint().toNumber();
+    }
+    /**
+     * Reads a varint as a signed 64 bit value returned as a string
+     */
+    int64String() {
+        return this.readLongVarint().toString();
+    }
+    /**
+     * Reads a varint as an unsigned 64 bit value
+     */
+    uint64() {
+        return this.readLongVarint().toBigInt(true);
+    }
+    /**
+     * Reads a varint as an unsigned 64 bit value returned as a possibly unsafe
+     * JavaScript number
+     */
+    uint64Number() {
+        const value = decodeUint8Array(this.buf, this.pos);
+        this.pos += encodingLength(value);
+        return value;
+    }
+    /**
+     * Reads a varint as an unsigned 64 bit value returned as a string
+     */
+    uint64String() {
+        return this.readLongVarint().toString(true);
+    }
+    /**
+     * Reads a zig-zag encoded varint as a signed 64 bit value
+     */
+    sint64() {
+        return this.readLongVarint().zzDecode().toBigInt();
+    }
+    /**
+     * Reads a zig-zag encoded varint as a signed 64 bit value returned as a
+     * possibly unsafe JavaScript number
+     */
+    sint64Number() {
+        return this.readLongVarint().zzDecode().toNumber();
+    }
+    /**
+     * Reads a zig-zag encoded varint as a signed 64 bit value returned as a
+     * string
+     */
+    sint64String() {
+        return this.readLongVarint().zzDecode().toString();
+    }
+    /**
+     * Reads fixed 64 bits
+     */
+    fixed64() {
+        return this.readFixed64().toBigInt();
+    }
+    /**
+     * Reads fixed 64 bits returned as a possibly unsafe JavaScript number
+     */
+    fixed64Number() {
+        return this.readFixed64().toNumber();
+    }
+    /**
+     * Reads fixed 64 bits returned as a string
+     */
+    fixed64String() {
+        return this.readFixed64().toString();
+    }
+    /**
+     * Reads zig-zag encoded fixed 64 bits
+     */
+    sfixed64() {
+        return this.readFixed64().toBigInt();
+    }
+    /**
+     * Reads zig-zag encoded fixed 64 bits returned as a possibly unsafe
+     * JavaScript number
+     */
+    sfixed64Number() {
+        return this.readFixed64().toNumber();
+    }
+    /**
+     * Reads zig-zag encoded fixed 64 bits returned as a string
+     */
+    sfixed64String() {
+        return this.readFixed64().toString();
+    }
+}
+function createReader(buf) {
+    return new Uint8ArrayReader(buf instanceof Uint8Array ? buf : buf.subarray());
+}
 
-    });
-};
-
-var ReaderClass = /*@__PURE__*/getDefaultExportFromCjs(reader$1);
-
-var reader_buffer = BufferReader;
-
-// extends Reader
-var Reader = reader$1;
-(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
-
-var util$3 = requireMinimal();
+function decodeMessage(buf, codec, opts) {
+    const reader = createReader(buf);
+    return codec.decode(reader, undefined, opts);
+}
 
 /**
- * Constructs a new buffer reader instance.
- * @classdesc Wire format reader using node buffers.
- * @extends Reader
- * @constructor
- * @param {Buffer} buffer Buffer to read from
+ * A general purpose buffer pool
  */
-function BufferReader(buffer) {
-    Reader.call(this, buffer);
+function pool(size) {
+    const SIZE = size ?? 8192;
+    const MAX = SIZE >>> 1;
+    let slab;
+    let offset = SIZE;
+    return function poolAlloc(size) {
+        if (size < 1 || size > MAX) {
+            return allocUnsafe(size);
+        }
+        if (offset + size > SIZE) {
+            slab = allocUnsafe(SIZE);
+            offset = 0;
+        }
+        const buf = slab.subarray(offset, offset += size);
+        if ((offset & 7) !== 0) {
+            // align to 32 bit
+            offset = (offset | 7) + 1;
+        }
+        return buf;
+    };
+}
 
+/**
+ * Constructs a new writer operation instance.
+ *
+ * @classdesc Scheduled writer operation
+ */
+class Op {
+    /**
+     * Function to call
+     */
+    fn;
+    /**
+     * Value byte length
+     */
+    len;
+    /**
+     * Next operation
+     */
+    next;
     /**
-     * Read buffer.
-     * @name BufferReader#buf
-     * @type {Buffer}
+     * Value to write
      */
+    val;
+    constructor(fn, len, val) {
+        this.fn = fn;
+        this.len = len;
+        this.next = undefined;
+        this.val = val; // type varies
+    }
 }
-
-BufferReader._configure = function () {
-    /* istanbul ignore else */
-    if (util$3.Buffer)
-        BufferReader.prototype._slice = util$3.Buffer.prototype.slice;
-};
-
-
+/* istanbul ignore next */
+function noop() { } // eslint-disable-line no-empty-function
 /**
- * @override
+ * Constructs a new writer state instance
  */
-BufferReader.prototype.string = function read_string_buffer() {
-    var len = this.uint32(); // modifies pos
-    return this.buf.utf8Slice
-        ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len))
-        : this.buf.toString("utf-8", this.pos, this.pos = Math.min(this.pos + len, this.len));
-};
-
+class State {
+    /**
+     * Current head
+     */
+    head;
+    /**
+     * Current tail
+     */
+    tail;
+    /**
+     * Current buffer length
+     */
+    len;
+    /**
+     * Next state
+     */
+    next;
+    constructor(writer) {
+        this.head = writer.head;
+        this.tail = writer.tail;
+        this.len = writer.len;
+        this.next = writer.states;
+    }
+}
+const bufferPool = pool();
 /**
- * Reads a sequence of bytes preceeded by its length as a varint.
- * @name BufferReader#bytes
- * @function
- * @returns {Buffer} Value read
+ * Allocates a buffer of the specified size
  */
-
-BufferReader._configure();
-
-var ReaderBufferClass = /*@__PURE__*/getDefaultExportFromCjs(reader_buffer);
-
-var minimalExports = requireMinimal();
-var util$2 = /*@__PURE__*/getDefaultExportFromCjs(minimalExports);
-
-var writer$1 = Writer$1;
-
-var util$1      = requireMinimal();
-
-var BufferWriter$1; // cyclic
-
-var LongBits  = util$1.LongBits,
-    base64    = util$1.base64,
-    utf8      = util$1.utf8;
-
+function alloc(size) {
+    if (globalThis.Buffer != null) {
+        return allocUnsafe(size);
+    }
+    return bufferPool(size);
+}
 /**
- * Constructs a new writer operation instance.
- * @classdesc Scheduled writer operation.
- * @constructor
- * @param {function(*, Uint8Array, number)} fn Function to call
- * @param {number} len Value byte length
- * @param {*} val Value to write
- * @ignore
+ * When a value is written, the writer calculates its byte length and puts it into a linked
+ * list of operations to perform when finish() is called. This both allows us to allocate
+ * buffers of the exact required size and reduces the amount of work we have to do compared
+ * to first calculating over objects and then encoding over objects. In our case, the encoding
+ * part is just a linked list walk calling operations with already prepared values.
  */
-function Op(fn, len, val) {
-
+class Uint8ArrayWriter {
+    /**
+     * Current length
+     */
+    len;
+    /**
+     * Operations head
+     */
+    head;
+    /**
+     * Operations tail
+     */
+    tail;
+    /**
+     * Linked forked states
+     */
+    states;
+    constructor() {
+        this.len = 0;
+        this.head = new Op(noop, 0, 0);
+        this.tail = this.head;
+        this.states = null;
+    }
+    /**
+     * Pushes a new operation to the queue
+     */
+    _push(fn, len, val) {
+        this.tail = this.tail.next = new Op(fn, len, val);
+        this.len += len;
+        return this;
+    }
+    /**
+     * Writes an unsigned 32 bit value as a varint
+     */
+    uint32(value) {
+        // here, the call to this.push has been inlined and a varint specific Op subclass is used.
+        // uint32 is by far the most frequently used operation and benefits significantly from this.
+        this.len += (this.tail = this.tail.next = new VarintOp((value = value >>> 0) <
+            128
+            ? 1
+            : value < 16384
+                ? 2
+                : value < 2097152
+                    ? 3
+                    : value < 268435456
+                        ? 4
+                        : 5, value)).len;
+        return this;
+    }
+    /**
+     * Writes a signed 32 bit value as a varint`
+     */
+    int32(value) {
+        return value < 0
+            ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) // 10 bytes per spec
+            : this.uint32(value);
+    }
+    /**
+     * Writes a 32 bit value as a varint, zig-zag encoded
+     */
+    sint32(value) {
+        return this.uint32((value << 1 ^ value >> 31) >>> 0);
+    }
+    /**
+     * Writes an unsigned 64 bit value as a varint
+     */
+    uint64(value) {
+        const bits = LongBits.fromBigInt(value);
+        return this._push(writeVarint64, bits.length(), bits);
+    }
+    /**
+     * Writes an unsigned 64 bit value as a varint
+     */
+    uint64Number(value) {
+        return this._push(encodeUint8Array, encodingLength(value), value);
+    }
+    /**
+     * Writes an unsigned 64 bit value as a varint
+     */
+    uint64String(value) {
+        return this.uint64(BigInt(value));
+    }
+    /**
+     * Writes a signed 64 bit value as a varint
+     */
+    int64(value) {
+        return this.uint64(value);
+    }
+    /**
+     * Writes a signed 64 bit value as a varint
+     */
+    int64Number(value) {
+        return this.uint64Number(value);
+    }
+    /**
+     * Writes a signed 64 bit value as a varint
+     */
+    int64String(value) {
+        return this.uint64String(value);
+    }
+    /**
+     * Writes a signed 64 bit value as a varint, zig-zag encoded
+     */
+    sint64(value) {
+        const bits = LongBits.fromBigInt(value).zzEncode();
+        return this._push(writeVarint64, bits.length(), bits);
+    }
+    /**
+     * Writes a signed 64 bit value as a varint, zig-zag encoded
+     */
+    sint64Number(value) {
+        const bits = LongBits.fromNumber(value).zzEncode();
+        return this._push(writeVarint64, bits.length(), bits);
+    }
+    /**
+     * Writes a signed 64 bit value as a varint, zig-zag encoded
+     */
+    sint64String(value) {
+        return this.sint64(BigInt(value));
+    }
+    /**
+     * Writes a boolish value as a varint
+     */
+    bool(value) {
+        return this._push(writeByte, 1, value ? 1 : 0);
+    }
+    /**
+     * Writes an unsigned 32 bit value as fixed 32 bits
+     */
+    fixed32(value) {
+        return this._push(writeFixed32, 4, value >>> 0);
+    }
+    /**
+     * Writes a signed 32 bit value as fixed 32 bits
+     */
+    sfixed32(value) {
+        return this.fixed32(value);
+    }
+    /**
+     * Writes an unsigned 64 bit value as fixed 64 bits
+     */
+    fixed64(value) {
+        const bits = LongBits.fromBigInt(value);
+        return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
+    }
+    /**
+     * Writes an unsigned 64 bit value as fixed 64 bits
+     */
+    fixed64Number(value) {
+        const bits = LongBits.fromNumber(value);
+        return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
+    }
     /**
-     * Function to call.
-     * @type {function(Uint8Array, number, *)}
+     * Writes an unsigned 64 bit value as fixed 64 bits
      */
-    this.fn = fn;
-
+    fixed64String(value) {
+        return this.fixed64(BigInt(value));
+    }
     /**
-     * Value byte length.
-     * @type {number}
+     * Writes a signed 64 bit value as fixed 64 bits
      */
-    this.len = len;
-
+    sfixed64(value) {
+        return this.fixed64(value);
+    }
     /**
-     * Next operation.
-     * @type {Writer.Op|undefined}
+     * Writes a signed 64 bit value as fixed 64 bits
      */
-    this.next = undefined;
-
+    sfixed64Number(value) {
+        return this.fixed64Number(value);
+    }
     /**
-     * Value to write.
-     * @type {*}
+     * Writes a signed 64 bit value as fixed 64 bits
      */
-    this.val = val; // type varies
-}
-
-/* istanbul ignore next */
-function noop() {} // eslint-disable-line no-empty-function
-
-/**
- * Constructs a new writer state instance.
- * @classdesc Copied writer state.
- * @memberof Writer
- * @constructor
- * @param {Writer} writer Writer to copy state from
- * @ignore
- */
-function State(writer) {
-
+    sfixed64String(value) {
+        return this.fixed64String(value);
+    }
     /**
-     * Current head.
-     * @type {Writer.Op}
+     * Writes a float (32 bit)
      */
-    this.head = writer.head;
-
+    float(value) {
+        return this._push(writeFloatLE, 4, value);
+    }
     /**
-     * Current tail.
-     * @type {Writer.Op}
+     * Writes a double (64 bit float).
+     *
+     * @function
+     * @param {number} value - Value to write
+     * @returns {Writer} `this`
      */
-    this.tail = writer.tail;
-
+    double(value) {
+        return this._push(writeDoubleLE, 8, value);
+    }
     /**
-     * Current buffer length.
-     * @type {number}
+     * Writes a sequence of bytes
      */
-    this.len = writer.len;
-
+    bytes(value) {
+        const len = value.length >>> 0;
+        if (len === 0) {
+            return this._push(writeByte, 1, 0);
+        }
+        return this.uint32(len)._push(writeBytes, len, value);
+    }
     /**
-     * Next state.
-     * @type {State|null}
+     * Writes a string
      */
-    this.next = writer.states;
-}
-
-/**
- * Constructs a new writer instance.
- * @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.
- * @constructor
- */
-function Writer$1() {
-
+    string(value) {
+        const len = length(value);
+        return len !== 0
+            ? this.uint32(len)._push(write, len, value)
+            : this._push(writeByte, 1, 0);
+    }
     /**
-     * Current length.
-     * @type {number}
+     * Forks this writer's state by pushing it to a stack.
+     * Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.
      */
-    this.len = 0;
-
+    fork() {
+        this.states = new State(this);
+        this.head = this.tail = new Op(noop, 0, 0);
+        this.len = 0;
+        return this;
+    }
     /**
-     * Operations head.
-     * @type {Object}
+     * Resets this instance to the last state
      */
-    this.head = new Op(noop, 0, 0);
-
+    reset() {
+        if (this.states != null) {
+            this.head = this.states.head;
+            this.tail = this.states.tail;
+            this.len = this.states.len;
+            this.states = this.states.next;
+        }
+        else {
+            this.head = this.tail = new Op(noop, 0, 0);
+            this.len = 0;
+        }
+        return this;
+    }
     /**
-     * Operations tail
-     * @type {Object}
+     * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
      */
-    this.tail = this.head;
-
+    ldelim() {
+        const head = this.head;
+        const tail = this.tail;
+        const len = this.len;
+        this.reset().uint32(len);
+        if (len !== 0) {
+            this.tail.next = head.next; // skip noop
+            this.tail = tail;
+            this.len += len;
+        }
+        return this;
+    }
     /**
-     * Linked forked states.
-     * @type {Object|null}
+     * Finishes the write operation
      */
-    this.states = null;
-
-    // When a value is written, the writer calculates its byte length and puts it into a linked
-    // list of operations to perform when finish() is called. This both allows us to allocate
-    // buffers of the exact required size and reduces the amount of work we have to do compared
-    // to first calculating over objects and then encoding over objects. In our case, the encoding
-    // part is just a linked list walk calling operations with already prepared values.
-}
-
-var create = function create() {
-    return util$1.Buffer
-        ? function create_buffer_setup() {
-            return (Writer$1.create = function create_buffer() {
-                return new BufferWriter$1();
-            })();
+    finish() {
+        let head = this.head.next; // skip noop
+        const buf = alloc(this.len);
+        let pos = 0;
+        while (head != null) {
+            head.fn(head.val, buf, pos);
+            pos += head.len;
+            head = head.next;
         }
-        /* istanbul ignore next */
-        : function create_array() {
-            return new Writer$1();
-        };
-};
-
-/**
- * Creates a new writer.
- * @function
- * @returns {BufferWriter|Writer} A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}
- */
-Writer$1.create = create();
-
-/**
- * Allocates a buffer of the specified size.
- * @param {number} size Buffer size
- * @returns {Uint8Array} Buffer
- */
-Writer$1.alloc = function alloc(size) {
-    return new util$1.Array(size);
-};
-
-// Use Uint8Array buffer pool in the browser, just like node does with buffers
-/* istanbul ignore else */
-if (util$1.Array !== Array)
-    Writer$1.alloc = util$1.pool(Writer$1.alloc, util$1.Array.prototype.subarray);
-
-/**
- * Pushes a new operation to the queue.
- * @param {function(Uint8Array, number, *)} fn Function to call
- * @param {number} len Value byte length
- * @param {number} val Value to write
- * @returns {Writer} `this`
- * @private
- */
-Writer$1.prototype._push = function push(fn, len, val) {
-    this.tail = this.tail.next = new Op(fn, len, val);
-    this.len += len;
-    return this;
-};
-
+        // this.head = this.tail = null;
+        return buf;
+    }
+}
 function writeByte(val, buf, pos) {
     buf[pos] = val & 255;
 }
-
 function writeVarint32(val, buf, pos) {
     while (val > 127) {
         buf[pos++] = val & 127 | 128;
@@ -2147,67 +1294,20 @@ function writeVarint32(val, buf, pos) {
     }
     buf[pos] = val;
 }
-
 /**
  * Constructs a new varint writer operation instance.
- * @classdesc Scheduled varint writer operation.
- * @extends Op
- * @constructor
- * @param {number} len Value byte length
- * @param {number} val Value to write
- * @ignore
+ *
+ * @classdesc Scheduled varint writer operation
  */
-function VarintOp(len, val) {
-    this.len = len;
-    this.next = undefined;
-    this.val = val;
+class VarintOp extends Op {
+    next;
+    constructor(len, val) {
+        super(writeVarint32, len, val);
+        this.next = undefined;
+    }
 }
-
-VarintOp.prototype = Object.create(Op.prototype);
-VarintOp.prototype.fn = writeVarint32;
-
-/**
- * Writes an unsigned 32 bit value as a varint.
- * @param {number} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.uint32 = function write_uint32(value) {
-    // here, the call to this.push has been inlined and a varint specific Op subclass is used.
-    // uint32 is by far the most frequently used operation and benefits significantly from this.
-    this.len += (this.tail = this.tail.next = new VarintOp(
-        (value = value >>> 0)
-                < 128       ? 1
-        : value < 16384     ? 2
-        : value < 2097152   ? 3
-        : value < 268435456 ? 4
-        :                     5,
-    value)).len;
-    return this;
-};
-
-/**
- * Writes a signed 32 bit value as a varint.
- * @function
- * @param {number} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.int32 = function write_int32(value) {
-    return value < 0
-        ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) // 10 bytes per spec
-        : this.uint32(value);
-};
-
-/**
- * Writes a 32 bit value as a varint, zig-zag encoded.
- * @param {number} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.sint32 = function write_sint32(value) {
-    return this.uint32((value << 1 ^ value >> 31) >>> 0);
-};
-
 function writeVarint64(val, buf, pos) {
-    while (val.hi) {
+    while (val.hi !== 0) {
         buf[pos++] = val.lo & 127 | 128;
         val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
         val.hi >>>= 7;
@@ -2218,358 +1318,60 @@ function writeVarint64(val, buf, pos) {
     }
     buf[pos++] = val.lo;
 }
-
-/**
- * Writes an unsigned 64 bit value as a varint.
- * @param {Long|number|string} value Value to write
- * @returns {Writer} `this`
- * @throws {TypeError} If `value` is a string and no long library is present.
- */
-Writer$1.prototype.uint64 = function write_uint64(value) {
-    var bits = LongBits.from(value);
-    return this._push(writeVarint64, bits.length(), bits);
-};
-
-/**
- * Writes a signed 64 bit value as a varint.
- * @function
- * @param {Long|number|string} value Value to write
- * @returns {Writer} `this`
- * @throws {TypeError} If `value` is a string and no long library is present.
- */
-Writer$1.prototype.int64 = Writer$1.prototype.uint64;
-
-/**
- * Writes a signed 64 bit value as a varint, zig-zag encoded.
- * @param {Long|number|string} value Value to write
- * @returns {Writer} `this`
- * @throws {TypeError} If `value` is a string and no long library is present.
- */
-Writer$1.prototype.sint64 = function write_sint64(value) {
-    var bits = LongBits.from(value).zzEncode();
-    return this._push(writeVarint64, bits.length(), bits);
-};
-
-/**
- * Writes a boolish value as a varint.
- * @param {boolean} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.bool = function write_bool(value) {
-    return this._push(writeByte, 1, value ? 1 : 0);
-};
-
 function writeFixed32(val, buf, pos) {
-    buf[pos    ] =  val         & 255;
-    buf[pos + 1] =  val >>> 8   & 255;
-    buf[pos + 2] =  val >>> 16  & 255;
-    buf[pos + 3] =  val >>> 24;
+    buf[pos] = val & 255;
+    buf[pos + 1] = val >>> 8 & 255;
+    buf[pos + 2] = val >>> 16 & 255;
+    buf[pos + 3] = val >>> 24;
 }
-
-/**
- * Writes an unsigned 32 bit value as fixed 32 bits.
- * @param {number} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.fixed32 = function write_fixed32(value) {
-    return this._push(writeFixed32, 4, value >>> 0);
-};
-
-/**
- * Writes a signed 32 bit value as fixed 32 bits.
- * @function
- * @param {number} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.sfixed32 = Writer$1.prototype.fixed32;
-
-/**
- * Writes an unsigned 64 bit value as fixed 64 bits.
- * @param {Long|number|string} value Value to write
- * @returns {Writer} `this`
- * @throws {TypeError} If `value` is a string and no long library is present.
- */
-Writer$1.prototype.fixed64 = function write_fixed64(value) {
-    var bits = LongBits.from(value);
-    return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
-};
-
-/**
- * Writes a signed 64 bit value as fixed 64 bits.
- * @function
- * @param {Long|number|string} value Value to write
- * @returns {Writer} `this`
- * @throws {TypeError} If `value` is a string and no long library is present.
- */
-Writer$1.prototype.sfixed64 = Writer$1.prototype.fixed64;
-
-/**
- * Writes a float (32 bit).
- * @function
- * @param {number} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.float = function write_float(value) {
-    return this._push(util$1.float.writeFloatLE, 4, value);
-};
-
-/**
- * Writes a double (64 bit float).
- * @function
- * @param {number} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.double = function write_double(value) {
-    return this._push(util$1.float.writeDoubleLE, 8, value);
-};
-
-var writeBytes = util$1.Array.prototype.set
-    ? function writeBytes_set(val, buf, pos) {
-        buf.set(val, pos); // also works for plain array values
-    }
-    /* istanbul ignore next */
-    : function writeBytes_for(val, buf, pos) {
-        for (var i = 0; i < val.length; ++i)
-            buf[pos + i] = val[i];
-    };
-
-/**
- * Writes a sequence of bytes.
- * @param {Uint8Array|string} value Buffer or base64 encoded string to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.bytes = function write_bytes(value) {
-    var len = value.length >>> 0;
-    if (!len)
-        return this._push(writeByte, 1, 0);
-    if (util$1.isString(value)) {
-        var buf = Writer$1.alloc(len = base64.length(value));
-        base64.decode(value, buf, 0);
-        value = buf;
-    }
-    return this.uint32(len)._push(writeBytes, len, value);
-};
-
-/**
- * Writes a string.
- * @param {string} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.string = function write_string(value) {
-    var len = utf8.length(value);
-    return len
-        ? this.uint32(len)._push(utf8.write, len, value)
-        : this._push(writeByte, 1, 0);
-};
-
-/**
- * Forks this writer's state by pushing it to a stack.
- * Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.
- * @returns {Writer} `this`
- */
-Writer$1.prototype.fork = function fork() {
-    this.states = new State(this);
-    this.head = this.tail = new Op(noop, 0, 0);
-    this.len = 0;
-    return this;
-};
-
-/**
- * Resets this instance to the last state.
- * @returns {Writer} `this`
- */
-Writer$1.prototype.reset = function reset() {
-    if (this.states) {
-        this.head   = this.states.head;
-        this.tail   = this.states.tail;
-        this.len    = this.states.len;
-        this.states = this.states.next;
-    } else {
-        this.head = this.tail = new Op(noop, 0, 0);
-        this.len  = 0;
-    }
-    return this;
-};
-
-/**
- * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
- * @returns {Writer} `this`
- */
-Writer$1.prototype.ldelim = function ldelim() {
-    var head = this.head,
-        tail = this.tail,
-        len  = this.len;
-    this.reset().uint32(len);
-    if (len) {
-        this.tail.next = head.next; // skip noop
-        this.tail = tail;
-        this.len += len;
-    }
-    return this;
-};
-
-/**
- * Finishes the write operation.
- * @returns {Uint8Array} Finished buffer
- */
-Writer$1.prototype.finish = function finish() {
-    var head = this.head.next, // skip noop
-        buf  = this.constructor.alloc(this.len),
-        pos  = 0;
-    while (head) {
-        head.fn(head.val, buf, pos);
-        pos += head.len;
-        head = head.next;
-    }
-    // this.head = this.tail = null;
-    return buf;
-};
-
-Writer$1._configure = function(BufferWriter_) {
-    BufferWriter$1 = BufferWriter_;
-    Writer$1.create = create();
-    BufferWriter$1._configure();
-};
-
-var WriterClass = /*@__PURE__*/getDefaultExportFromCjs(writer$1);
-
-var writer_buffer = BufferWriter;
-
-// extends Writer
-var Writer = writer$1;
-(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
-
-var util = requireMinimal();
-
-/**
- * Constructs a new buffer writer instance.
- * @classdesc Wire format writer using node buffers.
- * @extends Writer
- * @constructor
- */
-function BufferWriter() {
-    Writer.call(this);
+function writeBytes(val, buf, pos) {
+    buf.set(val, pos);
 }
-
-BufferWriter._configure = function () {
-    /**
-     * Allocates a buffer of the specified size.
-     * @function
-     * @param {number} size Buffer size
-     * @returns {Buffer} Buffer
-     */
-    BufferWriter.alloc = util._Buffer_allocUnsafe;
-
-    BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === "set"
-        ? function writeBytesBuffer_set(val, buf, pos) {
-          buf.set(val, pos); // faster than copy (requires node >= 4 where Buffers extend Uint8Array and set is properly inherited)
-          // also works for plain array values
+if (globalThis.Buffer != null) {
+    Uint8ArrayWriter.prototype.bytes = function (value) {
+        const len = value.length >>> 0;
+        this.uint32(len);
+        if (len > 0) {
+            this._push(writeBytesBuffer, len, value);
         }
-        /* istanbul ignore next */
-        : function writeBytesBuffer_copy(val, buf, pos) {
-          if (val.copy) // Buffer values
-            val.copy(buf, pos, 0, val.length);
-          else for (var i = 0; i < val.length;) // plain array values
-            buf[pos++] = val[i++];
-        };
-};
-
-
-/**
- * @override
- */
-BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
-    if (util.isString(value))
-        value = util._Buffer_from(value, "base64");
-    var len = value.length >>> 0;
-    this.uint32(len);
-    if (len)
-        this._push(BufferWriter.writeBytesBuffer, len, value);
-    return this;
-};
-
-function writeStringBuffer(val, buf, pos) {
-    if (val.length < 40) // plain js is faster for short strings (probably due to redundant assertions)
-        util.utf8.write(val, buf, pos);
-    else if (buf.utf8Write)
-        buf.utf8Write(val, pos);
-    else
-        buf.write(val, pos);
-}
-
-/**
- * @override
- */
-BufferWriter.prototype.string = function write_string_buffer(value) {
-    var len = util.Buffer.byteLength(value);
-    this.uint32(len);
-    if (len)
-        this._push(writeStringBuffer, len, value);
-    return this;
-};
-
-
-/**
- * Finishes the write operation.
- * @name BufferWriter#finish
- * @function
- * @returns {Buffer} Finished buffer
- */
-
-BufferWriter._configure();
-
-var WriterBufferClass = /*@__PURE__*/getDefaultExportFromCjs(writer_buffer);
-
-// @ts-expect-error no types
-function configure() {
-    util$2._configure();
-    ReaderClass._configure(ReaderBufferClass);
-    WriterClass._configure(WriterBufferClass);
-}
-// Set up buffer utility according to the environment
-configure();
-// monkey patch the reader to add native bigint support
-const methods = [
-    'uint64', 'int64', 'sint64', 'fixed64', 'sfixed64'
-];
-function patchReader(obj) {
-    for (const method of methods) {
-        if (obj[method] == null) {
-            continue;
+        return this;
+    };
+    Uint8ArrayWriter.prototype.string = function (value) {
+        const len = globalThis.Buffer.byteLength(value);
+        this.uint32(len);
+        if (len > 0) {
+            this._push(writeStringBuffer, len, value);
         }
-        const original = obj[method];
-        obj[method] = function () {
-            return BigInt(original.call(this).toString());
-        };
-    }
-    return obj;
+        return this;
+    };
 }
-function reader(buf) {
-    return patchReader(new ReaderClass(buf));
+function writeBytesBuffer(val, buf, pos) {
+    buf.set(val, pos); // faster than copy (requires node >= 4 where Buffers extend Uint8Array and set is properly inherited)
+    // also works for plain array values
 }
-function patchWriter(obj) {
-    for (const method of methods) {
-        if (obj[method] == null) {
-            continue;
-        }
-        const original = obj[method];
-        obj[method] = function (val) {
-            return original.call(this, val.toString());
-        };
+function writeStringBuffer(val, buf, pos) {
+    if (val.length < 40) {
+        // plain js is faster for short strings (probably due to redundant assertions)
+        write(val, buf, pos);
+        // @ts-expect-error buf isn't a Uint8Array?
+    }
+    else if (buf.utf8Write != null) {
+        // @ts-expect-error buf isn't a Uint8Array?
+        buf.utf8Write(val, pos);
+    }
+    else {
+        buf.set(fromString(val), pos);
     }
-    return obj;
-}
-function writer() {
-    return patchWriter(WriterClass.create());
 }
-
-function decodeMessage(buf, codec) {
-    const r = reader(buf instanceof Uint8Array ? buf : buf.subarray());
-    return codec.decode(r);
+/**
+ * Creates a new writer
+ */
+function createWriter() {
+    return new Uint8ArrayWriter();
 }
 
 function encodeMessage(message, codec) {
-    const w = writer();
+    const w = createWriter();
     codec.encode(message, w, {
         lengthDelimited: false
     });
@@ -4741,10 +3543,117 @@ var PeerExchangeRPC;
     };
 })(PeerExchangeRPC || (PeerExchangeRPC = {}));
 
-/**
- * DefaultPubsubTopic is the default gossipsub topic to use for Waku.
- */
-const DefaultPubsubTopic = "/waku/2/default-waku/proto";
+/* 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 WakuMetadataRequest;
+(function (WakuMetadataRequest) {
+    let _codec;
+    WakuMetadataRequest.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.clusterId != null) {
+                    w.uint32(8);
+                    w.uint32(obj.clusterId);
+                }
+                if (obj.shards != null) {
+                    for (const value of obj.shards) {
+                        w.uint32(16);
+                        w.uint32(value);
+                    }
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    shards: []
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.clusterId = reader.uint32();
+                            break;
+                        case 2:
+                            obj.shards.push(reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMetadataRequest.encode = (obj) => {
+        return encodeMessage(obj, WakuMetadataRequest.codec());
+    };
+    WakuMetadataRequest.decode = (buf) => {
+        return decodeMessage(buf, WakuMetadataRequest.codec());
+    };
+})(WakuMetadataRequest || (WakuMetadataRequest = {}));
+var WakuMetadataResponse;
+(function (WakuMetadataResponse) {
+    let _codec;
+    WakuMetadataResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.clusterId != null) {
+                    w.uint32(8);
+                    w.uint32(obj.clusterId);
+                }
+                if (obj.shards != null) {
+                    for (const value of obj.shards) {
+                        w.uint32(16);
+                        w.uint32(value);
+                    }
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    shards: []
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.clusterId = reader.uint32();
+                            break;
+                        case 2:
+                            obj.shards.push(reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMetadataResponse.encode = (obj) => {
+        return encodeMessage(obj, WakuMetadataResponse.codec());
+    };
+    WakuMetadataResponse.decode = (buf) => {
+        return decodeMessage(buf, WakuMetadataResponse.codec());
+    };
+})(WakuMetadataResponse || (WakuMetadataResponse = {}));
 
 const log = new Logger("message:version-0");
 const OneMillion = BigInt(1000000);
@@ -4838,8 +3747,8 @@ class Encoder {
  * pass to { @link @waku/interfaces!ISender.send } to automatically encode outgoing
  * messages.
  */
-function createEncoder({ pubsubTopic = DefaultPubsubTopic, contentTopic, ephemeral, metaSetter }) {
-    return new Encoder(contentTopic, ephemeral, pubsubTopic, metaSetter);
+function createEncoder({ pubsubTopic, pubsubTopicShardInfo, contentTopic, ephemeral, metaSetter }) {
+    return new Encoder(contentTopic, ephemeral, determinePubsubTopic(contentTopic, pubsubTopic ?? pubsubTopicShardInfo), metaSetter);
 }
 class Decoder {
     pubsubTopic;
@@ -4883,8 +3792,8 @@ class Decoder {
  *
  * @param contentTopic The resulting decoder will only decode messages with this content topic.
  */
-function createDecoder(contentTopic, pubsubTopic = DefaultPubsubTopic) {
-    return new Decoder(pubsubTopic, contentTopic);
+function createDecoder(contentTopic, pubsubTopicShardInfo) {
+    return new Decoder(determinePubsubTopic(contentTopic, pubsubTopicShardInfo), contentTopic);
 }
 
 var version_0 = /*#__PURE__*/Object.freeze({
@@ -4898,4 +3807,4 @@ var version_0 = /*#__PURE__*/Object.freeze({
     proto: message
 });
 
-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 };
+export { DecodedMessage as D, Encoder as E, FilterSubscribeRequest as F, HistoryRpc$1 as H, MessagePush as M, PushRpc$1 as P, Version as V, WakuMetadataResponse as W, encode as a, FilterSubscribeResponse$1 as b, PushResponse as c, decode as d, encodingLength as e, PagingInfo as f, HistoryResponse as g, createEncoder as h, WakuMetadataRequest as i, createDecoder as j, Decoder as k, message as m, version_0 as v };