@waku/message-encryption 0.0.24 → 0.0.25

package/bundle/{encryption-zFGfcjHZ.js → encryption-Cjy0BsYx.js}

@@ -1,2144 +1,1190 @@
-import { h as commonjsGlobal, i as getDefaultExportFromCjs, j as concat, u as utf8ToBytes$1, l as encrypt, m as hexToBytes, n as decrypt, o as generateIv, p as encrypt$1, S as Symmetric, q as decrypt$1, r as randomBytes, k as keccak256, d as sign, t as Signature, v as recoverPublicKey } from './symmetric-CXVjdTdV.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 { h as allocUnsafe, i as fromString, j as concat, u as utf8ToBytes$1, l as getDefaultExportFromCjs, m as encrypt, n as hexToBytes, o as decrypt, p as generateIv, q as encrypt$1, S as Symmetric, t as decrypt$1, r as randomBytes, k as keccak256, d as sign, v as Signature, w as recoverPublicKey } from './symmetric-Cd3XbaRu.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 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 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;
+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 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;
+/**
+ * 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 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;
+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];
 }
-
-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;
+/**
+ * Reads a 64 bit double from a buffer using little endian byte order
+ */
+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];
 }
 
-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;
+// 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;
+    }
+    /**
+     * Converts this long bits to a possibly unsafe JavaScript number
+     */
+    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;
+    }
+    /**
+     * Converts this long bits to a bigint
+     */
+    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);
+    }
+    /**
+     * Converts this long bits to a string
+     */
+    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;
+        }
+        if (value < MAX_SAFE_NUMBER_INTEGER && value > MIN_SAFE_NUMBER_INTEGER) {
+            return this.fromNumber(Number(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;
 
-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;
+/**
+ * Calculates the UTF8 byte length of a string
+ */
+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 UTF8 bytes as a string
+ */
+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;
+        }
+        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 != 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));
+}
+/**
+ * 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;
 }
-
-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);
+    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;
 }
-
 /**
  * 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
  */
-function Reader$1(buffer) {
-
+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;
+    }
     /**
-     * Read buffer.
-     * @type {Uint8Array}
+     * Reads a varint as an unsigned 32 bit value
      */
-    this.buf = buffer;
-
+    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;
+    }
     /**
-     * Read buffer position.
-     * @type {number}
+     * Reads a varint as a signed 32 bit value
      */
-    this.pos = 0;
-
+    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 (end > this.len) {
+            throw indexOutOfRange(this, length);
+        }
+        this.pos += length;
+        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 + 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;
+    }
     /**
-     * Read buffer length.
-     * @type {number}
+     * Skips the next element of the specified wire type
      */
-    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);
-        }
-        /* 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);
+    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 value;
-    };
-})();
-
-/**
- * Reads a varint as a signed 32 bit value.
- * @returns {number} Value read
- */
-Reader$1.prototype.int32 = function read_int32() {
-    return this.uint32() | 0;
-};
-
-/**
- * Reads a zig-zag encoded varint as a signed 32 bit value.
- * @returns {number} Value read
- */
-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 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;
+                }
+            }
+            // 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;
         }
-        // 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)
+        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;
-        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;
+        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) {
-            /* 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 {
+            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');
+    }
+    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();
     }
-    /* istanbul ignore next */
-    throw Error("invalid varint encoding");
 }
-
-/* eslint-enable no-invalid-this */
-
-/**
- * Reads a varint as a signed 64 bit value.
- * @name Reader#int64
- * @function
- * @returns {Long} Value read
- */
-
-/**
- * Reads a varint as an unsigned 64 bit value.
- * @name Reader#uint64
- * @function
- * @returns {Long} Value read
- */
-
-/**
- * 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;
+function createReader(buf) {
+    return new Uint8ArrayReader(buf instanceof Uint8Array ? buf : buf.subarray());
 }
 
-/**
- * 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));
+function decodeMessage(buf, codec, opts) {
+    const reader = createReader(buf);
+    return codec.decode(reader, undefined, opts);
 }
 
-/* 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
+ * A general purpose buffer pool
  */
