@waku/core 0.0.9 → 0.0.11

package/bundle/peer_exchange-1229c8b0.js

@@ -0,0 +1,4302 @@
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+				var args = [null];
+				args.push.apply(args, arguments);
+				var Ctor = Function.bind.apply(f, args);
+				return new Ctor();
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+var minimal = {};
+
+var 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);
+            }
+        }
+    });
+}
+
+var base64$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));
+
+var eventemitter = EventEmitter;
+
+/**
+ * Constructs a new event emitter instance.
+ * @classdesc A minimal event emitter.
+ * @memberof util
+ * @constructor
+ */
+function EventEmitter() {
+
+    /**
+     * Registered listeners.
+     * @type {Object.<string,*>}
+     * @private
+     */
+    this._listeners = {};
+}
+
+/**
+ * Registers an event listener.
+ * @param {string} evt Event name
+ * @param {function} fn Listener
+ * @param {*} [ctx] Listener context
+ * @returns {util.EventEmitter} `this`
+ */
+EventEmitter.prototype.on = function on(evt, fn, ctx) {
+    (this._listeners[evt] || (this._listeners[evt] = [])).push({
+        fn  : fn,
+        ctx : ctx || this
+    });
+    return this;
+};
+
+/**
+ * Removes an event listener or any matching listeners if arguments are omitted.
+ * @param {string} [evt] Event name. Removes all listeners if omitted.
+ * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
+ * @returns {util.EventEmitter} `this`
+ */
+EventEmitter.prototype.off = function off(evt, fn) {
+    if (evt === undefined)
+        this._listeners = {};
+    else {
+        if (fn === undefined)
+            this._listeners[evt] = [];
+        else {
+            var listeners = this._listeners[evt];
+            for (var i = 0; i < listeners.length;)
+                if (listeners[i].fn === fn)
+                    listeners.splice(i, 1);
+                else
+                    ++i;
+        }
+    }
+    return this;
+};
+
+/**
+ * Emits an event by calling its listeners with the specified arguments.
+ * @param {string} evt Event name
+ * @param {...*} args Arguments
+ * @returns {util.EventEmitter} `this`
+ */
+EventEmitter.prototype.emit = function emit(evt) {
+    var listeners = this._listeners[evt];
+    if (listeners) {
+        var args = [],
+            i = 1;
+        for (; i < arguments.length;)
+            args.push(arguments[i++]);
+        for (i = 0; i < listeners.length;)
+            listeners[i].fn.apply(listeners[i++].ctx, args);
+    }
+    return this;
+};
+
+var float = 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;
+}
+
+var 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;
+}
+
+var utf8$2 = {};
+
+(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));
+
+var pool_1 = pool;
+
+/**
+ * An allocator as used by {@link util.pool}.
+ * @typedef PoolAllocator
+ * @type {function}
+ * @param {number} size Buffer size
+ * @returns {Uint8Array} Buffer
+ */
+
+/**
+ * A slicer as used by {@link util.pool}.
+ * @typedef PoolSlicer
+ * @type {function}
+ * @param {number} start Start offset
+ * @param {number} end End offset
+ * @returns {Uint8Array} Buffer slice
+ * @this {Uint8Array}
+ */
+
+/**
+ * A general purpose buffer pool.
+ * @memberof util
+ * @function
+ * @param {PoolAllocator} alloc Allocator
+ * @param {PoolSlicer} slice Slicer
+ * @param {number} [size=8192] Slab size
+ * @returns {PoolAllocator} Pooled allocator
+ */
+function pool(alloc, slice, size) {
+    var SIZE   = size || 8192;
+    var MAX    = SIZE >>> 1;
+    var slab   = null;
+    var offset = SIZE;
+    return function pool_alloc(size) {
+        if (size < 1 || size > MAX)
+            return alloc(size);
+        if (offset + size > SIZE) {
+            slab = alloc(SIZE);
+            offset = 0;
+        }
+        var buf = slice.call(slab, offset, offset += size);
+        if (offset & 7) // align to 32 bit
+            offset = (offset | 7) + 1;
+        return buf;
+    };
+}
+
+var 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;
+}
+
+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 = aspromise;
+
+		// converts to / from base64 encoded strings
+		util.base64 = base64$1;
+
+		// base class of rpc.Service
+		util.EventEmitter = eventemitter;
+
+		// float handling accross browsers
+		util.float = float;
+
+		// requires modules optionally and hides the call from bundlers
+		util.inquire = inquire_1;
+
+		// converts to / from utf8 encoded strings
+		util.utf8 = utf8$2;
+
+		// provides a node-like buffer pool in the browser
+		util.pool = pool_1;
+
+		// 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;
+}
+
+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);
+}
+
+/**
+ * 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) {
+
+    /**
+     * Read buffer.
+     * @type {Uint8Array}
+     */
+    this.buf = buffer;
+
+    /**
+     * Read buffer position.
+     * @type {number}
+     */
+    this.pos = 0;
+
+    /**
+     * Read buffer length.
+     * @type {number}
+     */
+    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);
+        }
+        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 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;
+    } else {
+        for (; i < 3; ++i) {
+            /* istanbul ignore if */
+            if (this.pos >= this.len)
+                throw indexOutOfRange(this);
+            // 1st..3th
+            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+            if (this.buf[this.pos++] < 128)
+                return bits;
+        }
+        // 4th
+        bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
+        return bits;
+    }
+    if (this.len - this.pos > 4) { // fast route (hi)
+        for (; i < 5; ++i) {
+            // 6th..10th
+            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+            if (this.buf[this.pos++] < 128)
+                return bits;
+        }
+    } else {
+        for (; i < 5; ++i) {
+            /* 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;
+        }
+    }
+    /* 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;
+}
+
+/**
+ * Reads fixed 32 bits as an unsigned 32 bit integer.
+ * @returns {number} Value read
+ */
+Reader$1.prototype.fixed32 = function read_fixed32() {
+
+    /* istanbul ignore if */
+    if (this.pos + 4 > this.len)
+        throw indexOutOfRange(this, 4);
+
+    return readFixed32_end(this.buf, this.pos += 4);
+};
+
+/**
+ * Reads fixed 32 bits as a signed 32 bit integer.
+ * @returns {number} Value read
+ */
+Reader$1.prototype.sfixed32 = function read_sfixed32() {
+
+    /* istanbul ignore if */
+    if (this.pos + 4 > this.len)
+        throw indexOutOfRange(this, 4);
+
+    return readFixed32_end(this.buf, this.pos += 4) | 0;
+};
+
+/* eslint-disable no-invalid-this */
+
+function readFixed64(/* this: Reader */) {
+
+    /* istanbul ignore if */
+    if (this.pos + 8 > this.len)
+        throw indexOutOfRange(this, 8);
+
+    return new LongBits$1(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));
+}
+
+/* eslint-enable no-invalid-this */
+
+/**
+ * Reads fixed 64 bits.
+ * @name Reader#fixed64
+ * @function
+ * @returns {Long} Value read
+ */
+
+/**
+ * Reads zig-zag encoded fixed 64 bits.
+ * @name Reader#sfixed64
+ * @function
+ * @returns {Long} Value read
+ */
+
+/**
+ * Reads a float (32 bit) as a number.
+ * @function
+ * @returns {number} Value read
+ */
+Reader$1.prototype.float = function read_float() {
+
+    /* istanbul ignore if */
+    if (this.pos + 4 > this.len)
+        throw indexOutOfRange(this, 4);
+
+    var value = util$4.float.readFloatLE(this.buf, this.pos);
+    this.pos += 4;
+    return value;
+};
+
+/**
+ * Reads a double (64 bit float) as a number.
+ * @function
+ * @returns {number} Value read
+ */
+Reader$1.prototype.double = function read_double() {
+
+    /* istanbul ignore if */
+    if (this.pos + 8 > this.len)
+        throw indexOutOfRange(this, 4);
+
+    var value = util$4.float.readDoubleLE(this.buf, this.pos);
+    this.pos += 8;
+    return value;
+};
+
+/**
+ * Reads a sequence of bytes preceeded by its length as a varint.
+ * @returns {Uint8Array} Value read
+ */
+Reader$1.prototype.bytes = function read_bytes() {
+    var length = this.uint32(),
+        start  = this.pos,
+        end    = this.pos + length;
+
+    /* istanbul ignore if */
+    if (end > this.len)
+        throw indexOutOfRange(this, length);
+
+    this.pos += length;
+    if (Array.isArray(this.buf)) // plain array
+        return this.buf.slice(start, end);
+    return start === end // fix for IE 10/Win8 and others' subarray returning array of size 1
+        ? new this.buf.constructor(0)
+        : this._slice.call(this.buf, start, end);
+};
+
+/**
+ * Reads a string preceeded by its byte length as a varint.
+ * @returns {string} Value read
+ */
+Reader$1.prototype.string = function read_string() {
+    var bytes = this.bytes();
+    return utf8$1.read(bytes, 0, bytes.length);
+};
+
+/**
+ * Skips the specified number of bytes if specified, otherwise skips a varint.
+ * @param {number} [length] Length if known, otherwise a varint is assumed
+ * @returns {Reader} `this`
+ */
+Reader$1.prototype.skip = function skip(length) {
+    if (typeof length === "number") {
+        /* 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);
+    }
+    return this;
+};
+
+/**
+ * Skips the next element of the specified wire type.
+ * @param {number} wireType Wire type received
+ * @returns {Reader} `this`
+ */
+Reader$1.prototype.skipType = function(wireType) {
+    switch (wireType) {
+        case 0:
+            this.skip();
+            break;
+        case 1:
+            this.skip(8);
+            break;
+        case 2:
+            this.skip(this.uint32());
+            break;
+        case 3:
+            while ((wireType = this.uint32() & 7) !== 4) {
+                this.skipType(wireType);
+            }
+            break;
+        case 5:
+            this.skip(4);
+            break;
+
+        /* istanbul ignore next */
+        default:
+            throw Error("invalid wire type " + wireType + " at offset " + this.pos);
+    }
+    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 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}
+     */
+}
+
+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 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) {
+
+    /**
+     * Function to call.
+     * @type {function(Uint8Array, number, *)}
+     */
+    this.fn = fn;
+
+    /**
+     * Value byte length.
+     * @type {number}
+     */
+    this.len = len;
+
+    /**
+     * Next operation.
+     * @type {Writer.Op|undefined}
+     */
+    this.next = undefined;
+
+    /**
+     * Value to write.
+     * @type {*}
+     */
+    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) {
+
+    /**
+     * Current head.
+     * @type {Writer.Op}
+     */
+    this.head = writer.head;
+
+    /**
+     * Current tail.
+     * @type {Writer.Op}
+     */
+    this.tail = writer.tail;
+
+    /**
+     * Current buffer length.
+     * @type {number}
+     */
+    this.len = writer.len;
+
+    /**
+     * Next state.
+     * @type {State|null}
+     */
+    this.next = writer.states;
+}
+
+/**
+ * Constructs a new writer instance.
+ * @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.
+ * @constructor
+ */
+function Writer$1() {
+
+    /**
+     * Current length.
+     * @type {number}
+     */
+    this.len = 0;
+
+    /**
+     * Operations head.
+     * @type {Object}
+     */
+    this.head = new Op(noop, 0, 0);
+
+    /**
+     * Operations tail
+     * @type {Object}
+     */
+    this.tail = this.head;
+
+    /**
+     * Linked forked states.
+     * @type {Object|null}
+     */
+    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();
+            })();
+        }
+        /* 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;
+};
+
+function writeByte(val, buf, pos) {
+    buf[pos] = val & 255;
+}
+
+function writeVarint32(val, buf, pos) {
+    while (val > 127) {
+        buf[pos++] = val & 127 | 128;
+        val >>>= 7;
+    }
+    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
+ */
+function VarintOp(len, val) {
+    this.len = len;
+    this.next = undefined;
+    this.val = val;
+}
+
+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) {
+        buf[pos++] = val.lo & 127 | 128;
+        val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
+        val.hi >>>= 7;
+    }
+    while (val.lo > 127) {
+        buf[pos++] = val.lo & 127 | 128;
+        val.lo = val.lo >>> 7;
+    }
+    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;
+}
+
+/**
+ * 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 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);
+}
+
+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
+        }
+        /* 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();
+
+// @ts-expect-error no types
+function configure() {
+    util$2._configure();
+    reader$1._configure(reader_buffer);
+    writer$1._configure(writer_buffer);
+}
+// 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;
+        }
+        const original = obj[method];
+        obj[method] = function () {
+            return BigInt(original.call(this).toString());
+        };
+    }
+    return obj;
+}
+function reader(buf) {
+    return patchReader(new reader$1(buf));
+}
+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());
+        };
+    }
+    return obj;
+}
+function writer() {
+    return patchWriter(writer$1.create());
+}
+
+function decodeMessage(buf, codec) {
+    const r = reader(buf instanceof Uint8Array ? buf : buf.subarray());
+    return codec.decode(r);
+}
+
+function encodeMessage(message, codec) {
+    const w = writer();
+    codec.encode(message, w, {
+        lengthDelimited: false
+    });
+    return w.finish();
+}
+
+// https://developers.google.com/protocol-buffers/docs/encoding#structure
+var CODEC_TYPES;
+(function (CODEC_TYPES) {
+    CODEC_TYPES[CODEC_TYPES["VARINT"] = 0] = "VARINT";
+    CODEC_TYPES[CODEC_TYPES["BIT64"] = 1] = "BIT64";
+    CODEC_TYPES[CODEC_TYPES["LENGTH_DELIMITED"] = 2] = "LENGTH_DELIMITED";
+    CODEC_TYPES[CODEC_TYPES["START_GROUP"] = 3] = "START_GROUP";
+    CODEC_TYPES[CODEC_TYPES["END_GROUP"] = 4] = "END_GROUP";
+    CODEC_TYPES[CODEC_TYPES["BIT32"] = 5] = "BIT32";
+})(CODEC_TYPES || (CODEC_TYPES = {}));
+function createCodec(name, type, encode, decode) {
+    return {
+        name,
+        type,
+        encode,
+        decode
+    };
+}
+
+function enumeration(v) {
+    function findValue(val) {
+        // Use the reverse mapping to look up the enum key for the stored value
+        // https://www.typescriptlang.org/docs/handbook/enums.html#reverse-mappings
+        if (v[val.toString()] == null) {
+            throw new Error('Invalid enum value');
+        }
+        return v[val];
+    }
+    const encode = function enumEncode(val, writer) {
+        const enumValue = findValue(val);
+        writer.int32(enumValue);
+    };
+    const decode = function enumDecode(reader) {
+        const val = reader.int32();
+        return findValue(val);
+    };
+    // @ts-expect-error yeah yeah
+    return createCodec('enum', CODEC_TYPES.VARINT, encode, decode);
+}
+
+function message$1(encode, decode) {
+    return createCodec('message', CODEC_TYPES.LENGTH_DELIMITED, encode, decode);
+}
+
+/* eslint-disable import/export */
+var RateLimitProof$3;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.proof != null && obj.proof.byteLength > 0) {
+                    w.uint32(10);
+                    w.bytes(obj.proof);
+                }
+                if (obj.merkleRoot != null && obj.merkleRoot.byteLength > 0) {
+                    w.uint32(18);
+                    w.bytes(obj.merkleRoot);
+                }
+                if (obj.epoch != null && obj.epoch.byteLength > 0) {
+                    w.uint32(26);
+                    w.bytes(obj.epoch);
+                }
+                if (obj.shareX != null && obj.shareX.byteLength > 0) {
+                    w.uint32(34);
+                    w.bytes(obj.shareX);
+                }
+                if (obj.shareY != null && obj.shareY.byteLength > 0) {
+                    w.uint32(42);
+                    w.bytes(obj.shareY);
+                }
+                if (obj.nullifier != null && obj.nullifier.byteLength > 0) {
+                    w.uint32(50);
+                    w.bytes(obj.nullifier);
+                }
+                if (obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0) {
+                    w.uint32(58);
+                    w.bytes(obj.rlnIdentifier);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    proof: new Uint8Array(0),
+                    merkleRoot: new Uint8Array(0),
+                    epoch: new Uint8Array(0),
+                    shareX: new Uint8Array(0),
+                    shareY: new Uint8Array(0),
+                    nullifier: new Uint8Array(0),
+                    rlnIdentifier: new Uint8Array(0),
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.proof = reader.bytes();
+                            break;
+                        case 2:
+                            obj.merkleRoot = reader.bytes();
+                            break;
+                        case 3:
+                            obj.epoch = reader.bytes();
+                            break;
+                        case 4:
+                            obj.shareX = reader.bytes();
+                            break;
+                        case 5:
+                            obj.shareY = reader.bytes();
+                            break;
+                        case 6:
+                            obj.nullifier = reader.bytes();
+                            break;
+                        case 7:
+                            obj.rlnIdentifier = reader.bytes();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    RateLimitProof.encode = (obj) => {
+        return encodeMessage(obj, RateLimitProof.codec());
+    };
+    RateLimitProof.decode = (buf) => {
+        return decodeMessage(buf, RateLimitProof.codec());
+    };
+})(RateLimitProof$3 || (RateLimitProof$3 = {}));
+var WakuMessage$3;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.payload != null && obj.payload.byteLength > 0) {
+                    w.uint32(10);
+                    w.bytes(obj.payload);
+                }
+                if (obj.contentTopic != null && obj.contentTopic !== "") {
+                    w.uint32(18);
+                    w.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    w.uint32(24);
+                    w.uint32(obj.version);
+                }
+                if (obj.timestamp != null) {
+                    w.uint32(80);
+                    w.sint64(obj.timestamp);
+                }
+                if (obj.meta != null) {
+                    w.uint32(90);
+                    w.bytes(obj.meta);
+                }
+                if (obj.rateLimitProof != null) {
+                    w.uint32(170);
+                    RateLimitProof$3.codec().encode(obj.rateLimitProof, w);
+                }
+                if (obj.ephemeral != null) {
+                    w.uint32(248);
+                    w.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    payload: new Uint8Array(0),
+                    contentTopic: "",
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.payload = reader.bytes();
+                            break;
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.version = reader.uint32();
+                            break;
+                        case 10:
+                            obj.timestamp = reader.sint64();
+                            break;
+                        case 11:
+                            obj.meta = reader.bytes();
+                            break;
+                        case 21:
+                            obj.rateLimitProof = RateLimitProof$3.codec().decode(reader, reader.uint32());
+                            break;
+                        case 31:
+                            obj.ephemeral = reader.bool();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMessage.encode = (obj) => {
+        return encodeMessage(obj, WakuMessage.codec());
+    };
+    WakuMessage.decode = (buf) => {
+        return decodeMessage(buf, WakuMessage.codec());
+    };
+})(WakuMessage$3 || (WakuMessage$3 = {}));
+
+var message = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	get RateLimitProof () { return RateLimitProof$3; },
+	get WakuMessage () { return WakuMessage$3; }
+});
+
+/* eslint-disable import/export */
+var FilterRequest;
+(function (FilterRequest) {
+    (function (ContentFilter) {
+        let _codec;
+        ContentFilter.codec = () => {
+            if (_codec == null) {
+                _codec = message$1((obj, w, opts = {}) => {
+                    if (opts.lengthDelimited !== false) {
+                        w.fork();
+                    }
+                    if (obj.contentTopic != null && obj.contentTopic !== "") {
+                        w.uint32(10);
+                        w.string(obj.contentTopic);
+                    }
+                    if (opts.lengthDelimited !== false) {
+                        w.ldelim();
+                    }
+                }, (reader, length) => {
+                    const obj = {
+                        contentTopic: "",
+                    };
+                    const end = length == null ? reader.len : reader.pos + length;
+                    while (reader.pos < end) {
+                        const tag = reader.uint32();
+                        switch (tag >>> 3) {
+                            case 1:
+                                obj.contentTopic = reader.string();
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                        }
+                    }
+                    return obj;
+                });
+            }
+            return _codec;
+        };
+        ContentFilter.encode = (obj) => {
+            return encodeMessage(obj, ContentFilter.codec());
+        };
+        ContentFilter.decode = (buf) => {
+            return decodeMessage(buf, ContentFilter.codec());
+        };
+    })(FilterRequest.ContentFilter || (FilterRequest.ContentFilter = {}));
+    let _codec;
+    FilterRequest.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.subscribe != null && obj.subscribe !== false) {
+                    w.uint32(8);
+                    w.bool(obj.subscribe);
+                }
+                if (obj.topic != null && obj.topic !== "") {
+                    w.uint32(18);
+                    w.string(obj.topic);
+                }
+                if (obj.contentFilters != null) {
+                    for (const value of obj.contentFilters) {
+                        w.uint32(26);
+                        FilterRequest.ContentFilter.codec().encode(value, w);
+                    }
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    subscribe: false,
+                    topic: "",
+                    contentFilters: [],
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.subscribe = reader.bool();
+                            break;
+                        case 2:
+                            obj.topic = reader.string();
+                            break;
+                        case 3:
+                            obj.contentFilters.push(FilterRequest.ContentFilter.codec().decode(reader, reader.uint32()));
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    FilterRequest.encode = (obj) => {
+        return encodeMessage(obj, FilterRequest.codec());
+    };
+    FilterRequest.decode = (buf) => {
+        return decodeMessage(buf, FilterRequest.codec());
+    };
+})(FilterRequest || (FilterRequest = {}));
+var MessagePush;
+(function (MessagePush) {
+    let _codec;
+    MessagePush.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.messages != null) {
+                    for (const value of obj.messages) {
+                        w.uint32(10);
+                        WakuMessage$2.codec().encode(value, w);
+                    }
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    messages: [],
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.messages.push(WakuMessage$2.codec().decode(reader, reader.uint32()));
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    MessagePush.encode = (obj) => {
+        return encodeMessage(obj, MessagePush.codec());
+    };
+    MessagePush.decode = (buf) => {
+        return decodeMessage(buf, MessagePush.codec());
+    };
+})(MessagePush || (MessagePush = {}));
+var FilterRpc$1;
+(function (FilterRpc) {
+    let _codec;
+    FilterRpc.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.requestId != null && obj.requestId !== "") {
+                    w.uint32(10);
+                    w.string(obj.requestId);
+                }
+                if (obj.request != null) {
+                    w.uint32(18);
+                    FilterRequest.codec().encode(obj.request, w);
+                }
+                if (obj.push != null) {
+                    w.uint32(26);
+                    MessagePush.codec().encode(obj.push, w);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    requestId: "",
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.requestId = reader.string();
+                            break;
+                        case 2:
+                            obj.request = FilterRequest.codec().decode(reader, reader.uint32());
+                            break;
+                        case 3:
+                            obj.push = MessagePush.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    FilterRpc.encode = (obj) => {
+        return encodeMessage(obj, FilterRpc.codec());
+    };
+    FilterRpc.decode = (buf) => {
+        return decodeMessage(buf, FilterRpc.codec());
+    };
+})(FilterRpc$1 || (FilterRpc$1 = {}));
+var RateLimitProof$2;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.proof != null && obj.proof.byteLength > 0) {
+                    w.uint32(10);
+                    w.bytes(obj.proof);
+                }
+                if (obj.merkleRoot != null && obj.merkleRoot.byteLength > 0) {
+                    w.uint32(18);
+                    w.bytes(obj.merkleRoot);
+                }
+                if (obj.epoch != null && obj.epoch.byteLength > 0) {
+                    w.uint32(26);
+                    w.bytes(obj.epoch);
+                }
+                if (obj.shareX != null && obj.shareX.byteLength > 0) {
+                    w.uint32(34);
+                    w.bytes(obj.shareX);
+                }
+                if (obj.shareY != null && obj.shareY.byteLength > 0) {
+                    w.uint32(42);
+                    w.bytes(obj.shareY);
+                }
+                if (obj.nullifier != null && obj.nullifier.byteLength > 0) {
+                    w.uint32(50);
+                    w.bytes(obj.nullifier);
+                }
+                if (obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0) {
+                    w.uint32(58);
+                    w.bytes(obj.rlnIdentifier);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    proof: new Uint8Array(0),
+                    merkleRoot: new Uint8Array(0),
+                    epoch: new Uint8Array(0),
+                    shareX: new Uint8Array(0),
+                    shareY: new Uint8Array(0),
+                    nullifier: new Uint8Array(0),
+                    rlnIdentifier: new Uint8Array(0),
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.proof = reader.bytes();
+                            break;
+                        case 2:
+                            obj.merkleRoot = reader.bytes();
+                            break;
+                        case 3:
+                            obj.epoch = reader.bytes();
+                            break;
+                        case 4:
+                            obj.shareX = reader.bytes();
+                            break;
+                        case 5:
+                            obj.shareY = reader.bytes();
+                            break;
+                        case 6:
+                            obj.nullifier = reader.bytes();
+                            break;
+                        case 7:
+                            obj.rlnIdentifier = reader.bytes();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    RateLimitProof.encode = (obj) => {
+        return encodeMessage(obj, RateLimitProof.codec());
+    };
+    RateLimitProof.decode = (buf) => {
+        return decodeMessage(buf, RateLimitProof.codec());
+    };
+})(RateLimitProof$2 || (RateLimitProof$2 = {}));
+var WakuMessage$2;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.payload != null && obj.payload.byteLength > 0) {
+                    w.uint32(10);
+                    w.bytes(obj.payload);
+                }
+                if (obj.contentTopic != null && obj.contentTopic !== "") {
+                    w.uint32(18);
+                    w.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    w.uint32(24);
+                    w.uint32(obj.version);
+                }
+                if (obj.timestamp != null) {
+                    w.uint32(80);
+                    w.sint64(obj.timestamp);
+                }
+                if (obj.meta != null) {
+                    w.uint32(90);
+                    w.bytes(obj.meta);
+                }
+                if (obj.rateLimitProof != null) {
+                    w.uint32(170);
+                    RateLimitProof$2.codec().encode(obj.rateLimitProof, w);
+                }
+                if (obj.ephemeral != null) {
+                    w.uint32(248);
+                    w.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    payload: new Uint8Array(0),
+                    contentTopic: "",
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.payload = reader.bytes();
+                            break;
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.version = reader.uint32();
+                            break;
+                        case 10:
+                            obj.timestamp = reader.sint64();
+                            break;
+                        case 11:
+                            obj.meta = reader.bytes();
+                            break;
+                        case 21:
+                            obj.rateLimitProof = RateLimitProof$2.codec().decode(reader, reader.uint32());
+                            break;
+                        case 31:
+                            obj.ephemeral = reader.bool();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMessage.encode = (obj) => {
+        return encodeMessage(obj, WakuMessage.codec());
+    };
+    WakuMessage.decode = (buf) => {
+        return decodeMessage(buf, WakuMessage.codec());
+    };
+})(WakuMessage$2 || (WakuMessage$2 = {}));
+
+/* eslint-disable import/export */
+var TopicOnlyMessage;
+(function (TopicOnlyMessage) {
+    let _codec;
+    TopicOnlyMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.contentTopic != null && obj.contentTopic !== "") {
+                    w.uint32(18);
+                    w.string(obj.contentTopic);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    contentTopic: "",
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    TopicOnlyMessage.encode = (obj) => {
+        return encodeMessage(obj, TopicOnlyMessage.codec());
+    };
+    TopicOnlyMessage.decode = (buf) => {
+        return decodeMessage(buf, TopicOnlyMessage.codec());
+    };
+})(TopicOnlyMessage || (TopicOnlyMessage = {}));
+
+/* eslint-disable import/export */
+var PushRequest;
+(function (PushRequest) {
+    let _codec;
+    PushRequest.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.pubsubTopic != null && obj.pubsubTopic !== "") {
+                    w.uint32(10);
+                    w.string(obj.pubsubTopic);
+                }
+                if (obj.message != null) {
+                    w.uint32(18);
+                    WakuMessage$1.codec().encode(obj.message, w);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    pubsubTopic: "",
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.pubsubTopic = reader.string();
+                            break;
+                        case 2:
+                            obj.message = WakuMessage$1.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PushRequest.encode = (obj) => {
+        return encodeMessage(obj, PushRequest.codec());
+    };
+    PushRequest.decode = (buf) => {
+        return decodeMessage(buf, PushRequest.codec());
+    };
+})(PushRequest || (PushRequest = {}));
+var PushResponse;
+(function (PushResponse) {
+    let _codec;
+    PushResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.isSuccess != null && obj.isSuccess !== false) {
+                    w.uint32(8);
+                    w.bool(obj.isSuccess);
+                }
+                if (obj.info != null) {
+                    w.uint32(18);
+                    w.string(obj.info);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    isSuccess: false,
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.isSuccess = reader.bool();
+                            break;
+                        case 2:
+                            obj.info = reader.string();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PushResponse.encode = (obj) => {
+        return encodeMessage(obj, PushResponse.codec());
+    };
+    PushResponse.decode = (buf) => {
+        return decodeMessage(buf, PushResponse.codec());
+    };
+})(PushResponse || (PushResponse = {}));
+var PushRpc$1;
+(function (PushRpc) {
+    let _codec;
+    PushRpc.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.requestId != null && obj.requestId !== "") {
+                    w.uint32(10);
+                    w.string(obj.requestId);
+                }
+                if (obj.request != null) {
+                    w.uint32(18);
+                    PushRequest.codec().encode(obj.request, w);
+                }
+                if (obj.response != null) {
+                    w.uint32(26);
+                    PushResponse.codec().encode(obj.response, w);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    requestId: "",
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.requestId = reader.string();
+                            break;
+                        case 2:
+                            obj.request = PushRequest.codec().decode(reader, reader.uint32());
+                            break;
+                        case 3:
+                            obj.response = PushResponse.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PushRpc.encode = (obj) => {
+        return encodeMessage(obj, PushRpc.codec());
+    };
+    PushRpc.decode = (buf) => {
+        return decodeMessage(buf, PushRpc.codec());
+    };
+})(PushRpc$1 || (PushRpc$1 = {}));
+var RateLimitProof$1;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.proof != null && obj.proof.byteLength > 0) {
+                    w.uint32(10);
+                    w.bytes(obj.proof);
+                }
+                if (obj.merkleRoot != null && obj.merkleRoot.byteLength > 0) {
+                    w.uint32(18);
+                    w.bytes(obj.merkleRoot);
+                }
+                if (obj.epoch != null && obj.epoch.byteLength > 0) {
+                    w.uint32(26);
+                    w.bytes(obj.epoch);
+                }
+                if (obj.shareX != null && obj.shareX.byteLength > 0) {
+                    w.uint32(34);
+                    w.bytes(obj.shareX);
+                }
+                if (obj.shareY != null && obj.shareY.byteLength > 0) {
+                    w.uint32(42);
+                    w.bytes(obj.shareY);
+                }
+                if (obj.nullifier != null && obj.nullifier.byteLength > 0) {
+                    w.uint32(50);
+                    w.bytes(obj.nullifier);
+                }
+                if (obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0) {
+                    w.uint32(58);
+                    w.bytes(obj.rlnIdentifier);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    proof: new Uint8Array(0),
+                    merkleRoot: new Uint8Array(0),
+                    epoch: new Uint8Array(0),
+                    shareX: new Uint8Array(0),
+                    shareY: new Uint8Array(0),
+                    nullifier: new Uint8Array(0),
+                    rlnIdentifier: new Uint8Array(0),
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.proof = reader.bytes();
+                            break;
+                        case 2:
+                            obj.merkleRoot = reader.bytes();
+                            break;
+                        case 3:
+                            obj.epoch = reader.bytes();
+                            break;
+                        case 4:
+                            obj.shareX = reader.bytes();
+                            break;
+                        case 5:
+                            obj.shareY = reader.bytes();
+                            break;
+                        case 6:
+                            obj.nullifier = reader.bytes();
+                            break;
+                        case 7:
+                            obj.rlnIdentifier = reader.bytes();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    RateLimitProof.encode = (obj) => {
+        return encodeMessage(obj, RateLimitProof.codec());
+    };
+    RateLimitProof.decode = (buf) => {
+        return decodeMessage(buf, RateLimitProof.codec());
+    };
+})(RateLimitProof$1 || (RateLimitProof$1 = {}));
+var WakuMessage$1;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.payload != null && obj.payload.byteLength > 0) {
+                    w.uint32(10);
+                    w.bytes(obj.payload);
+                }
+                if (obj.contentTopic != null && obj.contentTopic !== "") {
+                    w.uint32(18);
+                    w.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    w.uint32(24);
+                    w.uint32(obj.version);
+                }
+                if (obj.timestamp != null) {
+                    w.uint32(80);
+                    w.sint64(obj.timestamp);
+                }
+                if (obj.meta != null) {
+                    w.uint32(90);
+                    w.bytes(obj.meta);
+                }
+                if (obj.rateLimitProof != null) {
+                    w.uint32(170);
+                    RateLimitProof$1.codec().encode(obj.rateLimitProof, w);
+                }
+                if (obj.ephemeral != null) {
+                    w.uint32(248);
+                    w.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    payload: new Uint8Array(0),
+                    contentTopic: "",
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.payload = reader.bytes();
+                            break;
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.version = reader.uint32();
+                            break;
+                        case 10:
+                            obj.timestamp = reader.sint64();
+                            break;
+                        case 11:
+                            obj.meta = reader.bytes();
+                            break;
+                        case 21:
+                            obj.rateLimitProof = RateLimitProof$1.codec().decode(reader, reader.uint32());
+                            break;
+                        case 31:
+                            obj.ephemeral = reader.bool();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMessage.encode = (obj) => {
+        return encodeMessage(obj, WakuMessage.codec());
+    };
+    WakuMessage.decode = (buf) => {
+        return decodeMessage(buf, WakuMessage.codec());
+    };
+})(WakuMessage$1 || (WakuMessage$1 = {}));
+
+/* eslint-disable import/export */
+var Index;
+(function (Index) {
+    let _codec;
+    Index.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.digest != null && obj.digest.byteLength > 0) {
+                    w.uint32(10);
+                    w.bytes(obj.digest);
+                }
+                if (obj.receiverTime != null && obj.receiverTime !== 0n) {
+                    w.uint32(16);
+                    w.sint64(obj.receiverTime);
+                }
+                if (obj.senderTime != null && obj.senderTime !== 0n) {
+                    w.uint32(24);
+                    w.sint64(obj.senderTime);
+                }
+                if (obj.pubsubTopic != null && obj.pubsubTopic !== "") {
+                    w.uint32(34);
+                    w.string(obj.pubsubTopic);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    digest: new Uint8Array(0),
+                    receiverTime: 0n,
+                    senderTime: 0n,
+                    pubsubTopic: "",
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.digest = reader.bytes();
+                            break;
+                        case 2:
+                            obj.receiverTime = reader.sint64();
+                            break;
+                        case 3:
+                            obj.senderTime = reader.sint64();
+                            break;
+                        case 4:
+                            obj.pubsubTopic = reader.string();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    Index.encode = (obj) => {
+        return encodeMessage(obj, Index.codec());
+    };
+    Index.decode = (buf) => {
+        return decodeMessage(buf, Index.codec());
+    };
+})(Index || (Index = {}));
+var PagingInfo;
+(function (PagingInfo) {
+    (function (Direction) {
+        Direction["BACKWARD"] = "BACKWARD";
+        Direction["FORWARD"] = "FORWARD";
+    })(PagingInfo.Direction || (PagingInfo.Direction = {}));
+    let __DirectionValues;
+    (function (__DirectionValues) {
+        __DirectionValues[__DirectionValues["BACKWARD"] = 0] = "BACKWARD";
+        __DirectionValues[__DirectionValues["FORWARD"] = 1] = "FORWARD";
+    })(__DirectionValues || (__DirectionValues = {}));
+    (function (Direction) {
+        Direction.codec = () => {
+            return enumeration(__DirectionValues);
+        };
+    })(PagingInfo.Direction || (PagingInfo.Direction = {}));
+    let _codec;
+    PagingInfo.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.pageSize != null) {
+                    w.uint32(8);
+                    w.uint64(obj.pageSize);
+                }
+                if (obj.cursor != null) {
+                    w.uint32(18);
+                    Index.codec().encode(obj.cursor, w);
+                }
+                if (obj.direction != null) {
+                    w.uint32(24);
+                    PagingInfo.Direction.codec().encode(obj.direction, w);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.pageSize = reader.uint64();
+                            break;
+                        case 2:
+                            obj.cursor = Index.codec().decode(reader, reader.uint32());
+                            break;
+                        case 3:
+                            obj.direction = PagingInfo.Direction.codec().decode(reader);
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PagingInfo.encode = (obj) => {
+        return encodeMessage(obj, PagingInfo.codec());
+    };
+    PagingInfo.decode = (buf) => {
+        return decodeMessage(buf, PagingInfo.codec());
+    };
+})(PagingInfo || (PagingInfo = {}));
+var ContentFilter;
+(function (ContentFilter) {
+    let _codec;
+    ContentFilter.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.contentTopic != null && obj.contentTopic !== "") {
+                    w.uint32(10);
+                    w.string(obj.contentTopic);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    contentTopic: "",
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.contentTopic = reader.string();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    ContentFilter.encode = (obj) => {
+        return encodeMessage(obj, ContentFilter.codec());
+    };
+    ContentFilter.decode = (buf) => {
+        return decodeMessage(buf, ContentFilter.codec());
+    };
+})(ContentFilter || (ContentFilter = {}));
+var HistoryQuery;
+(function (HistoryQuery) {
+    let _codec;
+    HistoryQuery.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.pubsubTopic != null) {
+                    w.uint32(18);
+                    w.string(obj.pubsubTopic);
+                }
+                if (obj.contentFilters != null) {
+                    for (const value of obj.contentFilters) {
+                        w.uint32(26);
+                        ContentFilter.codec().encode(value, w);
+                    }
+                }
+                if (obj.pagingInfo != null) {
+                    w.uint32(34);
+                    PagingInfo.codec().encode(obj.pagingInfo, w);
+                }
+                if (obj.startTime != null) {
+                    w.uint32(40);
+                    w.sint64(obj.startTime);
+                }
+                if (obj.endTime != null) {
+                    w.uint32(48);
+                    w.sint64(obj.endTime);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    contentFilters: [],
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 2:
+                            obj.pubsubTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.contentFilters.push(ContentFilter.codec().decode(reader, reader.uint32()));
+                            break;
+                        case 4:
+                            obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32());
+                            break;
+                        case 5:
+                            obj.startTime = reader.sint64();
+                            break;
+                        case 6:
+                            obj.endTime = reader.sint64();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    HistoryQuery.encode = (obj) => {
+        return encodeMessage(obj, HistoryQuery.codec());
+    };
+    HistoryQuery.decode = (buf) => {
+        return decodeMessage(buf, HistoryQuery.codec());
+    };
+})(HistoryQuery || (HistoryQuery = {}));
+var HistoryResponse;
+(function (HistoryResponse) {
+    let HistoryError;
+    (function (HistoryError) {
+        HistoryError["NONE"] = "NONE";
+        HistoryError["INVALID_CURSOR"] = "INVALID_CURSOR";
+    })(HistoryError = HistoryResponse.HistoryError || (HistoryResponse.HistoryError = {}));
+    let __HistoryErrorValues;
+    (function (__HistoryErrorValues) {
+        __HistoryErrorValues[__HistoryErrorValues["NONE"] = 0] = "NONE";
+        __HistoryErrorValues[__HistoryErrorValues["INVALID_CURSOR"] = 1] = "INVALID_CURSOR";
+    })(__HistoryErrorValues || (__HistoryErrorValues = {}));
+    (function (HistoryError) {
+        HistoryError.codec = () => {
+            return enumeration(__HistoryErrorValues);
+        };
+    })(HistoryError = HistoryResponse.HistoryError || (HistoryResponse.HistoryError = {}));
+    let _codec;
+    HistoryResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.messages != null) {
+                    for (const value of obj.messages) {
+                        w.uint32(18);
+                        WakuMessage.codec().encode(value, w);
+                    }
+                }
+                if (obj.pagingInfo != null) {
+                    w.uint32(26);
+                    PagingInfo.codec().encode(obj.pagingInfo, w);
+                }
+                if (obj.error != null && __HistoryErrorValues[obj.error] !== 0) {
+                    w.uint32(32);
+                    HistoryResponse.HistoryError.codec().encode(obj.error, w);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    messages: [],
+                    error: HistoryError.NONE,
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 2:
+                            obj.messages.push(WakuMessage.codec().decode(reader, reader.uint32()));
+                            break;
+                        case 3:
+                            obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32());
+                            break;
+                        case 4:
+                            obj.error = HistoryResponse.HistoryError.codec().decode(reader);
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    HistoryResponse.encode = (obj) => {
+        return encodeMessage(obj, HistoryResponse.codec());
+    };
+    HistoryResponse.decode = (buf) => {
+        return decodeMessage(buf, HistoryResponse.codec());
+    };
+})(HistoryResponse || (HistoryResponse = {}));
+var HistoryRpc$1;
+(function (HistoryRpc) {
+    let _codec;
+    HistoryRpc.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.requestId != null && obj.requestId !== "") {
+                    w.uint32(10);
+                    w.string(obj.requestId);
+                }
+                if (obj.query != null) {
+                    w.uint32(18);
+                    HistoryQuery.codec().encode(obj.query, w);
+                }
+                if (obj.response != null) {
+                    w.uint32(26);
+                    HistoryResponse.codec().encode(obj.response, w);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    requestId: "",
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.requestId = reader.string();
+                            break;
+                        case 2:
+                            obj.query = HistoryQuery.codec().decode(reader, reader.uint32());
+                            break;
+                        case 3:
+                            obj.response = HistoryResponse.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    HistoryRpc.encode = (obj) => {
+        return encodeMessage(obj, HistoryRpc.codec());
+    };
+    HistoryRpc.decode = (buf) => {
+        return decodeMessage(buf, HistoryRpc.codec());
+    };
+})(HistoryRpc$1 || (HistoryRpc$1 = {}));
+var RateLimitProof;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.proof != null && obj.proof.byteLength > 0) {
+                    w.uint32(10);
+                    w.bytes(obj.proof);
+                }
+                if (obj.merkleRoot != null && obj.merkleRoot.byteLength > 0) {
+                    w.uint32(18);
+                    w.bytes(obj.merkleRoot);
+                }
+                if (obj.epoch != null && obj.epoch.byteLength > 0) {
+                    w.uint32(26);
+                    w.bytes(obj.epoch);
+                }
+                if (obj.shareX != null && obj.shareX.byteLength > 0) {
+                    w.uint32(34);
+                    w.bytes(obj.shareX);
+                }
+                if (obj.shareY != null && obj.shareY.byteLength > 0) {
+                    w.uint32(42);
+                    w.bytes(obj.shareY);
+                }
+                if (obj.nullifier != null && obj.nullifier.byteLength > 0) {
+                    w.uint32(50);
+                    w.bytes(obj.nullifier);
+                }
+                if (obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0) {
+                    w.uint32(58);
+                    w.bytes(obj.rlnIdentifier);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    proof: new Uint8Array(0),
+                    merkleRoot: new Uint8Array(0),
+                    epoch: new Uint8Array(0),
+                    shareX: new Uint8Array(0),
+                    shareY: new Uint8Array(0),
+                    nullifier: new Uint8Array(0),
+                    rlnIdentifier: new Uint8Array(0),
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.proof = reader.bytes();
+                            break;
+                        case 2:
+                            obj.merkleRoot = reader.bytes();
+                            break;
+                        case 3:
+                            obj.epoch = reader.bytes();
+                            break;
+                        case 4:
+                            obj.shareX = reader.bytes();
+                            break;
+                        case 5:
+                            obj.shareY = reader.bytes();
+                            break;
+                        case 6:
+                            obj.nullifier = reader.bytes();
+                            break;
+                        case 7:
+                            obj.rlnIdentifier = reader.bytes();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    RateLimitProof.encode = (obj) => {
+        return encodeMessage(obj, RateLimitProof.codec());
+    };
+    RateLimitProof.decode = (buf) => {
+        return decodeMessage(buf, RateLimitProof.codec());
+    };
+})(RateLimitProof || (RateLimitProof = {}));
+var WakuMessage;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.payload != null && obj.payload.byteLength > 0) {
+                    w.uint32(10);
+                    w.bytes(obj.payload);
+                }
+                if (obj.contentTopic != null && obj.contentTopic !== "") {
+                    w.uint32(18);
+                    w.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    w.uint32(24);
+                    w.uint32(obj.version);
+                }
+                if (obj.timestamp != null) {
+                    w.uint32(80);
+                    w.sint64(obj.timestamp);
+                }
+                if (obj.meta != null) {
+                    w.uint32(90);
+                    w.bytes(obj.meta);
+                }
+                if (obj.rateLimitProof != null) {
+                    w.uint32(170);
+                    RateLimitProof.codec().encode(obj.rateLimitProof, w);
+                }
+                if (obj.ephemeral != null) {
+                    w.uint32(248);
+                    w.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    payload: new Uint8Array(0),
+                    contentTopic: "",
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.payload = reader.bytes();
+                            break;
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.version = reader.uint32();
+                            break;
+                        case 10:
+                            obj.timestamp = reader.sint64();
+                            break;
+                        case 11:
+                            obj.meta = reader.bytes();
+                            break;
+                        case 21:
+                            obj.rateLimitProof = RateLimitProof.codec().decode(reader, reader.uint32());
+                            break;
+                        case 31:
+                            obj.ephemeral = reader.bool();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMessage.encode = (obj) => {
+        return encodeMessage(obj, WakuMessage.codec());
+    };
+    WakuMessage.decode = (buf) => {
+        return decodeMessage(buf, WakuMessage.codec());
+    };
+})(WakuMessage || (WakuMessage = {}));
+
+/* eslint-disable import/export */
+var PeerInfo;
+(function (PeerInfo) {
+    let _codec;
+    PeerInfo.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.enr != null) {
+                    w.uint32(10);
+                    w.bytes(obj.enr);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.enr = reader.bytes();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PeerInfo.encode = (obj) => {
+        return encodeMessage(obj, PeerInfo.codec());
+    };
+    PeerInfo.decode = (buf) => {
+        return decodeMessage(buf, PeerInfo.codec());
+    };
+})(PeerInfo || (PeerInfo = {}));
+var PeerExchangeQuery;
+(function (PeerExchangeQuery) {
+    let _codec;
+    PeerExchangeQuery.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.numPeers != null) {
+                    w.uint32(8);
+                    w.uint64(obj.numPeers);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.numPeers = reader.uint64();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PeerExchangeQuery.encode = (obj) => {
+        return encodeMessage(obj, PeerExchangeQuery.codec());
+    };
+    PeerExchangeQuery.decode = (buf) => {
+        return decodeMessage(buf, PeerExchangeQuery.codec());
+    };
+})(PeerExchangeQuery || (PeerExchangeQuery = {}));
+var PeerExchangeResponse;
+(function (PeerExchangeResponse) {
+    let _codec;
+    PeerExchangeResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.peerInfos != null) {
+                    for (const value of obj.peerInfos) {
+                        w.uint32(10);
+                        PeerInfo.codec().encode(value, w);
+                    }
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    peerInfos: [],
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.peerInfos.push(PeerInfo.codec().decode(reader, reader.uint32()));
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PeerExchangeResponse.encode = (obj) => {
+        return encodeMessage(obj, PeerExchangeResponse.codec());
+    };
+    PeerExchangeResponse.decode = (buf) => {
+        return decodeMessage(buf, PeerExchangeResponse.codec());
+    };
+})(PeerExchangeResponse || (PeerExchangeResponse = {}));
+var PeerExchangeRPC;
+(function (PeerExchangeRPC) {
+    let _codec;
+    PeerExchangeRPC.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.query != null) {
+                    w.uint32(10);
+                    PeerExchangeQuery.codec().encode(obj.query, w);
+                }
+                if (obj.response != null) {
+                    w.uint32(18);
+                    PeerExchangeResponse.codec().encode(obj.response, w);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.query = PeerExchangeQuery.codec().decode(reader, reader.uint32());
+                            break;
+                        case 2:
+                            obj.response = PeerExchangeResponse.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PeerExchangeRPC.encode = (obj) => {
+        return encodeMessage(obj, PeerExchangeRPC.codec());
+    };
+    PeerExchangeRPC.decode = (buf) => {
+        return decodeMessage(buf, PeerExchangeRPC.codec());
+    };
+})(PeerExchangeRPC || (PeerExchangeRPC = {}));
+
+export { FilterRpc$1 as F, HistoryRpc$1 as H, PushRpc$1 as P, TopicOnlyMessage as T, WakuMessage$3 as W, PushResponse as a, aspromise as b, base64$1 as c, commonjsGlobal as d, eventemitter as e, float as f, getDefaultExportFromCjs as g, getAugmentedNamespace as h, inquire_1 as i, PagingInfo as j, HistoryResponse as k, message as m, pool_1 as p, utf8$2 as u };