@waku/core 0.0.5 → 0.0.7

package/bundle/{message-049c8b67.js → peer_exchange-53df2b11.js}

@@ -25,850 +25,1516 @@ function getAugmentedNamespace(n) {
 	return a;
 }
 
-var protobufjs = {exports: {}};
+var browser = {exports: {}};
 
-var src = {exports: {}};
+/**
+ * Helpers.
+ */
 
-var indexLight = {exports: {}};
+var ms;
+var hasRequiredMs;
+
+function requireMs () {
+	if (hasRequiredMs) return ms;
+	hasRequiredMs = 1;
+	var s = 1000;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var w = d * 7;
+	var y = d * 365.25;
+
+	/**
+	 * Parse or format the given `val`.
+	 *
+	 * Options:
+	 *
+	 *  - `long` verbose formatting [false]
+	 *
+	 * @param {String|Number} val
+	 * @param {Object} [options]
+	 * @throws {Error} throw an error if val is not a non-empty string or a number
+	 * @return {String|Number}
+	 * @api public
+	 */
+
+	ms = function(val, options) {
+	  options = options || {};
+	  var type = typeof val;
+	  if (type === 'string' && val.length > 0) {
+	    return parse(val);
+	  } else if (type === 'number' && isFinite(val)) {
+	    return options.long ? fmtLong(val) : fmtShort(val);
+	  }
+	  throw new Error(
+	    'val is not a non-empty string or a valid number. val=' +
+	      JSON.stringify(val)
+	  );
+	};
 
-var indexMinimal = {};
+	/**
+	 * Parse the given `str` and return milliseconds.
+	 *
+	 * @param {String} str
+	 * @return {Number}
+	 * @api private
+	 */
+
+	function parse(str) {
+	  str = String(str);
+	  if (str.length > 100) {
+	    return;
+	  }
+	  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+	    str
+	  );
+	  if (!match) {
+	    return;
+	  }
+	  var n = parseFloat(match[1]);
+	  var type = (match[2] || 'ms').toLowerCase();
+	  switch (type) {
+	    case 'years':
+	    case 'year':
+	    case 'yrs':
+	    case 'yr':
+	    case 'y':
+	      return n * y;
+	    case 'weeks':
+	    case 'week':
+	    case 'w':
+	      return n * w;
+	    case 'days':
+	    case 'day':
+	    case 'd':
+	      return n * d;
+	    case 'hours':
+	    case 'hour':
+	    case 'hrs':
+	    case 'hr':
+	    case 'h':
+	      return n * h;
+	    case 'minutes':
+	    case 'minute':
+	    case 'mins':
+	    case 'min':
+	    case 'm':
+	      return n * m;
+	    case 'seconds':
+	    case 'second':
+	    case 'secs':
+	    case 'sec':
+	    case 's':
+	      return n * s;
+	    case 'milliseconds':
+	    case 'millisecond':
+	    case 'msecs':
+	    case 'msec':
+	    case 'ms':
+	      return n;
+	    default:
+	      return undefined;
+	  }
+	}
 
-var minimal = {};
+	/**
+	 * Short format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtShort(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return Math.round(ms / d) + 'd';
+	  }
+	  if (msAbs >= h) {
+	    return Math.round(ms / h) + 'h';
+	  }
+	  if (msAbs >= m) {
+	    return Math.round(ms / m) + 'm';
+	  }
+	  if (msAbs >= s) {
+	    return Math.round(ms / s) + 's';
+	  }
+	  return ms + 'ms';
+	}
 
-var aspromise;
-var hasRequiredAspromise;
+	/**
+	 * Long format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtLong(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return plural(ms, msAbs, d, 'day');
+	  }
+	  if (msAbs >= h) {
+	    return plural(ms, msAbs, h, 'hour');
+	  }
+	  if (msAbs >= m) {
+	    return plural(ms, msAbs, m, 'minute');
+	  }
+	  if (msAbs >= s) {
+	    return plural(ms, msAbs, s, 'second');
+	  }
+	  return ms + ' ms';
+	}
 
-function requireAspromise () {
-	if (hasRequiredAspromise) return aspromise;
-	hasRequiredAspromise = 1;
-	aspromise = asPromise;
-
-	/**
-	 * Callback as used by {@link util.asPromise}.
-	 * @typedef asPromiseCallback
-	 * @type {function}
-	 * @param {Error|null} error Error, if any
-	 * @param {...*} params Additional arguments
-	 * @returns {undefined}
-	 */
-
-	/**
-	 * Returns a promise from a node-style callback function.
-	 * @memberof util
-	 * @param {asPromiseCallback} fn Function to call
-	 * @param {*} ctx Function context
-	 * @param {...*} params Function arguments
-	 * @returns {Promise<*>} Promisified function
-	 */
-	function asPromise(fn, ctx/*, varargs */) {
-	    var params  = new Array(arguments.length - 1),
-	        offset  = 0,
-	        index   = 2,
-	        pending = true;
-	    while (index < arguments.length)
-	        params[offset++] = arguments[index++];
-	    return new Promise(function executor(resolve, reject) {
-	        params[offset] = function callback(err/*, varargs */) {
-	            if (pending) {
-	                pending = false;
-	                if (err)
-	                    reject(err);
-	                else {
-	                    var params = new Array(arguments.length - 1),
-	                        offset = 0;
-	                    while (offset < params.length)
-	                        params[offset++] = arguments[offset];
-	                    resolve.apply(null, params);
-	                }
-	            }
-	        };
-	        try {
-	            fn.apply(ctx || null, params);
-	        } catch (err) {
-	            if (pending) {
-	                pending = false;
-	                reject(err);
-	            }
-	        }
-	    });
+	/**
+	 * Pluralization helper.
+	 */
+
+	function plural(ms, msAbs, n, name) {
+	  var isPlural = msAbs >= n * 1.5;
+	  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
 	}
-	return aspromise;
+	return ms;
 }
 
-var base64$1 = {};
+/**
+ * This is the common logic for both the Node.js and web browser
+ * implementations of `debug()`.
+ */
 