-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;
-};
+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;
+    };
+}
 
 /**
- * Reads a sequence of bytes preceeded by its length as a varint.
- * @returns {Uint8Array} Value read
+ * Constructs a new writer operation instance.
+ *
+ * @classdesc Scheduled writer operation
  */
-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);
+class Op {
+    /**
+     * Function to call
+     */
+    fn;
+    /**
+     * Value byte length
+     */
+    len;
+    /**
+     * Next operation
+     */
+    next;
+    /**
+     * Value to write
+     */
+    val;
+    constructor(fn, len, val) {
+        this.fn = fn;
+        this.len = len;
+        this.next = undefined;
+        this.val = val; // type varies
     }
-    return this._slice.call(this.buf, start, end);
-};
-
+}
+/* istanbul ignore next */
+function noop() { } // eslint-disable-line no-empty-function
 /**
- * Reads a string preceeded by its byte length as a varint.
- * @returns {string} Value read
+ * Constructs a new writer state instance
  */
-Reader$1.prototype.string = function read_string() {
-    var bytes = this.bytes();
-    return utf8$1.read(bytes, 0, bytes.length);
-};
-
+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();
 /**
- * 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`
+ * Allocates a buffer of the specified size
  */
-Reader$1.prototype.skip = function skip(length) {
-    if (typeof length === "number") {
-        /* istanbul ignore if */
-        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);
+function alloc(size) {
+    if (globalThis.Buffer != null) {
+        return allocUnsafe(size);
     }
-    return this;
-};
-
+    return bufferPool(size);
+}
 /**
- * Skips the next element of the specified wire type.
- * @param {number} wireType Wire type received
- * @returns {Reader} `this`
+ * 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.
  */
-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);
-            }
-            break;
-        case 5:
-            this.skip(4);
-            break;
-
-        /* istanbul ignore next */
-        default:
-            throw Error("invalid wire type " + wireType + " at offset " + this.pos);
+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);
     }
-    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);
-        }
-
-    });
-};
-
-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();
-
-/**
- * Constructs a new buffer reader instance.
- * @classdesc Wire format reader using node buffers.
- * @extends Reader
- * @constructor
- * @param {Buffer} buffer Buffer to read from
- */
-function BufferReader(buffer) {
-    Reader.call(this, buffer);
-
     /**
-     * Read buffer.
-     * @name BufferReader#buf
-     * @type {Buffer}
+     * Writes an unsigned 64 bit value as fixed 64 bits
      */
-}
-
-BufferReader._configure = function () {
-    /* istanbul ignore else */
-    if (util$3.Buffer)
-        BufferReader.prototype._slice = util$3.Buffer.prototype.slice;
-};
-
-
-/**
- * @override
- */
-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));
-};
-
-/**
- * Reads a sequence of bytes preceeded by its length as a varint.
- * @name BufferReader#bytes
- * @function
- * @returns {Buffer} Value read
- */
-
-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;
-
-/**
- * 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
- */
-function Op(fn, len, val) {
-
+    fixed64(value) {
+        const bits = LongBits.fromBigInt(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;
-
+    fixed64Number(value) {
+        const bits = LongBits.fromNumber(value);
+        return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
+    }
     /**
-     * Value byte length.
-     * @type {number}
+     * Writes an unsigned 64 bit value as fixed 64 bits
      */
-    this.len = len;
-
+    fixed64String(value) {
+        return this.fixed64(BigInt(value));
+    }
     /**
-     * Next operation.
-     * @type {Writer.Op|undefined}
+     * Writes a signed 64 bit value as fixed 64 bits
      */
-    this.next = undefined;
-
+    sfixed64(value) {
+        return this.fixed64(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) {
-
+    sfixed64Number(value) {
+        return this.fixed64Number(value);
+    }
     /**
-     * Current head.
-     * @type {Writer.Op}
+     * Writes a signed 64 bit value as fixed 64 bits
      */
-    this.head = writer.head;
-
+    sfixed64String(value) {
+        return this.fixed64String(value);
+    }
     /**
-     * Current tail.
-     * @type {Writer.Op}
+     * Writes a float (32 bit)
      */
-    this.tail = writer.tail;
-
+    float(value) {
+        return this._push(writeFloatLE, 4, value);
+    }
+    /**
+     * Writes a double (64 bit float).
+     *
+     * @function
+     * @param {number} value - Value to write
+     * @returns {Writer} `this`
+     */
+    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;
@@ -2146,67 +1192,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;
@@ -2217,358 +1216,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
     });
@@ -4846,8 +3547,13 @@ var WakuMetadataResponse;
     };
 })(WakuMetadataResponse || (WakuMetadataResponse = {}));
 