-var hasRequiredBase64;
+function setup(env) {
+	createDebug.debug = createDebug;
+	createDebug.default = createDebug;
+	createDebug.coerce = coerce;
+	createDebug.disable = disable;
+	createDebug.enable = enable;
+	createDebug.enabled = enabled;
+	createDebug.humanize = requireMs();
+	createDebug.destroy = destroy;
+
+	Object.keys(env).forEach(key => {
+		createDebug[key] = env[key];
+	});
 
-function requireBase64 () {
-	if (hasRequiredBase64) return base64$1;
-	hasRequiredBase64 = 1;
-	(function (exports) {
-
-		/**
-		 * A minimal base64 implementation for number arrays.
-		 * @memberof util
-		 * @namespace
-		 */
-		var base64 = exports;
-
-		/**
-		 * Calculates the byte length of a base64 encoded string.
-		 * @param {string} string Base64 encoded string
-		 * @returns {number} Byte length
-		 */
-		base64.length = function length(string) {
-		    var p = string.length;
-		    if (!p)
-		        return 0;
-		    var n = 0;
-		    while (--p % 4 > 1 && string.charAt(p) === "=")
-		        ++n;
-		    return Math.ceil(string.length * 3) / 4 - n;
-		};
-
-		// Base64 encoding table
-		var b64 = new Array(64);
-
-		// Base64 decoding table
-		var s64 = new Array(123);
-
-		// 65..90, 97..122, 48..57, 43, 47
-		for (var i = 0; i < 64;)
-		    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
-
-		/**
-		 * Encodes a buffer to a base64 encoded string.
-		 * @param {Uint8Array} buffer Source buffer
-		 * @param {number} start Source start
-		 * @param {number} end Source end
-		 * @returns {string} Base64 encoded string
-		 */
-		base64.encode = function encode(buffer, start, end) {
-		    var parts = null,
-		        chunk = [];
-		    var i = 0, // output index
-		        j = 0, // goto index
-		        t;     // temporary
-		    while (start < end) {
-		        var b = buffer[start++];
-		        switch (j) {
-		            case 0:
-		                chunk[i++] = b64[b >> 2];
-		                t = (b & 3) << 4;
-		                j = 1;
-		                break;
-		            case 1:
-		                chunk[i++] = b64[t | b >> 4];
-		                t = (b & 15) << 2;
-		                j = 2;
-		                break;
-		            case 2:
-		                chunk[i++] = b64[t | b >> 6];
-		                chunk[i++] = b64[b & 63];
-		                j = 0;
-		                break;
-		        }
-		        if (i > 8191) {
-		            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
-		            i = 0;
-		        }
-		    }
-		    if (j) {
-		        chunk[i++] = b64[t];
-		        chunk[i++] = 61;
-		        if (j === 1)
-		            chunk[i++] = 61;
-		    }
-		    if (parts) {
-		        if (i)
-		            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
-		        return parts.join("");
-		    }
-		    return String.fromCharCode.apply(String, chunk.slice(0, i));
-		};
-
-		var invalidEncoding = "invalid encoding";
+	/**
+	* The currently active debug mode names, and names to skip.
+	*/
+
+	createDebug.names = [];
+	createDebug.skips = [];
+
+	/**
+	* Map of special "%n" handling functions, for the debug "format" argument.
+	*
+	* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+	*/
+	createDebug.formatters = {};
+
+	/**
+	* Selects a color for a debug namespace
+	* @param {String} namespace The namespace string for the debug instance to be colored
+	* @return {Number|String} An ANSI color code for the given namespace
+	* @api private
+	*/
+	function selectColor(namespace) {
+		let hash = 0;
+
+		for (let i = 0; i < namespace.length; i++) {
+			hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
+			hash |= 0; // Convert to 32bit integer
+		}
+
+		return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+	}
+	createDebug.selectColor = selectColor;
+
+	/**
+	* Create a debugger with the given `namespace`.
+	*
+	* @param {String} namespace
+	* @return {Function}
+	* @api public
+	*/
+	function createDebug(namespace) {
+		let prevTime;
+		let enableOverride = null;
+		let namespacesCache;
+		let enabledCache;
+
+		function debug(...args) {
+			// Disabled?
+			if (!debug.enabled) {
+				return;
+			}
+
+			const self = debug;
+
+			// Set `diff` timestamp
+			const curr = Number(new Date());
+			const ms = curr - (prevTime || curr);
+			self.diff = ms;
+			self.prev = prevTime;
+			self.curr = curr;
+			prevTime = curr;
+
+			args[0] = createDebug.coerce(args[0]);
+
+			if (typeof args[0] !== 'string') {
+				// Anything else let's inspect with %O
+				args.unshift('%O');
+			}
+
+			// Apply any `formatters` transformations
+			let index = 0;
+			args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+				// If we encounter an escaped % then don't increase the array index
+				if (match === '%%') {
+					return '%';
+				}
+				index++;
+				const formatter = createDebug.formatters[format];
+				if (typeof formatter === 'function') {
+					const val = args[index];
+					match = formatter.call(self, val);
+
+					// Now we need to remove `args[index]` since it's inlined in the `format`
+					args.splice(index, 1);
+					index--;
+				}
+				return match;
+			});
+
+			// Apply env-specific formatting (colors, etc.)
+			createDebug.formatArgs.call(self, args);
+
+			const logFn = self.log || createDebug.log;
+			logFn.apply(self, args);
+		}
+
+		debug.namespace = namespace;
+		debug.useColors = createDebug.useColors();
+		debug.color = createDebug.selectColor(namespace);
+		debug.extend = extend;
+		debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
+
+		Object.defineProperty(debug, 'enabled', {
+			enumerable: true,
+			configurable: false,
+			get: () => {
+				if (enableOverride !== null) {
+					return enableOverride;
+				}
+				if (namespacesCache !== createDebug.namespaces) {
+					namespacesCache = createDebug.namespaces;
+					enabledCache = createDebug.enabled(namespace);
+				}
+
+				return enabledCache;
+			},
+			set: v => {
+				enableOverride = v;
+			}
+		});
+
+		// Env-specific initialization logic for debug instances
+		if (typeof createDebug.init === 'function') {
+			createDebug.init(debug);
+		}
+
+		return debug;
+	}
+
+	function extend(namespace, delimiter) {
+		const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+		newDebug.log = this.log;
+		return newDebug;
+	}
+
+	/**
+	* Enables a debug mode by namespaces. This can include modes
+	* separated by a colon and wildcards.
+	*
+	* @param {String} namespaces
+	* @api public
+	*/
+	function enable(namespaces) {
+		createDebug.save(namespaces);
+		createDebug.namespaces = namespaces;
+
+		createDebug.names = [];
+		createDebug.skips = [];
+
+		let i;
+		const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+		const len = split.length;
+
+		for (i = 0; i < len; i++) {
+			if (!split[i]) {
+				// ignore empty strings
+				continue;
+			}
+
+			namespaces = split[i].replace(/\*/g, '.*?');
+
+			if (namespaces[0] === '-') {
+				createDebug.skips.push(new RegExp('^' + namespaces.slice(1) + '$'));
+			} else {
+				createDebug.names.push(new RegExp('^' + namespaces + '$'));
+			}
+		}
+	}
+
+	/**
+	* Disable debug output.
+	*
+	* @return {String} namespaces
+	* @api public
+	*/
+	function disable() {
+		const namespaces = [
+			...createDebug.names.map(toNamespace),
+			...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
+		].join(',');
+		createDebug.enable('');
+		return namespaces;
+	}
+
+	/**
+	* Returns true if the given mode name is enabled, false otherwise.
+	*
+	* @param {String} name
+	* @return {Boolean}
+	* @api public
+	*/
+	function enabled(name) {
+		if (name[name.length - 1] === '*') {
+			return true;
+		}
+
+		let i;
+		let len;
+
+		for (i = 0, len = createDebug.skips.length; i < len; i++) {
+			if (createDebug.skips[i].test(name)) {
+				return false;
+			}
+		}
+
+		for (i = 0, len = createDebug.names.length; i < len; i++) {
+			if (createDebug.names[i].test(name)) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	* Convert regexp to namespace
+	*
+	* @param {RegExp} regxep
+	* @return {String} namespace
+	* @api private
+	*/
+	function toNamespace(regexp) {
+		return regexp.toString()
+			.substring(2, regexp.toString().length - 2)
+			.replace(/\.\*\?$/, '*');
+	}
+
+	/**
+	* Coerce `val`.
+	*
+	* @param {Mixed} val
+	* @return {Mixed}
+	* @api private
+	*/
+	function coerce(val) {
+		if (val instanceof Error) {
+			return val.stack || val.message;
+		}
+		return val;
+	}
+
+	/**
+	* XXX DO NOT USE. This is a temporary stub function.
+	* XXX It WILL be removed in the next major release.
+	*/
+	function destroy() {
+		console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+	}
+
+	createDebug.enable(createDebug.load());
+
+	return createDebug;
+}
+
+var common$1 = setup;
+
+/* eslint-env browser */
+
+(function (module, exports) {
+	/**
+	 * This is the web browser implementation of `debug()`.
+	 */
+
+	exports.formatArgs = formatArgs;
+	exports.save = save;
+	exports.load = load;
+	exports.useColors = useColors;
+	exports.storage = localstorage();
+	exports.destroy = (() => {
+		let warned = false;
+
+		return () => {
+			if (!warned) {
+				warned = true;
+				console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+			}
+		};
+	})();
+
+	/**
+	 * Colors.
+	 */
+
+	exports.colors = [
+		'#0000CC',
+		'#0000FF',
+		'#0033CC',
+		'#0033FF',
+		'#0066CC',
+		'#0066FF',
+		'#0099CC',
+		'#0099FF',
+		'#00CC00',
+		'#00CC33',
+		'#00CC66',
+		'#00CC99',
+		'#00CCCC',
+		'#00CCFF',
+		'#3300CC',
+		'#3300FF',
+		'#3333CC',
+		'#3333FF',
+		'#3366CC',
+		'#3366FF',
+		'#3399CC',
+		'#3399FF',
+		'#33CC00',
+		'#33CC33',
+		'#33CC66',
+		'#33CC99',
+		'#33CCCC',
+		'#33CCFF',
+		'#6600CC',
+		'#6600FF',
+		'#6633CC',
+		'#6633FF',
+		'#66CC00',
+		'#66CC33',
+		'#9900CC',
+		'#9900FF',
+		'#9933CC',
+		'#9933FF',
+		'#99CC00',
+		'#99CC33',
+		'#CC0000',
+		'#CC0033',
+		'#CC0066',
+		'#CC0099',
+		'#CC00CC',
+		'#CC00FF',
+		'#CC3300',
+		'#CC3333',
+		'#CC3366',
+		'#CC3399',
+		'#CC33CC',
+		'#CC33FF',
+		'#CC6600',
+		'#CC6633',
+		'#CC9900',
+		'#CC9933',
+		'#CCCC00',
+		'#CCCC33',
+		'#FF0000',
+		'#FF0033',
+		'#FF0066',
+		'#FF0099',
+		'#FF00CC',
+		'#FF00FF',
+		'#FF3300',
+		'#FF3333',
+		'#FF3366',
+		'#FF3399',
+		'#FF33CC',
+		'#FF33FF',
+		'#FF6600',
+		'#FF6633',
+		'#FF9900',
+		'#FF9933',
+		'#FFCC00',
+		'#FFCC33'
+	];
+
+	/**
+	 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+	 * and the Firebug extension (any Firefox version) are known
+	 * to support "%c" CSS customizations.
+	 *
+	 * TODO: add a `localStorage` variable to explicitly enable/disable colors
+	 */
+
+	// eslint-disable-next-line complexity
+	function useColors() {
+		// NB: In an Electron preload script, document will be defined but not fully
+		// initialized. Since we know we're in Chrome, we'll just detect this case
+		// explicitly
+		if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+			return true;
+		}
+
+		// Internet Explorer and Edge do not support colors.
+		if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+			return false;
+		}
+
+		// Is webkit? http://stackoverflow.com/a/16459606/376773
+		// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+		return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+			// Is firebug? http://stackoverflow.com/a/398120/376773
+			(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+			// Is firefox >= v31?
+			// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+			(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+			// Double check webkit in userAgent just in case we are in a worker
+			(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+	}
+
+	/**
+	 * Colorize log arguments if enabled.
+	 *
+	 * @api public
+	 */
+
+	function formatArgs(args) {
+		args[0] = (this.useColors ? '%c' : '') +
+			this.namespace +
+			(this.useColors ? ' %c' : ' ') +
+			args[0] +
+			(this.useColors ? '%c ' : ' ') +
+			'+' + module.exports.humanize(this.diff);
+
+		if (!this.useColors) {
+			return;
+		}
+
+		const c = 'color: ' + this.color;
+		args.splice(1, 0, c, 'color: inherit');
+
+		// The final "%c" is somewhat tricky, because there could be other
+		// arguments passed either before or after the %c, so we need to
+		// figure out the correct index to insert the CSS into
+		let index = 0;
+		let lastC = 0;
+		args[0].replace(/%[a-zA-Z%]/g, match => {
+			if (match === '%%') {
+				return;
+			}
+			index++;
+			if (match === '%c') {
+				// We only are interested in the *last* %c
+				// (the user may have provided their own)
+				lastC = index;
+			}
+		});
+
+		args.splice(lastC, 0, c);
+	}
+
+	/**
+	 * Invokes `console.debug()` when available.
+	 * No-op when `console.debug` is not a "function".
+	 * If `console.debug` is not available, falls back
+	 * to `console.log`.
+	 *
+	 * @api public
+	 */
+	exports.log = console.debug || console.log || (() => {});
+
+	/**
+	 * Save `namespaces`.
+	 *
+	 * @param {String} namespaces
+	 * @api private
+	 */
+	function save(namespaces) {
+		try {
+			if (namespaces) {
+				exports.storage.setItem('debug', namespaces);
+			} else {
+				exports.storage.removeItem('debug');
+			}
+		} catch (error) {
+			// Swallow
+			// XXX (@Qix-) should we be logging these?
+		}
+	}
+
+	/**
+	 * Load `namespaces`.
+	 *
+	 * @return {String} returns the previously persisted debug modes
+	 * @api private
+	 */
+	function load() {
+		let r;
+		try {
+			r = exports.storage.getItem('debug');
+		} catch (error) {
+			// Swallow
+			// XXX (@Qix-) should we be logging these?
+		}
+
+		// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+		if (!r && typeof process !== 'undefined' && 'env' in process) {
+			r = process.env.DEBUG;
+		}
+
+		return r;
+	}
+
+	/**
+	 * Localstorage attempts to return the localstorage.
+	 *
+	 * This is necessary because safari throws
+	 * when a user disables cookies/localstorage
+	 * and you attempt to access it.
+	 *
+	 * @return {LocalStorage}
+	 * @api private
+	 */
+
+	function localstorage() {
+		try {
+			// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+			// The Browser also has localStorage in the global context.
+			return localStorage;
+		} catch (error) {
+			// Swallow
+			// XXX (@Qix-) should we be logging these?
+		}
+	}
+
+	module.exports = common$1(exports);
+
+	const {formatters} = module.exports;
+
+	/**
+	 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+	 */
+
+	formatters.j = function (v) {
+		try {
+			return JSON.stringify(v);
+		} catch (error) {
+			return '[UnexpectedJSONParseError]: ' + error.message;
+		}
+	};
+} (browser, browser.exports));
+
+var debug = browser.exports;
+
+var aspromise = asPromise;
 
-		/**
-		 * 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;
-		};
+/**
+ * Callback as used by {@link util.asPromise}.
+ * @typedef asPromiseCallback
+ * @type {function}
+ * @param {Error|null} error Error, if any
+ * @param {...*} params Additional arguments
+ * @returns {undefined}
+ */
 
-		/**
-		 * Tests if the specified string appears to be base64 encoded.
-		 * @param {string} string String to test
-		 * @returns {boolean} `true` if probably base64 encoded, otherwise false
-		 */
-		base64.test = function test(string) {
-		    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
-		};
-} (base64$1));
-	return base64$1;
+/**
+ * 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 eventemitter;
-var hasRequiredEventemitter;
+var base64$1 = {};
 
-function requireEventemitter () {
-	if (hasRequiredEventemitter) return eventemitter;
-	hasRequiredEventemitter = 1;
-	eventemitter = EventEmitter;
+(function (exports) {
 
 	/**
-	 * Constructs a new event emitter instance.
-	 * @classdesc A minimal event emitter.
+	 * A minimal base64 implementation for number arrays.
 	 * @memberof util
-	 * @constructor
+	 * @namespace
 	 */
-	function EventEmitter() {
-
-	    /**
-	     * Registered listeners.
-	     * @type {Object.<string,*>}
-	     * @private
-	     */
-	    this._listeners = {};
-	}
+	var base64 = exports;
 
 	/**
-	 * Registers an event listener.
-	 * @param {string} evt Event name
-	 * @param {function} fn Listener
-	 * @param {*} [ctx] Listener context
-	 * @returns {util.EventEmitter} `this`
+	 * Calculates the byte length of a base64 encoded string.
+	 * @param {string} string Base64 encoded string
+	 * @returns {number} Byte length
 	 */
-	EventEmitter.prototype.on = function on(evt, fn, ctx) {
-	    (this._listeners[evt] || (this._listeners[evt] = [])).push({
-	        fn  : fn,
-	        ctx : ctx || this
-	    });
-	    return this;
+	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++;
+
 	/**
-	 * 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`
+	 * 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
 	 */
-	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;
+	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;
 	        }
 	    }
-	    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);
+	    if (j) {
+	        chunk[i++] = b64[t];
+	        chunk[i++] = 61;
+	        if (j === 1)
+	            chunk[i++] = 61;
 	    }
-	    return this;
-	};
-	return eventemitter;
-}
-
-var float;
-var hasRequiredFloat;
-
-function requireFloat () {
-	if (hasRequiredFloat) return float;
-	hasRequiredFloat = 1;
+	    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));
+	};
 
-	float = factory(factory);
+	var invalidEncoding = "invalid encoding";
 
 	/**
-	 * Reads / writes floats / doubles from / to buffers.
-	 * @name util.float
-	 * @namespace
+	 * 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;
+	};
 
 	/**
-	 * 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}
+	 * 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;
 
-	/**
-	 * 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}
-	 */
+/**
+ * Constructs a new event emitter instance.
+ * @classdesc A minimal event emitter.
+ * @memberof util
+ * @constructor
+ */
+function EventEmitter() {
 
-	/**
-	 * 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
-	 */
+    /**
+     * Registered listeners.
+     * @type {Object.<string,*>}
+     * @private
+     */
+    this._listeners = {};
+}
 
-	/**
-	 * 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
-	 */
+/**
+ * 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;
+};
 
-	/**
-	 * 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}
-	 */
+/**
+ * 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;
+};
 
-	/**
-	 * 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}
-	 */
+/**
+ * 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 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 / writes floats / doubles from / to buffers.
+ * @name util.float
+ * @namespace
+ */
 
-	/**
-	 * 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
-	 */
+/**
+ * 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}
+ */
 
-	// Factory function for the purpose of node-based testing in modified global environments
-	function factory(exports) {
+/**
+ * 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}
+ */
 
-	    // float: typed array
-	    if (typeof Float32Array !== "undefined") (function() {
+/**
+ * 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
+ */
 
-	        var f32 = new Float32Array([ -0 ]),
-	            f8b = new Uint8Array(f32.buffer),
-	            le  = f8b[3] === 128;
+/**
+ * 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
+ */
 
-	        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];
-	        }
+/**
+ * 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}
+ */
 
-	        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];
-	        }
+/**
+ * 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}
+ */
 
-	        /* istanbul ignore next */
-	        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
-	        /* istanbul ignore next */
-	        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
+/**
+ * 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
+ */
 
-	        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];
-	        }
+/**
+ * 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
+ */
 
-	        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];
-	        }
+// Factory function for the purpose of node-based testing in modified global environments
+function factory(exports) {
 
-	        /* 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: typed array
+    if (typeof Float32Array !== "undefined") (function() {
 
-	    // float: ieee754
-	    })(); else (function() {
+        var f32 = new Float32Array([ -0 ]),
+            f8b = new Uint8Array(f32.buffer),
+            le  = f8b[3] === 128;
 
-	        function writeFloat_ieee754(writeUint, val, buf, pos) {
-	            var sign = val < 0 ? 1 : 0;
-	            if (sign)
-	                val = -val;
-	            if (val === 0)
-	                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);
-	            else if (isNaN(val))
-	                writeUint(2143289344, buf, pos);
-	            else if (val > 3.4028234663852886e+38) // +-Infinity
-	                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
-	            else if (val < 1.1754943508222875e-38) // denormal
-	                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);
-	            else {
-	                var exponent = Math.floor(Math.log(val) / Math.LN2),
-	                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
-	                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
-	            }
-	        }
+        function writeFloat_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];
+        }
 
-	        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
-	        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
+        function writeFloat_f32_rev(val, buf, pos) {
+            f32[0] = val;
+            buf[pos    ] = f8b[3];
+            buf[pos + 1] = f8b[2];
+            buf[pos + 2] = f8b[1];
+            buf[pos + 3] = f8b[0];
+        }
 
-	        function readFloat_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);
-	        }
+        /* istanbul ignore next */
+        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
+        /* istanbul ignore next */
+        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
 
-	        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
-	        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
+        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];
+        }
 
-	    // double: typed array
-	    if (typeof Float64Array !== "undefined") (function() {
+        /* istanbul ignore next */
+        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
+        /* istanbul ignore next */
+        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
 
-	        var f64 = new Float64Array([-0]),
-	            f8b = new Uint8Array(f64.buffer),
-	            le  = f8b[7] === 128;
+    // float: ieee754
+    })(); else (function() {
 
-	        function writeDouble_f64_cpy(val, buf, pos) {
-	            f64[0] = val;
-	            buf[pos    ] = f8b[0];
-	            buf[pos + 1] = f8b[1];
-	            buf[pos + 2] = f8b[2];
-	            buf[pos + 3] = f8b[3];
-	            buf[pos + 4] = f8b[4];
-	            buf[pos + 5] = f8b[5];
-	            buf[pos + 6] = f8b[6];
-	            buf[pos + 7] = f8b[7];
-	        }
+        function writeFloat_ieee754(writeUint, val, buf, pos) {
+            var sign = val < 0 ? 1 : 0;
+            if (sign)
+                val = -val;
+            if (val === 0)
+                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);
+            else if (isNaN(val))
+                writeUint(2143289344, buf, pos);
+            else if (val > 3.4028234663852886e+38) // +-Infinity
+                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
+            else if (val < 1.1754943508222875e-38) // denormal
+                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);
+            else {
+                var exponent = Math.floor(Math.log(val) / Math.LN2),
+                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
+                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
+            }
+        }
 
-	        function 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];
-	        }
+        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
+        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
 
-	        /* 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 readFloat_ieee754(readUint, buf, pos) {
+            var uint = readUint(buf, pos),
+                sign = (uint >> 31) * 2 + 1,
+                exponent = uint >>> 23 & 255,
+                mantissa = uint & 8388607;
+            return exponent === 255
+                ? mantissa
+                ? NaN
+                : sign * Infinity
+                : exponent === 0 // denormal
+                ? sign * 1.401298464324817e-45 * mantissa
+                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
+        }
 
-	        function 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];
-	        }
+        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
+        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
 
-	        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: typed array
+    if (typeof Float64Array !== "undefined") (function() {
 
-	    // double: ieee754
-	    })(); else (function() {
+        var f64 = new Float64Array([-0]),
+            f8b = new Uint8Array(f64.buffer),
+            le  = f8b[7] === 128;
 
-	        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
-	            var sign = val < 0 ? 1 : 0;
-	            if (sign)
-	                val = -val;
-	            if (val === 0) {
-	                writeUint(0, buf, pos + off0);
-	                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);
-	            } else if (isNaN(val)) {
-	                writeUint(0, buf, pos + off0);
-	                writeUint(2146959360, buf, pos + off1);
-	            } else if (val > 1.7976931348623157e+308) { // +-Infinity
-	                writeUint(0, buf, pos + off0);
-	                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
-	            } else {
-	                var mantissa;
-	                if (val < 2.2250738585072014e-308) { // denormal
-	                    mantissa = val / 5e-324;
-	                    writeUint(mantissa >>> 0, buf, pos + off0);
-	                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
-	                } else {
-	                    var exponent = Math.floor(Math.log(val) / Math.LN2);
-	                    if (exponent === 1024)
-	                        exponent = 1023;
-	                    mantissa = val * Math.pow(2, -exponent);
-	                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
-	                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
-	                }
-	            }
-	        }
+        function writeDouble_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];
+        }
 
-	        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
-	        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
+        function writeDouble_f64_rev(val, buf, pos) {
+            f64[0] = val;
+            buf[pos    ] = f8b[7];
+            buf[pos + 1] = f8b[6];
+            buf[pos + 2] = f8b[5];
+            buf[pos + 3] = f8b[4];
+            buf[pos + 4] = f8b[3];
+            buf[pos + 5] = f8b[2];
+            buf[pos + 6] = f8b[1];
+            buf[pos + 7] = f8b[0];
+        }
 
-	        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);
-	        }
+        /* istanbul ignore next */
+        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
+        /* istanbul ignore next */
+        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
 