+// copied from utils
+function isBytes$1(a) {
+    return (a instanceof Uint8Array ||
+        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
+}
 function bytes(b, ...lengths) {
-    if (!(b instanceof Uint8Array))
+    if (!isBytes$1(b))
         throw new Error('Expected Uint8Array');
     if (lengths.length > 0 && !lengths.includes(b.length))
         throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
@@ -4872,14 +3578,19 @@ function output(out, instance) {
 // For node.js, package.json#exports field mapping rewrites import
 // from `crypto` to `cryptoNode`, which imports native module.
 // Makes the utils un-importable in browsers without a bundler.
-// Once node.js 18 is deprecated, we can just drop the import.
-const u8a = (a) => a instanceof Uint8Array;
+// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
+function isBytes(a) {
+    return (a instanceof Uint8Array ||
+        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
+}
 // Cast array to view
 const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 // The rotate right (circular right shift) operation for uint32
 const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
 // big-endian hardware is rare. Just in case someone still decides to run hashes:
 // early-throw an error because we don't support BE yet.
+// Other libraries would silently corrupt the data instead of throwing an error,
+// when they don't support it.
 const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
 if (!isLE)
     throw new Error('Non little-endian hardware is not supported');
@@ -4899,7 +3610,7 @@ function utf8ToBytes(str) {
 function toBytes(data) {
     if (typeof data === 'string')
         data = utf8ToBytes(data);
-    if (!u8a(data))
+    if (!isBytes(data))
         throw new Error(`expected Uint8Array, got ${typeof data}`);
     return data;
 }
@@ -5205,6 +3916,7 @@ var Tags;
 (function (Tags) {
     Tags["BOOTSTRAP"] = "bootstrap";
     Tags["PEER_EXCHANGE"] = "peer-exchange";
+    Tags["LOCAL"] = "local-peer-cache";
 })(Tags || (Tags = {}));
 var EPeersByDiscoveryEvents;
 (function (EPeersByDiscoveryEvents) {
@@ -5222,6 +3934,10 @@ var EConnectionStateEvents;
  * DefaultPubsubTopic is the default gossipsub topic to use for Waku.
  */
 const DefaultPubsubTopic = "/waku/2/default-waku/proto";
+/**
+ * The default cluster ID for The Waku Network
+ */
+const DEFAULT_CLUSTER_ID = 1;
 
 const singleShardInfoToPubsubTopic = (shardInfo) => {
     if (shardInfo.clusterId === undefined || shardInfo.shard === undefined)
@@ -5285,7 +4001,7 @@ function contentTopicToShardIndex(contentTopic, networkShards = 8) {
     const dataview = new DataView(digest.buffer.slice(-8));
     return Number(dataview.getBigUint64(0, false) % BigInt(networkShards));
 }
-function contentTopicToPubsubTopic(contentTopic, clusterId = 1, networkShards = 8) {
+function contentTopicToPubsubTopic(contentTopic, clusterId = DEFAULT_CLUSTER_ID, networkShards = 8) {
     const shardIndex = contentTopicToShardIndex(contentTopic, networkShards);
     return `/waku/2/rs/${clusterId}/${shardIndex}`;
 }