-	        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
-	        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
+        function readDouble_f64_cpy(buf, pos) {
+            f8b[0] = buf[pos    ];
+            f8b[1] = buf[pos + 1];
+            f8b[2] = buf[pos + 2];
+            f8b[3] = buf[pos + 3];
+            f8b[4] = buf[pos + 4];
+            f8b[5] = buf[pos + 5];
+            f8b[6] = buf[pos + 6];
+            f8b[7] = buf[pos + 7];
+            return f64[0];
+        }
 
-	    })();
+        function readDouble_f64_rev(buf, pos) {
+            f8b[7] = buf[pos    ];
+            f8b[6] = buf[pos + 1];
+            f8b[5] = buf[pos + 2];
+            f8b[4] = buf[pos + 3];
+            f8b[3] = buf[pos + 4];
+            f8b[2] = buf[pos + 5];
+            f8b[1] = buf[pos + 6];
+            f8b[0] = buf[pos + 7];
+            return f64[0];
+        }
 
-	    return exports;
-	}
+        /* istanbul ignore next */
+        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
+        /* istanbul ignore next */
+        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
 
-	// uint helpers
+    // double: ieee754
+    })(); else (function() {
 
-	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 writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
+            var sign = val < 0 ? 1 : 0;
+            if (sign)
+                val = -val;
+            if (val === 0) {
+                writeUint(0, buf, pos + off0);
+                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);
+            } else if (isNaN(val)) {
+                writeUint(0, buf, pos + off0);
+                writeUint(2146959360, buf, pos + off1);
+            } else if (val > 1.7976931348623157e+308) { // +-Infinity
+                writeUint(0, buf, pos + off0);
+                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
+            } else {
+                var mantissa;
+                if (val < 2.2250738585072014e-308) { // denormal
+                    mantissa = val / 5e-324;
+                    writeUint(mantissa >>> 0, buf, pos + off0);
+                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
+                } else {
+                    var exponent = Math.floor(Math.log(val) / Math.LN2);
+                    if (exponent === 1024)
+                        exponent = 1023;
+                    mantissa = val * Math.pow(2, -exponent);
+                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
+                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
+                }
+            }
+        }
 
-	function 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;
-	}
+        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
+        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
 
-	function readUintLE(buf, pos) {
-	    return (buf[pos    ]
-	          | buf[pos + 1] << 8
-	          | buf[pos + 2] << 16
-	          | buf[pos + 3] << 24) >>> 0;
-	}
+        function readDouble_ieee754(readUint, off0, off1, buf, pos) {
+            var lo = readUint(buf, pos + off0),
+                hi = readUint(buf, pos + off1);
+            var sign = (hi >> 31) * 2 + 1,
+                exponent = hi >>> 20 & 2047,
+                mantissa = 4294967296 * (hi & 1048575) + lo;
+            return exponent === 2047
+                ? mantissa
+                ? NaN
+                : sign * Infinity
+                : exponent === 0 // denormal
+                ? sign * 5e-324 * mantissa
+                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
+        }
 
-	function readUintBE(buf, pos) {
-	    return (buf[pos    ] << 24
-	          | buf[pos + 1] << 16
-	          | buf[pos + 2] << 8
-	          | buf[pos + 3]) >>> 0;
-	}
-	return float;
-}
-
-var inquire_1;
-var hasRequiredInquire;
-
-function requireInquire () {
-	if (hasRequiredInquire) return inquire_1;
-	hasRequiredInquire = 1;
-	inquire_1 = inquire;
+        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
+        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
 
-	/**
-	 * Requires a module only if available.
-	 * @memberof util
-	 * @param {string} moduleName Module to require
-	 * @returns {?Object} Required module if available and not empty, otherwise `null`
-	 */
-	function inquire(moduleName) {
-	    try {
-	        var mod = eval("quire".replace(/^/,"re"))(moduleName); // eslint-disable-line no-eval
-	        if (mod && (mod.length || Object.keys(mod).length))
-	            return mod;
-	    } catch (e) {} // eslint-disable-line no-empty
-	    return null;
-	}
-	return inquire_1;
-}
-
-var utf8$2 = {};
-
-var hasRequiredUtf8;
-
-function requireUtf8 () {
-	if (hasRequiredUtf8) return utf8$2;
-	hasRequiredUtf8 = 1;
-	(function (exports) {
+    })();
 
-		/**
-		 * A minimal UTF8 implementation for number arrays.
-		 * @memberof util
-		 * @namespace
-		 */
-		var utf8 = exports;
+    return 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;
-		};
+// uint helpers
 
-		/**
-		 * 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));
-		};
+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;
+}
 
-		/**
-		 * Writes a string as UTF8 bytes.
-		 * @param {string} string Source string
-		 * @param {Uint8Array} buffer Destination buffer
-		 * @param {number} offset Destination offset
-		 * @returns {number} Bytes written
-		 */
-		utf8.write = function utf8_write(string, buffer, offset) {
-		    var start = offset,
-		        c1, // character 1
-		        c2; // character 2
-		    for (var i = 0; i < string.length; ++i) {
-		        c1 = string.charCodeAt(i);
-		        if (c1 < 128) {
-		            buffer[offset++] = c1;
-		        } else if (c1 < 2048) {
-		            buffer[offset++] = c1 >> 6       | 192;
-		            buffer[offset++] = c1       & 63 | 128;
-		        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
-		            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
-		            ++i;
-		            buffer[offset++] = c1 >> 18      | 240;
-		            buffer[offset++] = c1 >> 12 & 63 | 128;
-		            buffer[offset++] = c1 >> 6  & 63 | 128;
-		            buffer[offset++] = c1       & 63 | 128;
-		        } else {
-		            buffer[offset++] = c1 >> 12      | 224;
-		            buffer[offset++] = c1 >> 6  & 63 | 128;
-		            buffer[offset++] = c1       & 63 | 128;
-		        }
-		    }
-		    return offset - start;
-		};
-} (utf8$2));
-	return utf8$2;
+function 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 pool_1;
-var hasRequiredPool;
+var utf8$2 = {};
 
-function requirePool () {
-	if (hasRequiredPool) return pool_1;
-	hasRequiredPool = 1;
-	pool_1 = pool;
+(function (exports) {
 
 	/**
-	 * An allocator as used by {@link util.pool}.
-	 * @typedef PoolAllocator
-	 * @type {function}
-	 * @param {number} size Buffer size
-	 * @returns {Uint8Array} Buffer
+	 * A minimal UTF8 implementation for number arrays.
+	 * @memberof util
+	 * @namespace
 	 */
+	var utf8 = exports;
 
 	/**
-	 * 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}
+	 * 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;
+	};
 
 	/**
-	 * 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
+	 * 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
 	 */
-	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;
+	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;
 	        }
-	        var buf = slice.call(slab, offset, offset += size);
-	        if (offset & 7) // align to 32 bit
-	            offset = (offset | 7) + 1;
-	        return buf;
-	    };
-	}
-	return pool_1;
+	    }
+	    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 protobufjs = {exports: {}};
+
+var src = {exports: {}};
+
+var indexLight = {exports: {}};
+
+var indexMinimal = {};
+
+var minimal = {};
+
 var longbits;
 var hasRequiredLongbits;
 
@@ -1086,25 +1752,25 @@ function requireMinimal () {
 		var util = exports;
 
 		// used to return a Promise where callback is omitted
-		util.asPromise = requireAspromise();
+		util.asPromise = aspromise;
 
 		// converts to / from base64 encoded strings
-		util.base64 = requireBase64();
+		util.base64 = base64$1;
 
 		// base class of rpc.Service
-		util.EventEmitter = requireEventemitter();
+		util.EventEmitter = eventemitter;
 
 		// float handling accross browsers
-		util.float = requireFloat();
+		util.float = float;
 
 		// requires modules optionally and hides the call from bundlers
-		util.inquire = requireInquire();
+		util.inquire = inquire_1;
 
 		// converts to / from utf8 encoded strings
-		util.utf8 = requireUtf8();
+		util.utf8 = utf8$2;
 
 		// provides a node-like buffer pool in the browser
-		util.pool = requirePool();
+		util.pool = pool_1;
 
 		// utility to work with the low and high bits of a 64 bit value
 		util.LongBits = requireLongbits();
@@ -2760,288 +3426,311 @@ var roots = {};
 
 var util$2 = {exports: {}};
 
-var codegen_1 = codegen;
+var codegen_1;
+var hasRequiredCodegen;
+
+function requireCodegen () {
+	if (hasRequiredCodegen) return codegen_1;
+	hasRequiredCodegen = 1;
+	codegen_1 = codegen;
 
-/**
- * Begins generating a function.
- * @memberof util
- * @param {string[]} functionParams Function parameter names
- * @param {string} [functionName] Function name if not anonymous
- * @returns {Codegen} Appender that appends code to the function's body
- */
-function codegen(functionParams, functionName) {
+	/**
+	 * Begins generating a function.
+	 * @memberof util
+	 * @param {string[]} functionParams Function parameter names
+	 * @param {string} [functionName] Function name if not anonymous
+	 * @returns {Codegen} Appender that appends code to the function's body
+	 */
+	function codegen(functionParams, functionName) {
 
-    /* istanbul ignore if */
-    if (typeof functionParams === "string") {
-        functionName = functionParams;
-        functionParams = undefined;
-    }
+	    /* istanbul ignore if */
+	    if (typeof functionParams === "string") {
+	        functionName = functionParams;
+	        functionParams = undefined;
+	    }
 
-    var body = [];
+	    var body = [];
 
-    /**
-     * Appends code to the function's body or finishes generation.
-     * @typedef Codegen
-     * @type {function}
-     * @param {string|Object.<string,*>} [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
-     * @param {...*} [formatParams] Format parameters
-     * @returns {Codegen|Function} Itself or the generated function if finished
-     * @throws {Error} If format parameter counts do not match
-     */
+	    /**
+	     * Appends code to the function's body or finishes generation.
+	     * @typedef Codegen
+	     * @type {function}
+	     * @param {string|Object.<string,*>} [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
+	     * @param {...*} [formatParams] Format parameters
+	     * @returns {Codegen|Function} Itself or the generated function if finished
+	     * @throws {Error} If format parameter counts do not match
+	     */
 
-    function Codegen(formatStringOrScope) {
-        // note that explicit array handling below makes this ~50% faster
+	    function Codegen(formatStringOrScope) {
+	        // note that explicit array handling below makes this ~50% faster
 
-        // finish the function
-        if (typeof formatStringOrScope !== "string") {
-            var source = toString();
-            if (codegen.verbose)
-                console.log("codegen: " + source); // eslint-disable-line no-console
-            source = "return " + source;
-            if (formatStringOrScope) {
-                var scopeKeys   = Object.keys(formatStringOrScope),
-                    scopeParams = new Array(scopeKeys.length + 1),
-                    scopeValues = new Array(scopeKeys.length),
-                    scopeOffset = 0;
-                while (scopeOffset < scopeKeys.length) {
-                    scopeParams[scopeOffset] = scopeKeys[scopeOffset];
-                    scopeValues[scopeOffset] = formatStringOrScope[scopeKeys[scopeOffset++]];
-                }
-                scopeParams[scopeOffset] = source;
-                return Function.apply(null, scopeParams).apply(null, scopeValues); // eslint-disable-line no-new-func
-            }
-            return Function(source)(); // eslint-disable-line no-new-func
-        }
+	        // finish the function
+	        if (typeof formatStringOrScope !== "string") {
+	            var source = toString();
+	            if (codegen.verbose)
+	                console.log("codegen: " + source); // eslint-disable-line no-console
+	            source = "return " + source;
+	            if (formatStringOrScope) {
+	                var scopeKeys   = Object.keys(formatStringOrScope),
+	                    scopeParams = new Array(scopeKeys.length + 1),
+	                    scopeValues = new Array(scopeKeys.length),
+	                    scopeOffset = 0;
+	                while (scopeOffset < scopeKeys.length) {
+	                    scopeParams[scopeOffset] = scopeKeys[scopeOffset];
+	                    scopeValues[scopeOffset] = formatStringOrScope[scopeKeys[scopeOffset++]];
+	                }
+	                scopeParams[scopeOffset] = source;
+	                return Function.apply(null, scopeParams).apply(null, scopeValues); // eslint-disable-line no-new-func
+	            }
+	            return Function(source)(); // eslint-disable-line no-new-func
+	        }
 
-        // otherwise append to body
-        var formatParams = new Array(arguments.length - 1),
-            formatOffset = 0;
-        while (formatOffset < formatParams.length)
-            formatParams[formatOffset] = arguments[++formatOffset];
-        formatOffset = 0;
-        formatStringOrScope = formatStringOrScope.replace(/%([%dfijs])/g, function replace($0, $1) {
-            var value = formatParams[formatOffset++];
-            switch ($1) {
-                case "d": case "f": return String(Number(value));
-                case "i": return String(Math.floor(value));
-                case "j": return JSON.stringify(value);
-                case "s": return String(value);
-            }
-            return "%";
-        });
-        if (formatOffset !== formatParams.length)
-            throw Error("parameter count mismatch");
-        body.push(formatStringOrScope);
-        return Codegen;
-    }
+	        // otherwise append to body
+	        var formatParams = new Array(arguments.length - 1),
+	            formatOffset = 0;
+	        while (formatOffset < formatParams.length)
+	            formatParams[formatOffset] = arguments[++formatOffset];
+	        formatOffset = 0;
+	        formatStringOrScope = formatStringOrScope.replace(/%([%dfijs])/g, function replace($0, $1) {
+	            var value = formatParams[formatOffset++];
+	            switch ($1) {
+	                case "d": case "f": return String(Number(value));
+	                case "i": return String(Math.floor(value));
+	                case "j": return JSON.stringify(value);
+	                case "s": return String(value);
+	            }
+	            return "%";
+	        });
+	        if (formatOffset !== formatParams.length)
+	            throw Error("parameter count mismatch");
+	        body.push(formatStringOrScope);
+	        return Codegen;
+	    }
 
-    function toString(functionNameOverride) {
-        return "function " + (functionNameOverride || functionName || "") + "(" + (functionParams && functionParams.join(",") || "") + "){\n  " + body.join("\n  ") + "\n}";
-    }
+	    function toString(functionNameOverride) {
+	        return "function " + (functionNameOverride || functionName || "") + "(" + (functionParams && functionParams.join(",") || "") + "){\n  " + body.join("\n  ") + "\n}";
+	    }
 
-    Codegen.toString = toString;
-    return Codegen;
-}
+	    Codegen.toString = toString;
+	    return Codegen;
+	}
 
-/**
- * Begins generating a function.
- * @memberof util
- * @function codegen
- * @param {string} [functionName] Function name if not anonymous
- * @returns {Codegen} Appender that appends code to the function's body
- * @variation 2
- */
+	/**
+	 * Begins generating a function.
+	 * @memberof util
+	 * @function codegen
+	 * @param {string} [functionName] Function name if not anonymous
+	 * @returns {Codegen} Appender that appends code to the function's body
+	 * @variation 2
+	 */
 
-/**
- * When set to `true`, codegen will log generated code to console. Useful for debugging.
- * @name util.codegen.verbose
- * @type {boolean}
- */
-codegen.verbose = false;
+	/**
+	 * When set to `true`, codegen will log generated code to console. Useful for debugging.
+	 * @name util.codegen.verbose
+	 * @type {boolean}
+	 */
+	codegen.verbose = false;
+	return codegen_1;
+}
 
-var fetch_1 = fetch;
+var fetch_1;
+var hasRequiredFetch;
+
+function requireFetch () {
+	if (hasRequiredFetch) return fetch_1;
+	hasRequiredFetch = 1;
+	fetch_1 = fetch;
 
-var asPromise = requireAspromise(),
-    inquire   = requireInquire();
+	var asPromise = aspromise,
+	    inquire   = inquire_1;
 
-var fs = inquire("fs");
+	var fs = inquire("fs");
 
-/**
- * Node-style callback as used by {@link util.fetch}.
- * @typedef FetchCallback
- * @type {function}
- * @param {?Error} error Error, if any, otherwise `null`
- * @param {string} [contents] File contents, if there hasn't been an error
- * @returns {undefined}
- */
+	/**
+	 * Node-style callback as used by {@link util.fetch}.
+	 * @typedef FetchCallback
+	 * @type {function}
+	 * @param {?Error} error Error, if any, otherwise `null`
+	 * @param {string} [contents] File contents, if there hasn't been an error
+	 * @returns {undefined}
+	 */
 
-/**
- * Options as used by {@link util.fetch}.
- * @typedef FetchOptions
- * @type {Object}
- * @property {boolean} [binary=false] Whether expecting a binary response
- * @property {boolean} [xhr=false] If `true`, forces the use of XMLHttpRequest
- */
+	/**
+	 * Options as used by {@link util.fetch}.
+	 * @typedef FetchOptions
+	 * @type {Object}
+	 * @property {boolean} [binary=false] Whether expecting a binary response
+	 * @property {boolean} [xhr=false] If `true`, forces the use of XMLHttpRequest
+	 */
 
-/**
- * Fetches the contents of a file.
- * @memberof util
- * @param {string} filename File path or url
- * @param {FetchOptions} options Fetch options
- * @param {FetchCallback} callback Callback function
- * @returns {undefined}
- */
-function fetch(filename, options, callback) {
-    if (typeof options === "function") {
-        callback = options;
-        options = {};
-    } else if (!options)
-        options = {};
+	/**
+	 * Fetches the contents of a file.
+	 * @memberof util
+	 * @param {string} filename File path or url
+	 * @param {FetchOptions} options Fetch options
+	 * @param {FetchCallback} callback Callback function
+	 * @returns {undefined}
+	 */
+	function fetch(filename, options, callback) {
+	    if (typeof options === "function") {
+	        callback = options;
+	        options = {};
+	    } else if (!options)
+	        options = {};
 
-    if (!callback)
-        return asPromise(fetch, this, filename, options); // eslint-disable-line no-invalid-this
+	    if (!callback)
+	        return asPromise(fetch, this, filename, options); // eslint-disable-line no-invalid-this
 
-    // if a node-like filesystem is present, try it first but fall back to XHR if nothing is found.
-    if (!options.xhr && fs && fs.readFile)
-        return fs.readFile(filename, function fetchReadFileCallback(err, contents) {
-            return err && typeof XMLHttpRequest !== "undefined"
-                ? fetch.xhr(filename, options, callback)
-                : err
-                ? callback(err)
-                : callback(null, options.binary ? contents : contents.toString("utf8"));
-        });
+	    // if a node-like filesystem is present, try it first but fall back to XHR if nothing is found.
+	    if (!options.xhr && fs && fs.readFile)
+	        return fs.readFile(filename, function fetchReadFileCallback(err, contents) {
+	            return err && typeof XMLHttpRequest !== "undefined"
+	                ? fetch.xhr(filename, options, callback)
+	                : err
+	                ? callback(err)
+	                : callback(null, options.binary ? contents : contents.toString("utf8"));
+	        });
 
-    // use the XHR version otherwise.
-    return fetch.xhr(filename, options, callback);
-}
+	    // use the XHR version otherwise.
+	    return fetch.xhr(filename, options, callback);
+	}
 
-/**
- * Fetches the contents of a file.
- * @name util.fetch
- * @function
- * @param {string} path File path or url
- * @param {FetchCallback} callback Callback function
- * @returns {undefined}
- * @variation 2
- */
+	/**
+	 * Fetches the contents of a file.
+	 * @name util.fetch
+	 * @function
+	 * @param {string} path File path or url
+	 * @param {FetchCallback} callback Callback function
+	 * @returns {undefined}
+	 * @variation 2
+	 */
 
-/**
- * Fetches the contents of a file.
- * @name util.fetch
- * @function
- * @param {string} path File path or url
- * @param {FetchOptions} [options] Fetch options
- * @returns {Promise<string|Uint8Array>} Promise
- * @variation 3
- */
+	/**
+	 * Fetches the contents of a file.
+	 * @name util.fetch
+	 * @function
+	 * @param {string} path File path or url
+	 * @param {FetchOptions} [options] Fetch options
+	 * @returns {Promise<string|Uint8Array>} Promise
+	 * @variation 3
+	 */
 
-/**/
-fetch.xhr = function fetch_xhr(filename, options, callback) {
-    var xhr = new XMLHttpRequest();
-    xhr.onreadystatechange /* works everywhere */ = function fetchOnReadyStateChange() {
+	/**/
+	fetch.xhr = function fetch_xhr(filename, options, callback) {
+	    var xhr = new XMLHttpRequest();
+	    xhr.onreadystatechange /* works everywhere */ = function fetchOnReadyStateChange() {
 
-        if (xhr.readyState !== 4)
-            return undefined;
+	        if (xhr.readyState !== 4)
+	            return undefined;
 
-        // local cors security errors return status 0 / empty string, too. afaik this cannot be
-        // reliably distinguished from an actually empty file for security reasons. feel free
-        // to send a pull request if you are aware of a solution.
-        if (xhr.status !== 0 && xhr.status !== 200)
-            return callback(Error("status " + xhr.status));
+	        // local cors security errors return status 0 / empty string, too. afaik this cannot be
+	        // reliably distinguished from an actually empty file for security reasons. feel free
+	        // to send a pull request if you are aware of a solution.
+	        if (xhr.status !== 0 && xhr.status !== 200)
+	            return callback(Error("status " + xhr.status));
 
-        // if binary data is expected, make sure that some sort of array is returned, even if
-        // ArrayBuffers are not supported. the binary string fallback, however, is unsafe.
-        if (options.binary) {
-            var buffer = xhr.response;
-            if (!buffer) {
-                buffer = [];
-                for (var i = 0; i < xhr.responseText.length; ++i)
-                    buffer.push(xhr.responseText.charCodeAt(i) & 255);
-            }
-            return callback(null, typeof Uint8Array !== "undefined" ? new Uint8Array(buffer) : buffer);
-        }
-        return callback(null, xhr.responseText);
-    };
+	        // if binary data is expected, make sure that some sort of array is returned, even if
+	        // ArrayBuffers are not supported. the binary string fallback, however, is unsafe.
+	        if (options.binary) {
+	            var buffer = xhr.response;
+	            if (!buffer) {
+	                buffer = [];
+	                for (var i = 0; i < xhr.responseText.length; ++i)
+	                    buffer.push(xhr.responseText.charCodeAt(i) & 255);
+	            }
+	            return callback(null, typeof Uint8Array !== "undefined" ? new Uint8Array(buffer) : buffer);
+	        }
+	        return callback(null, xhr.responseText);
+	    };
 
-    if (options.binary) {
-        // ref: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Sending_and_Receiving_Binary_Data#Receiving_binary_data_in_older_browsers
-        if ("overrideMimeType" in xhr)
-            xhr.overrideMimeType("text/plain; charset=x-user-defined");
-        xhr.responseType = "arraybuffer";
-    }
+	    if (options.binary) {
+	        // ref: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Sending_and_Receiving_Binary_Data#Receiving_binary_data_in_older_browsers
+	        if ("overrideMimeType" in xhr)
+	            xhr.overrideMimeType("text/plain; charset=x-user-defined");
+	        xhr.responseType = "arraybuffer";
+	    }
 
-    xhr.open("GET", filename);
-    xhr.send();
-};
+	    xhr.open("GET", filename);
+	    xhr.send();
+	};
+	return fetch_1;
+}
 
 var path = {};
 
-(function (exports) {
+var hasRequiredPath;
+
+function requirePath () {
+	if (hasRequiredPath) return path;
+	hasRequiredPath = 1;
+	(function (exports) {
 
-	/**
-	 * A minimal path module to resolve Unix, Windows and URL paths alike.
-	 * @memberof util
-	 * @namespace
-	 */
-	var path = exports;
+		/**
+		 * A minimal path module to resolve Unix, Windows and URL paths alike.
+		 * @memberof util
+		 * @namespace
+		 */
+		var path = exports;
 
-	var isAbsolute =
-	/**
-	 * Tests if the specified path is absolute.
-	 * @param {string} path Path to test
-	 * @returns {boolean} `true` if path is absolute
-	 */
-	path.isAbsolute = function isAbsolute(path) {
-	    return /^(?:\/|\w+:)/.test(path);
-	};
+		var isAbsolute =
+		/**
+		 * Tests if the specified path is absolute.
+		 * @param {string} path Path to test
+		 * @returns {boolean} `true` if path is absolute
+		 */
+		path.isAbsolute = function isAbsolute(path) {
+		    return /^(?:\/|\w+:)/.test(path);
+		};
 
-	var normalize =
-	/**
-	 * Normalizes the specified path.
-	 * @param {string} path Path to normalize
-	 * @returns {string} Normalized path
-	 */
-	path.normalize = function normalize(path) {
-	    path = path.replace(/\\/g, "/")
-	               .replace(/\/{2,}/g, "/");
-	    var parts    = path.split("/"),
-	        absolute = isAbsolute(path),
-	        prefix   = "";
-	    if (absolute)
-	        prefix = parts.shift() + "/";
-	    for (var i = 0; i < parts.length;) {
-	        if (parts[i] === "..") {
-	            if (i > 0 && parts[i - 1] !== "..")
-	                parts.splice(--i, 2);
-	            else if (absolute)
-	                parts.splice(i, 1);
-	            else
-	                ++i;
-	        } else if (parts[i] === ".")
-	            parts.splice(i, 1);
-	        else
-	            ++i;
-	    }
-	    return prefix + parts.join("/");
-	};
+		var normalize =
+		/**
+		 * Normalizes the specified path.
+		 * @param {string} path Path to normalize
+		 * @returns {string} Normalized path
+		 */
+		path.normalize = function normalize(path) {
+		    path = path.replace(/\\/g, "/")
+		               .replace(/\/{2,}/g, "/");
+		    var parts    = path.split("/"),
+		        absolute = isAbsolute(path),
+		        prefix   = "";
+		    if (absolute)
+		        prefix = parts.shift() + "/";
+		    for (var i = 0; i < parts.length;) {
+		        if (parts[i] === "..") {
+		            if (i > 0 && parts[i - 1] !== "..")
+		                parts.splice(--i, 2);
+		            else if (absolute)
+		                parts.splice(i, 1);
+		            else
+		                ++i;
+		        } else if (parts[i] === ".")
+		            parts.splice(i, 1);
+		        else
+		            ++i;
+		    }
+		    return prefix + parts.join("/");
+		};
 
-	/**
-	 * Resolves the specified include path against the specified origin path.
-	 * @param {string} originPath Path to the origin file
-	 * @param {string} includePath Include path relative to origin path
-	 * @param {boolean} [alreadyNormalized=false] `true` if both paths are already known to be normalized
-	 * @returns {string} Path to the include file
-	 */
-	path.resolve = function resolve(originPath, includePath, alreadyNormalized) {
-	    if (!alreadyNormalized)
-	        includePath = normalize(includePath);
-	    if (isAbsolute(includePath))
-	        return includePath;
-	    if (!alreadyNormalized)
-	        originPath = normalize(originPath);
-	    return (originPath = originPath.replace(/(?:\/|^)[^/]+$/, "")).length ? normalize(originPath + "/" + includePath) : includePath;
-	};
+		/**
+		 * Resolves the specified include path against the specified origin path.
+		 * @param {string} originPath Path to the origin file
+		 * @param {string} includePath Include path relative to origin path
+		 * @param {boolean} [alreadyNormalized=false] `true` if both paths are already known to be normalized
+		 * @returns {string} Path to the include file
+		 */
+		path.resolve = function resolve(originPath, includePath, alreadyNormalized) {
+		    if (!alreadyNormalized)
+		        includePath = normalize(includePath);
+		    if (isAbsolute(includePath))
+		        return includePath;
+		    if (!alreadyNormalized)
+		        originPath = normalize(originPath);
+		    return (originPath = originPath.replace(/(?:\/|^)[^/]+$/, "")).length ? normalize(originPath + "/" + includePath) : includePath;
+		};
 } (path));
+	return path;
+}
 
 var types$1 = {};
 
@@ -4764,7 +5453,7 @@ function requireService () {
 	return service;
 }
 
-var message$1 = Message;
+var message$2 = Message;
 
 var util$1 = requireMinimal();
 
@@ -5546,7 +6235,7 @@ var wrappers = {};
 	 */
 	var wrappers = exports;
 
-	var Message = message$1;
+	var Message = message$2;
 
 	/**
 	 * From object converter part of an {@link IWrapper}.
@@ -5658,7 +6347,7 @@ function requireType () {
 	    Field     = requireField(),
 	    MapField  = requireMapfield(),
 	    Service   = requireService(),
-	    Message   = message$1,
+	    Message   = message$2,
 	    Reader    = reader,
 	    Writer    = writer,
 	    util      = requireUtil(),
@@ -6627,9 +7316,9 @@ function requireUtil () {
 		var Type, // cyclic
 		    Enum;
 
-		util.codegen = codegen_1;
-		util.fetch   = fetch_1;
-		util.path    = path;
+		util.codegen = requireCodegen();
+		util.fetch   = requireFetch();
+		util.path    = requirePath();
 
 		/**
 		 * Node's fs module if available.
@@ -7487,7 +8176,7 @@ function requireEncoder () {
 	protobuf.Method           = requireMethod();
 
 	// Runtime
-	protobuf.Message          = message$1;
+	protobuf.Message          = message$2;
 	protobuf.wrappers         = wrappers;
 
 	// Utility
@@ -9245,8 +9934,1891 @@ function createCodec(name, type, encode, decode) {
     };
 }
 
-function message(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.uint32();
+        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);
 }
 
-export { CODEC_TYPES as C, requireBase64 as a, requireEventemitter as b, requireFloat as c, requireInquire as d, requireUtf8 as e, requirePool as f, commonjsGlobal as g, getAugmentedNamespace as h, createCodec as i, encodeMessage as j, decodeMessage as k, message as m, requireAspromise as r };
+/* eslint-disable import/export */
+var RateLimitProof$3;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.proof != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.proof);
+                }
+                else {
+                    throw new Error('Protocol error: required field "proof" was not found in object');
+                }
+                if (obj.merkleRoot != null) {
+                    writer.uint32(18);
+                    writer.bytes(obj.merkleRoot);
+                }
+                else {
+                    throw new Error('Protocol error: required field "merkleRoot" was not found in object');
+                }
+                if (obj.epoch != null) {
+                    writer.uint32(26);
+                    writer.bytes(obj.epoch);
+                }
+                else {
+                    throw new Error('Protocol error: required field "epoch" was not found in object');
+                }
+                if (obj.shareX != null) {
+                    writer.uint32(34);
+                    writer.bytes(obj.shareX);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareX" was not found in object');
+                }
+                if (obj.shareY != null) {
+                    writer.uint32(42);
+                    writer.bytes(obj.shareY);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareY" was not found in object');
+                }
+                if (obj.nullifier != null) {
+                    writer.uint32(50);
+                    writer.bytes(obj.nullifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "nullifier" was not found in object');
+                }
+                if (obj.rlnIdentifier != null) {
+                    writer.uint32(58);
+                    writer.bytes(obj.rlnIdentifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "rlnIdentifier" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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;
+                    }
+                }
+                if (obj.proof == null) {
+                    throw new Error('Protocol error: value for required field "proof" was not found in protobuf');
+                }
+                if (obj.merkleRoot == null) {
+                    throw new Error('Protocol error: value for required field "merkleRoot" was not found in protobuf');
+                }
+                if (obj.epoch == null) {
+                    throw new Error('Protocol error: value for required field "epoch" was not found in protobuf');
+                }
+                if (obj.shareX == null) {
+                    throw new Error('Protocol error: value for required field "shareX" was not found in protobuf');
+                }
+                if (obj.shareY == null) {
+                    throw new Error('Protocol error: value for required field "shareY" was not found in protobuf');
+                }
+                if (obj.nullifier == null) {
+                    throw new Error('Protocol error: value for required field "nullifier" was not found in protobuf');
+                }
+                if (obj.rlnIdentifier == null) {
+                    throw new Error('Protocol error: value for required field "rlnIdentifier" was not found in protobuf');
+                }
+                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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.payload != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.payload);
+                }
+                if (obj.contentTopic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    writer.uint32(24);
+                    writer.uint32(obj.version);
+                }
+                if (obj.timestampDeprecated != null) {
+                    writer.uint32(33);
+                    writer.double(obj.timestampDeprecated);
+                }
+                if (obj.timestamp != null) {
+                    writer.uint32(80);
+                    writer.sint64(obj.timestamp);
+                }
+                if (obj.rateLimitProof != null) {
+                    writer.uint32(170);
+                    RateLimitProof$3.codec().encode(obj.rateLimitProof, writer);
+                }
+                if (obj.ephemeral != null) {
+                    writer.uint32(248);
+                    writer.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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.payload = reader.bytes();
+                            break;
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.version = reader.uint32();
+                            break;
+                        case 4:
+                            obj.timestampDeprecated = reader.double();
+                            break;
+                        case 10:
+                            obj.timestamp = reader.sint64();
+                            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, writer, opts = {}) => {
+                    if (opts.lengthDelimited !== false) {
+                        writer.fork();
+                    }
+                    if (obj.contentTopic != null) {
+                        writer.uint32(10);
+                        writer.string(obj.contentTopic);
+                    }
+                    if (opts.lengthDelimited !== false) {
+                        writer.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.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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.subscribe != null) {
+                    writer.uint32(8);
+                    writer.bool(obj.subscribe);
+                }
+                if (obj.topic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.topic);
+                }
+                if (obj.contentFilters != null) {
+                    for (const value of obj.contentFilters) {
+                        writer.uint32(26);
+                        FilterRequest.ContentFilter.codec().encode(value, writer);
+                    }
+                }
+                else {
+                    throw new Error('Protocol error: required field "contentFilters" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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 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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.messages != null) {
+                    for (const value of obj.messages) {
+                        writer.uint32(10);
+                        WakuMessage$2.codec().encode(value, writer);
+                    }
+                }
+                else {
+                    throw new Error('Protocol error: required field "messages" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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;
+(function (FilterRPC) {
+    let _codec;
+    FilterRPC.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.requestId != null) {
+                    writer.uint32(10);
+                    writer.string(obj.requestId);
+                }
+                if (obj.request != null) {
+                    writer.uint32(18);
+                    FilterRequest.codec().encode(obj.request, writer);
+                }
+                if (obj.push != null) {
+                    writer.uint32(26);
+                    MessagePush.codec().encode(obj.push, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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.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 || (FilterRPC = {}));
+var RateLimitProof$2;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.proof != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.proof);
+                }
+                else {
+                    throw new Error('Protocol error: required field "proof" was not found in object');
+                }
+                if (obj.merkleRoot != null) {
+                    writer.uint32(18);
+                    writer.bytes(obj.merkleRoot);
+                }
+                else {
+                    throw new Error('Protocol error: required field "merkleRoot" was not found in object');
+                }
+                if (obj.epoch != null) {
+                    writer.uint32(26);
+                    writer.bytes(obj.epoch);
+                }
+                else {
+                    throw new Error('Protocol error: required field "epoch" was not found in object');
+                }
+                if (obj.shareX != null) {
+                    writer.uint32(34);
+                    writer.bytes(obj.shareX);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareX" was not found in object');
+                }
+                if (obj.shareY != null) {
+                    writer.uint32(42);
+                    writer.bytes(obj.shareY);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareY" was not found in object');
+                }
+                if (obj.nullifier != null) {
+                    writer.uint32(50);
+                    writer.bytes(obj.nullifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "nullifier" was not found in object');
+                }
+                if (obj.rlnIdentifier != null) {
+                    writer.uint32(58);
+                    writer.bytes(obj.rlnIdentifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "rlnIdentifier" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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;
+                    }
+                }
+                if (obj.proof == null) {
+                    throw new Error('Protocol error: value for required field "proof" was not found in protobuf');
+                }
+                if (obj.merkleRoot == null) {
+                    throw new Error('Protocol error: value for required field "merkleRoot" was not found in protobuf');
+                }
+                if (obj.epoch == null) {
+                    throw new Error('Protocol error: value for required field "epoch" was not found in protobuf');
+                }
+                if (obj.shareX == null) {
+                    throw new Error('Protocol error: value for required field "shareX" was not found in protobuf');
+                }
+                if (obj.shareY == null) {
+                    throw new Error('Protocol error: value for required field "shareY" was not found in protobuf');
+                }
+                if (obj.nullifier == null) {
+                    throw new Error('Protocol error: value for required field "nullifier" was not found in protobuf');
+                }
+                if (obj.rlnIdentifier == null) {
+                    throw new Error('Protocol error: value for required field "rlnIdentifier" was not found in protobuf');
+                }
+                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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.payload != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.payload);
+                }
+                if (obj.contentTopic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    writer.uint32(24);
+                    writer.uint32(obj.version);
+                }
+                if (obj.timestampDeprecated != null) {
+                    writer.uint32(33);
+                    writer.double(obj.timestampDeprecated);
+                }
+                if (obj.timestamp != null) {
+                    writer.uint32(80);
+                    writer.sint64(obj.timestamp);
+                }
+                if (obj.rateLimitProof != null) {
+                    writer.uint32(170);
+                    RateLimitProof$2.codec().encode(obj.rateLimitProof, writer);
+                }
+                if (obj.ephemeral != null) {
+                    writer.uint32(248);
+                    writer.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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.payload = reader.bytes();
+                            break;
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.version = reader.uint32();
+                            break;
+                        case 4:
+                            obj.timestampDeprecated = reader.double();
+                            break;
+                        case 10:
+                            obj.timestamp = reader.sint64();
+                            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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.contentTopic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.contentTopic);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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 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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.pubSubTopic != null) {
+                    writer.uint32(10);
+                    writer.string(obj.pubSubTopic);
+                }
+                if (obj.message != null) {
+                    writer.uint32(18);
+                    WakuMessage$1.codec().encode(obj.message, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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.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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.isSuccess != null) {
+                    writer.uint32(8);
+                    writer.bool(obj.isSuccess);
+                }
+                if (obj.info != null) {
+                    writer.uint32(18);
+                    writer.string(obj.info);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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.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;
+(function (PushRPC) {
+    let _codec;
+    PushRPC.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.requestId != null) {
+                    writer.uint32(10);
+                    writer.string(obj.requestId);
+                }
+                if (obj.request != null) {
+                    writer.uint32(18);
+                    PushRequest.codec().encode(obj.request, writer);
+                }
+                if (obj.response != null) {
+                    writer.uint32(26);
+                    PushResponse.codec().encode(obj.response, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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.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 || (PushRPC = {}));
+var RateLimitProof$1;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.proof != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.proof);
+                }
+                else {
+                    throw new Error('Protocol error: required field "proof" was not found in object');
+                }
+                if (obj.merkleRoot != null) {
+                    writer.uint32(18);
+                    writer.bytes(obj.merkleRoot);
+                }
+                else {
+                    throw new Error('Protocol error: required field "merkleRoot" was not found in object');
+                }
+                if (obj.epoch != null) {
+                    writer.uint32(26);
+                    writer.bytes(obj.epoch);
+                }
+                else {
+                    throw new Error('Protocol error: required field "epoch" was not found in object');
+                }
+                if (obj.shareX != null) {
+                    writer.uint32(34);
+                    writer.bytes(obj.shareX);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareX" was not found in object');
+                }
+                if (obj.shareY != null) {
+                    writer.uint32(42);
+                    writer.bytes(obj.shareY);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareY" was not found in object');
+                }
+                if (obj.nullifier != null) {
+                    writer.uint32(50);
+                    writer.bytes(obj.nullifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "nullifier" was not found in object');
+                }
+                if (obj.rlnIdentifier != null) {
+                    writer.uint32(58);
+                    writer.bytes(obj.rlnIdentifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "rlnIdentifier" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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;
+                    }
+                }
+                if (obj.proof == null) {
+                    throw new Error('Protocol error: value for required field "proof" was not found in protobuf');
+                }
+                if (obj.merkleRoot == null) {
+                    throw new Error('Protocol error: value for required field "merkleRoot" was not found in protobuf');
+                }
+                if (obj.epoch == null) {
+                    throw new Error('Protocol error: value for required field "epoch" was not found in protobuf');
+                }
+                if (obj.shareX == null) {
+                    throw new Error('Protocol error: value for required field "shareX" was not found in protobuf');
+                }
+                if (obj.shareY == null) {
+                    throw new Error('Protocol error: value for required field "shareY" was not found in protobuf');
+                }
+                if (obj.nullifier == null) {
+                    throw new Error('Protocol error: value for required field "nullifier" was not found in protobuf');
+                }
+                if (obj.rlnIdentifier == null) {
+                    throw new Error('Protocol error: value for required field "rlnIdentifier" was not found in protobuf');
+                }
+                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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.payload != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.payload);
+                }
+                if (obj.contentTopic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    writer.uint32(24);
+                    writer.uint32(obj.version);
+                }
+                if (obj.timestampDeprecated != null) {
+                    writer.uint32(33);
+                    writer.double(obj.timestampDeprecated);
+                }
+                if (obj.timestamp != null) {
+                    writer.uint32(80);
+                    writer.sint64(obj.timestamp);
+                }
+                if (obj.rateLimitProof != null) {
+                    writer.uint32(170);
+                    RateLimitProof$1.codec().encode(obj.rateLimitProof, writer);
+                }
+                if (obj.ephemeral != null) {
+                    writer.uint32(248);
+                    writer.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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.payload = reader.bytes();
+                            break;
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.version = reader.uint32();
+                            break;
+                        case 4:
+                            obj.timestampDeprecated = reader.double();
+                            break;
+                        case 10:
+                            obj.timestamp = reader.sint64();
+                            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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.digest != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.digest);
+                }
+                if (obj.receivedTime != null) {
+                    writer.uint32(16);
+                    writer.sint64(obj.receivedTime);
+                }
+                if (obj.senderTime != null) {
+                    writer.uint32(24);
+                    writer.sint64(obj.senderTime);
+                }
+                if (obj.pubsubTopic != null) {
+                    writer.uint32(34);
+                    writer.string(obj.pubsubTopic);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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.digest = reader.bytes();
+                            break;
+                        case 2:
+                            obj.receivedTime = 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["DIRECTION_BACKWARD_UNSPECIFIED"] = "DIRECTION_BACKWARD_UNSPECIFIED";
+        Direction["DIRECTION_FORWARD"] = "DIRECTION_FORWARD";
+    })(PagingInfo.Direction || (PagingInfo.Direction = {}));
+    let __DirectionValues;
+    (function (__DirectionValues) {
+        __DirectionValues[__DirectionValues["DIRECTION_BACKWARD_UNSPECIFIED"] = 0] = "DIRECTION_BACKWARD_UNSPECIFIED";
+        __DirectionValues[__DirectionValues["DIRECTION_FORWARD"] = 1] = "DIRECTION_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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.pageSize != null) {
+                    writer.uint32(8);
+                    writer.uint64(obj.pageSize);
+                }
+                if (obj.cursor != null) {
+                    writer.uint32(18);
+                    Index.codec().encode(obj.cursor, writer);
+                }
+                if (obj.direction != null) {
+                    writer.uint32(24);
+                    PagingInfo.Direction.codec().encode(obj.direction, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.contentTopic != null) {
+                    writer.uint32(10);
+                    writer.string(obj.contentTopic);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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.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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.pubSubTopic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.pubSubTopic);
+                }
+                if (obj.contentFilters != null) {
+                    for (const value of obj.contentFilters) {
+                        writer.uint32(26);
+                        ContentFilter.codec().encode(value, writer);
+                    }
+                }
+                else {
+                    throw new Error('Protocol error: required field "contentFilters" was not found in object');
+                }
+                if (obj.pagingInfo != null) {
+                    writer.uint32(34);
+                    PagingInfo.codec().encode(obj.pagingInfo, writer);
+                }
+                if (obj.startTime != null) {
+                    writer.uint32(40);
+                    writer.sint64(obj.startTime);
+                }
+                if (obj.endTime != null) {
+                    writer.uint32(48);
+                    writer.sint64(obj.endTime);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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) {
+    (function (HistoryError) {
+        HistoryError["ERROR_NONE_UNSPECIFIED"] = "ERROR_NONE_UNSPECIFIED";
+        HistoryError["ERROR_INVALID_CURSOR"] = "ERROR_INVALID_CURSOR";
+    })(HistoryResponse.HistoryError || (HistoryResponse.HistoryError = {}));
+    let __HistoryErrorValues;
+    (function (__HistoryErrorValues) {
+        __HistoryErrorValues[__HistoryErrorValues["ERROR_NONE_UNSPECIFIED"] = 0] = "ERROR_NONE_UNSPECIFIED";
+        __HistoryErrorValues[__HistoryErrorValues["ERROR_INVALID_CURSOR"] = 1] = "ERROR_INVALID_CURSOR";
+    })(__HistoryErrorValues || (__HistoryErrorValues = {}));
+    (function (HistoryError) {
+        HistoryError.codec = () => {
+            return enumeration(__HistoryErrorValues);
+        };
+    })(HistoryResponse.HistoryError || (HistoryResponse.HistoryError = {}));
+    let _codec;
+    HistoryResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.messages != null) {
+                    for (const value of obj.messages) {
+                        writer.uint32(18);
+                        WakuMessage.codec().encode(value, writer);
+                    }
+                }
+                else {
+                    throw new Error('Protocol error: required field "messages" was not found in object');
+                }
+                if (obj.pagingInfo != null) {
+                    writer.uint32(26);
+                    PagingInfo.codec().encode(obj.pagingInfo, writer);
+                }
+                if (obj.error != null) {
+                    writer.uint32(32);
+                    HistoryResponse.HistoryError.codec().encode(obj.error, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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 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;
+(function (HistoryRPC) {
+    let _codec;
+    HistoryRPC.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.requestId != null) {
+                    writer.uint32(10);
+                    writer.string(obj.requestId);
+                }
+                if (obj.query != null) {
+                    writer.uint32(18);
+                    HistoryQuery.codec().encode(obj.query, writer);
+                }
+                if (obj.response != null) {
+                    writer.uint32(26);
+                    HistoryResponse.codec().encode(obj.response, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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.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 || (HistoryRPC = {}));
+var RateLimitProof;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.proof != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.proof);
+                }
+                else {
+                    throw new Error('Protocol error: required field "proof" was not found in object');
+                }
+                if (obj.merkleRoot != null) {
+                    writer.uint32(18);
+                    writer.bytes(obj.merkleRoot);
+                }
+                else {
+                    throw new Error('Protocol error: required field "merkleRoot" was not found in object');
+                }
+                if (obj.epoch != null) {
+                    writer.uint32(26);
+                    writer.bytes(obj.epoch);
+                }
+                else {
+                    throw new Error('Protocol error: required field "epoch" was not found in object');
+                }
+                if (obj.shareX != null) {
+                    writer.uint32(34);
+                    writer.bytes(obj.shareX);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareX" was not found in object');
+                }
+                if (obj.shareY != null) {
+                    writer.uint32(42);
+                    writer.bytes(obj.shareY);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareY" was not found in object');
+                }
+                if (obj.nullifier != null) {
+                    writer.uint32(50);
+                    writer.bytes(obj.nullifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "nullifier" was not found in object');
+                }
+                if (obj.rlnIdentifier != null) {
+                    writer.uint32(58);
+                    writer.bytes(obj.rlnIdentifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "rlnIdentifier" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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;
+                    }
+                }
+                if (obj.proof == null) {
+                    throw new Error('Protocol error: value for required field "proof" was not found in protobuf');
+                }
+                if (obj.merkleRoot == null) {
+                    throw new Error('Protocol error: value for required field "merkleRoot" was not found in protobuf');
+                }
+                if (obj.epoch == null) {
+                    throw new Error('Protocol error: value for required field "epoch" was not found in protobuf');
+                }
+                if (obj.shareX == null) {
+                    throw new Error('Protocol error: value for required field "shareX" was not found in protobuf');
+                }
+                if (obj.shareY == null) {
+                    throw new Error('Protocol error: value for required field "shareY" was not found in protobuf');
+                }
+                if (obj.nullifier == null) {
+                    throw new Error('Protocol error: value for required field "nullifier" was not found in protobuf');
+                }
+                if (obj.rlnIdentifier == null) {
+                    throw new Error('Protocol error: value for required field "rlnIdentifier" was not found in protobuf');
+                }
+                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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.payload != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.payload);
+                }
+                if (obj.contentTopic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    writer.uint32(24);
+                    writer.uint32(obj.version);
+                }
+                if (obj.timestampDeprecated != null) {
+                    writer.uint32(33);
+                    writer.double(obj.timestampDeprecated);
+                }
+                if (obj.timestamp != null) {
+                    writer.uint32(80);
+                    writer.sint64(obj.timestamp);
+                }
+                if (obj.rateLimitProof != null) {
+                    writer.uint32(170);
+                    RateLimitProof.codec().encode(obj.rateLimitProof, writer);
+                }
+                if (obj.ephemeral != null) {
+                    writer.uint32(248);
+                    writer.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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.payload = reader.bytes();
+                            break;
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.version = reader.uint32();
+                            break;
+                        case 4:
+                            obj.timestampDeprecated = reader.double();
+                            break;
+                        case 10:
+                            obj.timestamp = reader.sint64();
+                            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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.enr != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.enr);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.numPeers != null) {
+                    writer.uint32(8);
+                    writer.uint64(obj.numPeers);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.peerInfos != null) {
+                    for (const value of obj.peerInfos) {
+                        writer.uint32(10);
+                        PeerInfo.codec().encode(value, writer);
+                    }
+                }
+                else {
+                    throw new Error('Protocol error: required field "peerInfos" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.query != null) {
+                    writer.uint32(10);
+                    PeerExchangeQuery.codec().encode(obj.query, writer);
+                }
+                if (obj.response != null) {
+                    writer.uint32(18);
+                    PeerExchangeResponse.codec().encode(obj.response, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.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 as F, HistoryRPC as H, PushRPC as P, TopicOnlyMessage as T, WakuMessage$3 as W, aspromise as a, base64$1 as b, commonjsGlobal as c, debug as d, eventemitter as e, float as f, getAugmentedNamespace as g, PushResponse as h, inquire_1 as i, PagingInfo as j, HistoryResponse as k, getDefaultExportFromCjs as l, message as m, pool_1 as p, utf8$2 as u };