@waku/core 0.0.1 → 0.0.3

package/bundle/index-ba42b4fc.js

@@ -1,862 +0,0 @@
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-function getAugmentedNamespace(n) {
-  var f = n.default;
-	if (typeof f == "function") {
-		var a = function () {
-			return f.apply(this, arguments);
-		};
-		a.prototype = f.prototype;
-  } else a = {};
-  Object.defineProperty(a, '__esModule', {value: true});
-	Object.keys(n).forEach(function (k) {
-		var d = Object.getOwnPropertyDescriptor(n, k);
-		Object.defineProperty(a, k, d.get ? d : {
-			enumerable: true,
-			get: function () {
-				return n[k];
-			}
-		});
-	});
-	return a;
-}
-
-var aspromise;
-var hasRequiredAspromise;
-
-function requireAspromise () {
-	if (hasRequiredAspromise) return aspromise;
-	hasRequiredAspromise = 1;
-	aspromise = asPromise;
-
-	/**
-	 * Callback as used by {@link util.asPromise}.
-	 * @typedef asPromiseCallback
-	 * @type {function}
-	 * @param {Error|null} error Error, if any
-	 * @param {...*} params Additional arguments
-	 * @returns {undefined}
-	 */
-
-	/**
-	 * Returns a promise from a node-style callback function.
-	 * @memberof util
-	 * @param {asPromiseCallback} fn Function to call
-	 * @param {*} ctx Function context
-	 * @param {...*} params Function arguments
-	 * @returns {Promise<*>} Promisified function
-	 */
-	function asPromise(fn, ctx/*, varargs */) {
-	    var params  = new Array(arguments.length - 1),
-	        offset  = 0,
-	        index   = 2,
-	        pending = true;
-	    while (index < arguments.length)
-	        params[offset++] = arguments[index++];
-	    return new Promise(function executor(resolve, reject) {
-	        params[offset] = function callback(err/*, varargs */) {
-	            if (pending) {
-	                pending = false;
-	                if (err)
-	                    reject(err);
-	                else {
-	                    var params = new Array(arguments.length - 1),
-	                        offset = 0;
-	                    while (offset < params.length)
-	                        params[offset++] = arguments[offset];
-	                    resolve.apply(null, params);
-	                }
-	            }
-	        };
-	        try {
-	            fn.apply(ctx || null, params);
-	        } catch (err) {
-	            if (pending) {
-	                pending = false;
-	                reject(err);
-	            }
-	        }
-	    });
-	}
-	return aspromise;
-}
-
-var base64 = {};
-
-var hasRequiredBase64;
-
-function requireBase64 () {
-	if (hasRequiredBase64) return base64;
-	hasRequiredBase64 = 1;
-	(function (exports) {
-
-		/**
-		 * A minimal base64 implementation for number arrays.
-		 * @memberof util
-		 * @namespace
-		 */
-		var base64 = exports;
-
-		/**
-		 * Calculates the byte length of a base64 encoded string.
-		 * @param {string} string Base64 encoded string
-		 * @returns {number} Byte length
-		 */
-		base64.length = function length(string) {
-		    var p = string.length;
-		    if (!p)
-		        return 0;
-		    var n = 0;
-		    while (--p % 4 > 1 && string.charAt(p) === "=")
-		        ++n;
-		    return Math.ceil(string.length * 3) / 4 - n;
-		};
-
-		// Base64 encoding table
-		var b64 = new Array(64);
-
-		// Base64 decoding table
-		var s64 = new Array(123);
-
-		// 65..90, 97..122, 48..57, 43, 47
-		for (var i = 0; i < 64;)
-		    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
-
-		/**
-		 * Encodes a buffer to a base64 encoded string.
-		 * @param {Uint8Array} buffer Source buffer
-		 * @param {number} start Source start
-		 * @param {number} end Source end
-		 * @returns {string} Base64 encoded string
-		 */
-		base64.encode = function encode(buffer, start, end) {
-		    var parts = null,
-		        chunk = [];
-		    var i = 0, // output index
-		        j = 0, // goto index
-		        t;     // temporary
-		    while (start < end) {
-		        var b = buffer[start++];
-		        switch (j) {
-		            case 0:
-		                chunk[i++] = b64[b >> 2];
-		                t = (b & 3) << 4;
-		                j = 1;
-		                break;
-		            case 1:
-		                chunk[i++] = b64[t | b >> 4];
-		                t = (b & 15) << 2;
-		                j = 2;
-		                break;
-		            case 2:
-		                chunk[i++] = b64[t | b >> 6];
-		                chunk[i++] = b64[b & 63];
-		                j = 0;
-		                break;
-		        }
-		        if (i > 8191) {
-		            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
-		            i = 0;
-		        }
-		    }
-		    if (j) {
-		        chunk[i++] = b64[t];
-		        chunk[i++] = 61;
-		        if (j === 1)
-		            chunk[i++] = 61;
-		    }
-		    if (parts) {
-		        if (i)
-		            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
-		        return parts.join("");
-		    }
-		    return String.fromCharCode.apply(String, chunk.slice(0, i));
-		};
-
-		var invalidEncoding = "invalid encoding";
-
-		/**
-		 * Decodes a base64 encoded string to a buffer.
-		 * @param {string} string Source string
-		 * @param {Uint8Array} buffer Destination buffer
-		 * @param {number} offset Destination offset
-		 * @returns {number} Number of bytes written
-		 * @throws {Error} If encoding is invalid
-		 */
-		base64.decode = function decode(string, buffer, offset) {
-		    var start = offset;
-		    var j = 0, // goto index
-		        t;     // temporary
-		    for (var i = 0; i < string.length;) {
-		        var c = string.charCodeAt(i++);
-		        if (c === 61 && j > 1)
-		            break;
-		        if ((c = s64[c]) === undefined)
-		            throw Error(invalidEncoding);
-		        switch (j) {
-		            case 0:
-		                t = c;
-		                j = 1;
-		                break;
-		            case 1:
-		                buffer[offset++] = t << 2 | (c & 48) >> 4;
-		                t = c;
-		                j = 2;
-		                break;
-		            case 2:
-		                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
-		                t = c;
-		                j = 3;
-		                break;
-		            case 3:
-		                buffer[offset++] = (t & 3) << 6 | c;
-		                j = 0;
-		                break;
-		        }
-		    }
-		    if (j === 1)
-		        throw Error(invalidEncoding);
-		    return offset - start;
-		};
-
-		/**
-		 * Tests if the specified string appears to be base64 encoded.
-		 * @param {string} string String to test
-		 * @returns {boolean} `true` if probably base64 encoded, otherwise false
-		 */
-		base64.test = function test(string) {
-		    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
-		};
-} (base64));
-	return base64;
-}
-
-var eventemitter;
-var hasRequiredEventemitter;
-
-function requireEventemitter () {
-	if (hasRequiredEventemitter) return eventemitter;
-	hasRequiredEventemitter = 1;
-	eventemitter = EventEmitter;
-
-	/**
-	 * Constructs a new event emitter instance.
-	 * @classdesc A minimal event emitter.
-	 * @memberof util
-	 * @constructor
-	 */
-	function EventEmitter() {
-
-	    /**
-	     * Registered listeners.
-	     * @type {Object.<string,*>}
-	     * @private
-	     */
-	    this._listeners = {};
-	}
-
-	/**
-	 * Registers an event listener.
-	 * @param {string} evt Event name
-	 * @param {function} fn Listener
-	 * @param {*} [ctx] Listener context
-	 * @returns {util.EventEmitter} `this`
-	 */
-	EventEmitter.prototype.on = function on(evt, fn, ctx) {
-	    (this._listeners[evt] || (this._listeners[evt] = [])).push({
-	        fn  : fn,
-	        ctx : ctx || this
-	    });
-	    return this;
-	};
-
-	/**
-	 * Removes an event listener or any matching listeners if arguments are omitted.
-	 * @param {string} [evt] Event name. Removes all listeners if omitted.
-	 * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
-	 * @returns {util.EventEmitter} `this`
-	 */
-	EventEmitter.prototype.off = function off(evt, fn) {
-	    if (evt === undefined)
-	        this._listeners = {};
-	    else {
-	        if (fn === undefined)
-	            this._listeners[evt] = [];
-	        else {
-	            var listeners = this._listeners[evt];
-	            for (var i = 0; i < listeners.length;)
-	                if (listeners[i].fn === fn)
-	                    listeners.splice(i, 1);
-	                else
-	                    ++i;
-	        }
-	    }
-	    return this;
-	};
-
-	/**
-	 * Emits an event by calling its listeners with the specified arguments.
-	 * @param {string} evt Event name
-	 * @param {...*} args Arguments
-	 * @returns {util.EventEmitter} `this`
-	 */
-	EventEmitter.prototype.emit = function emit(evt) {
-	    var listeners = this._listeners[evt];
-	    if (listeners) {
-	        var args = [],
-	            i = 1;
-	        for (; i < arguments.length;)
-	            args.push(arguments[i++]);
-	        for (i = 0; i < listeners.length;)
-	            listeners[i].fn.apply(listeners[i++].ctx, args);
-	    }
-	    return this;
-	};
-	return eventemitter;
-}
-
-var float;
-var hasRequiredFloat;
-
-function requireFloat () {
-	if (hasRequiredFloat) return float;
-	hasRequiredFloat = 1;
-
-	float = factory(factory);
-
-	/**
-	 * Reads / writes floats / doubles from / to buffers.
-	 * @name util.float
-	 * @namespace
-	 */
-
-	/**
-	 * Writes a 32 bit float to a buffer using little endian byte order.
-	 * @name util.float.writeFloatLE
-	 * @function
-	 * @param {number} val Value to write
-	 * @param {Uint8Array} buf Target buffer
-	 * @param {number} pos Target buffer offset
-	 * @returns {undefined}
-	 */
-
-	/**
-	 * Writes a 32 bit float to a buffer using big endian byte order.
-	 * @name util.float.writeFloatBE
-	 * @function
-	 * @param {number} val Value to write
-	 * @param {Uint8Array} buf Target buffer
-	 * @param {number} pos Target buffer offset
-	 * @returns {undefined}
-	 */
-
-	/**
-	 * Reads a 32 bit float from a buffer using little endian byte order.
-	 * @name util.float.readFloatLE
-	 * @function
-	 * @param {Uint8Array} buf Source buffer
-	 * @param {number} pos Source buffer offset
-	 * @returns {number} Value read
-	 */
-
-	/**
-	 * Reads a 32 bit float from a buffer using big endian byte order.
-	 * @name util.float.readFloatBE
-	 * @function
-	 * @param {Uint8Array} buf Source buffer
-	 * @param {number} pos Source buffer offset
-	 * @returns {number} Value read
-	 */
-
-	/**
-	 * Writes a 64 bit double to a buffer using little endian byte order.
-	 * @name util.float.writeDoubleLE
-	 * @function
-	 * @param {number} val Value to write
-	 * @param {Uint8Array} buf Target buffer
-	 * @param {number} pos Target buffer offset
-	 * @returns {undefined}
-	 */
-
-	/**
-	 * Writes a 64 bit double to a buffer using big endian byte order.
-	 * @name util.float.writeDoubleBE
-	 * @function
-	 * @param {number} val Value to write
-	 * @param {Uint8Array} buf Target buffer
-	 * @param {number} pos Target buffer offset
-	 * @returns {undefined}
-	 */
-
-	/**
-	 * Reads a 64 bit double from a buffer using little endian byte order.
-	 * @name util.float.readDoubleLE
-	 * @function
-	 * @param {Uint8Array} buf Source buffer
-	 * @param {number} pos Source buffer offset
-	 * @returns {number} Value read
-	 */
-
-	/**
-	 * Reads a 64 bit double from a buffer using big endian byte order.
-	 * @name util.float.readDoubleBE
-	 * @function
-	 * @param {Uint8Array} buf Source buffer
-	 * @param {number} pos Source buffer offset
-	 * @returns {number} Value read
-	 */
-
-	// Factory function for the purpose of node-based testing in modified global environments
-	function factory(exports) {
-
-	    // float: typed array
-	    if (typeof Float32Array !== "undefined") (function() {
-
-	        var f32 = new Float32Array([ -0 ]),
-	            f8b = new Uint8Array(f32.buffer),
-	            le  = f8b[3] === 128;
-
-	        function writeFloat_f32_cpy(val, buf, pos) {
-	            f32[0] = val;
-	            buf[pos    ] = f8b[0];
-	            buf[pos + 1] = f8b[1];
-	            buf[pos + 2] = f8b[2];
-	            buf[pos + 3] = f8b[3];
-	        }
-
-	        function writeFloat_f32_rev(val, buf, pos) {
-	            f32[0] = val;
-	            buf[pos    ] = f8b[3];
-	            buf[pos + 1] = f8b[2];
-	            buf[pos + 2] = f8b[1];
-	            buf[pos + 3] = f8b[0];
-	        }
-
-	        /* istanbul ignore next */
-	        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
-	        /* istanbul ignore next */
-	        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
-
-	        function readFloat_f32_cpy(buf, pos) {
-	            f8b[0] = buf[pos    ];
-	            f8b[1] = buf[pos + 1];
-	            f8b[2] = buf[pos + 2];
-	            f8b[3] = buf[pos + 3];
-	            return f32[0];
-	        }
-
-	        function readFloat_f32_rev(buf, pos) {
-	            f8b[3] = buf[pos    ];
-	            f8b[2] = buf[pos + 1];
-	            f8b[1] = buf[pos + 2];
-	            f8b[0] = buf[pos + 3];
-	            return f32[0];
-	        }
-
-	        /* istanbul ignore next */
-	        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
-	        /* istanbul ignore next */
-	        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
-
-	    // float: ieee754
-	    })(); else (function() {
-
-	        function writeFloat_ieee754(writeUint, val, buf, pos) {
-	            var sign = val < 0 ? 1 : 0;
-	            if (sign)
-	                val = -val;
-	            if (val === 0)
-	                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);
-	            else if (isNaN(val))
-	                writeUint(2143289344, buf, pos);
-	            else if (val > 3.4028234663852886e+38) // +-Infinity
-	                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
-	            else if (val < 1.1754943508222875e-38) // denormal
-	                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);
-	            else {
-	                var exponent = Math.floor(Math.log(val) / Math.LN2),
-	                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
-	                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
-	            }
-	        }
-
-	        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
-	        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
-
-	        function readFloat_ieee754(readUint, buf, pos) {
-	            var uint = readUint(buf, pos),
-	                sign = (uint >> 31) * 2 + 1,
-	                exponent = uint >>> 23 & 255,
-	                mantissa = uint & 8388607;
-	            return exponent === 255
-	                ? mantissa
-	                ? NaN
-	                : sign * Infinity
-	                : exponent === 0 // denormal
-	                ? sign * 1.401298464324817e-45 * mantissa
-	                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
-	        }
-
-	        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
-	        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
-
-	    })();
-
-	    // double: typed array
-	    if (typeof Float64Array !== "undefined") (function() {
-
-	        var f64 = new Float64Array([-0]),
-	            f8b = new Uint8Array(f64.buffer),
-	            le  = f8b[7] === 128;
-
-	        function writeDouble_f64_cpy(val, buf, pos) {
-	            f64[0] = val;
-	            buf[pos    ] = f8b[0];
-	            buf[pos + 1] = f8b[1];
-	            buf[pos + 2] = f8b[2];
-	            buf[pos + 3] = f8b[3];
-	            buf[pos + 4] = f8b[4];
-	            buf[pos + 5] = f8b[5];
-	            buf[pos + 6] = f8b[6];
-	            buf[pos + 7] = f8b[7];
-	        }
-
-	        function writeDouble_f64_rev(val, buf, pos) {
-	            f64[0] = val;
-	            buf[pos    ] = f8b[7];
-	            buf[pos + 1] = f8b[6];
-	            buf[pos + 2] = f8b[5];
-	            buf[pos + 3] = f8b[4];
-	            buf[pos + 4] = f8b[3];
-	            buf[pos + 5] = f8b[2];
-	            buf[pos + 6] = f8b[1];
-	            buf[pos + 7] = f8b[0];
-	        }
-
-	        /* istanbul ignore next */
-	        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
-	        /* istanbul ignore next */
-	        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
-
-	        function readDouble_f64_cpy(buf, pos) {
-	            f8b[0] = buf[pos    ];
-	            f8b[1] = buf[pos + 1];
-	            f8b[2] = buf[pos + 2];
-	            f8b[3] = buf[pos + 3];
-	            f8b[4] = buf[pos + 4];
-	            f8b[5] = buf[pos + 5];
-	            f8b[6] = buf[pos + 6];
-	            f8b[7] = buf[pos + 7];
-	            return f64[0];
-	        }
-
-	        function readDouble_f64_rev(buf, pos) {
-	            f8b[7] = buf[pos    ];
-	            f8b[6] = buf[pos + 1];
-	            f8b[5] = buf[pos + 2];
-	            f8b[4] = buf[pos + 3];
-	            f8b[3] = buf[pos + 4];
-	            f8b[2] = buf[pos + 5];
-	            f8b[1] = buf[pos + 6];
-	            f8b[0] = buf[pos + 7];
-	            return f64[0];
-	        }
-
-	        /* istanbul ignore next */
-	        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
-	        /* istanbul ignore next */
-	        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
-
-	    // double: ieee754
-	    })(); else (function() {
-
-	        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
-	            var sign = val < 0 ? 1 : 0;
-	            if (sign)
-	                val = -val;
-	            if (val === 0) {
-	                writeUint(0, buf, pos + off0);
-	                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);
-	            } else if (isNaN(val)) {
-	                writeUint(0, buf, pos + off0);
-	                writeUint(2146959360, buf, pos + off1);
-	            } else if (val > 1.7976931348623157e+308) { // +-Infinity
-	                writeUint(0, buf, pos + off0);
-	                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
-	            } else {
-	                var mantissa;
-	                if (val < 2.2250738585072014e-308) { // denormal
-	                    mantissa = val / 5e-324;
-	                    writeUint(mantissa >>> 0, buf, pos + off0);
-	                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
-	                } else {
-	                    var exponent = Math.floor(Math.log(val) / Math.LN2);
-	                    if (exponent === 1024)
-	                        exponent = 1023;
-	                    mantissa = val * Math.pow(2, -exponent);
-	                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
-	                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
-	                }
-	            }
-	        }
-
-	        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
-	        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
-
-	        function readDouble_ieee754(readUint, off0, off1, buf, pos) {
-	            var lo = readUint(buf, pos + off0),
-	                hi = readUint(buf, pos + off1);
-	            var sign = (hi >> 31) * 2 + 1,
-	                exponent = hi >>> 20 & 2047,
-	                mantissa = 4294967296 * (hi & 1048575) + lo;
-	            return exponent === 2047
-	                ? mantissa
-	                ? NaN
-	                : sign * Infinity
-	                : exponent === 0 // denormal
-	                ? sign * 5e-324 * mantissa
-	                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
-	        }
-
-	        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
-	        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
-
-	    })();
-
-	    return exports;
-	}
-
-	// uint helpers
-
-	function writeUintLE(val, buf, pos) {
-	    buf[pos    ] =  val        & 255;
-	    buf[pos + 1] =  val >>> 8  & 255;
-	    buf[pos + 2] =  val >>> 16 & 255;
-	    buf[pos + 3] =  val >>> 24;
-	}
-
-	function writeUintBE(val, buf, pos) {
-	    buf[pos    ] =  val >>> 24;
-	    buf[pos + 1] =  val >>> 16 & 255;
-	    buf[pos + 2] =  val >>> 8  & 255;
-	    buf[pos + 3] =  val        & 255;
-	}
-
-	function readUintLE(buf, pos) {
-	    return (buf[pos    ]
-	          | buf[pos + 1] << 8
-	          | buf[pos + 2] << 16
-	          | buf[pos + 3] << 24) >>> 0;
-	}
-
-	function readUintBE(buf, pos) {
-	    return (buf[pos    ] << 24
-	          | buf[pos + 1] << 16
-	          | buf[pos + 2] << 8
-	          | buf[pos + 3]) >>> 0;
-	}
-	return float;
-}
-
-var inquire_1;
-var hasRequiredInquire;
-
-function requireInquire () {
-	if (hasRequiredInquire) return inquire_1;
-	hasRequiredInquire = 1;
-	inquire_1 = inquire;
-
-	/**
-	 * Requires a module only if available.
-	 * @memberof util
-	 * @param {string} moduleName Module to require
-	 * @returns {?Object} Required module if available and not empty, otherwise `null`
-	 */
-	function inquire(moduleName) {
-	    try {
-	        var mod = eval("quire".replace(/^/,"re"))(moduleName); // eslint-disable-line no-eval
-	        if (mod && (mod.length || Object.keys(mod).length))
-	            return mod;
-	    } catch (e) {} // eslint-disable-line no-empty
-	    return null;
-	}
-	return inquire_1;
-}
-
-var utf8 = {};
-
-var hasRequiredUtf8;
-
-function requireUtf8 () {
-	if (hasRequiredUtf8) return utf8;
-	hasRequiredUtf8 = 1;
-	(function (exports) {
-
-		/**
-		 * A minimal UTF8 implementation for number arrays.
-		 * @memberof util
-		 * @namespace
-		 */
-		var utf8 = exports;
-
-		/**
-		 * Calculates the UTF8 byte length of a string.
-		 * @param {string} string String
-		 * @returns {number} Byte length
-		 */
-		utf8.length = function utf8_length(string) {
-		    var len = 0,
-		        c = 0;
-		    for (var i = 0; i < string.length; ++i) {
-		        c = string.charCodeAt(i);
-		        if (c < 128)
-		            len += 1;
-		        else if (c < 2048)
-		            len += 2;
-		        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
-		            ++i;
-		            len += 4;
-		        } else
-		            len += 3;
-		    }
-		    return len;
-		};
-
-		/**
-		 * Reads UTF8 bytes as a string.
-		 * @param {Uint8Array} buffer Source buffer
-		 * @param {number} start Source start
-		 * @param {number} end Source end
-		 * @returns {string} String read
-		 */
-		utf8.read = function utf8_read(buffer, start, end) {
-		    var len = end - start;
-		    if (len < 1)
-		        return "";
-		    var parts = null,
-		        chunk = [],
-		        i = 0, // char offset
-		        t;     // temporary
-		    while (start < end) {
-		        t = buffer[start++];
-		        if (t < 128)
-		            chunk[i++] = t;
-		        else if (t > 191 && t < 224)
-		            chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
-		        else if (t > 239 && t < 365) {
-		            t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;
-		            chunk[i++] = 0xD800 + (t >> 10);
-		            chunk[i++] = 0xDC00 + (t & 1023);
-		        } else
-		            chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
-		        if (i > 8191) {
-		            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
-		            i = 0;
-		        }
-		    }
-		    if (parts) {
-		        if (i)
-		            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
-		        return parts.join("");
-		    }
-		    return String.fromCharCode.apply(String, chunk.slice(0, i));
-		};
-
-		/**
-		 * Writes a string as UTF8 bytes.
-		 * @param {string} string Source string
-		 * @param {Uint8Array} buffer Destination buffer
-		 * @param {number} offset Destination offset
-		 * @returns {number} Bytes written
-		 */
-		utf8.write = function utf8_write(string, buffer, offset) {
-		    var start = offset,
-		        c1, // character 1
-		        c2; // character 2
-		    for (var i = 0; i < string.length; ++i) {
-		        c1 = string.charCodeAt(i);
-		        if (c1 < 128) {
-		            buffer[offset++] = c1;
-		        } else if (c1 < 2048) {
-		            buffer[offset++] = c1 >> 6       | 192;
-		            buffer[offset++] = c1       & 63 | 128;
-		        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
-		            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
-		            ++i;
-		            buffer[offset++] = c1 >> 18      | 240;
-		            buffer[offset++] = c1 >> 12 & 63 | 128;
-		            buffer[offset++] = c1 >> 6  & 63 | 128;
-		            buffer[offset++] = c1       & 63 | 128;
-		        } else {
-		            buffer[offset++] = c1 >> 12      | 224;
-		            buffer[offset++] = c1 >> 6  & 63 | 128;
-		            buffer[offset++] = c1       & 63 | 128;
-		        }
-		    }
-		    return offset - start;
-		};
-} (utf8));
-	return utf8;
-}
-
-var pool_1;
-var hasRequiredPool;
-
-function requirePool () {
-	if (hasRequiredPool) return pool_1;
-	hasRequiredPool = 1;
-	pool_1 = pool;
-
-	/**
-	 * An allocator as used by {@link util.pool}.
-	 * @typedef PoolAllocator
-	 * @type {function}
-	 * @param {number} size Buffer size
-	 * @returns {Uint8Array} Buffer
-	 */
-
-	/**
-	 * A slicer as used by {@link util.pool}.
-	 * @typedef PoolSlicer
-	 * @type {function}
-	 * @param {number} start Start offset
-	 * @param {number} end End offset
-	 * @returns {Uint8Array} Buffer slice
-	 * @this {Uint8Array}
-	 */
-
-	/**
-	 * A general purpose buffer pool.
-	 * @memberof util
-	 * @function
-	 * @param {PoolAllocator} alloc Allocator
-	 * @param {PoolSlicer} slice Slicer
-	 * @param {number} [size=8192] Slab size
-	 * @returns {PoolAllocator} Pooled allocator
-	 */
-	function pool(alloc, slice, size) {
-	    var SIZE   = size || 8192;
-	    var MAX    = SIZE >>> 1;
-	    var slab   = null;
-	    var offset = SIZE;
-	    return function pool_alloc(size) {
-	        if (size < 1 || size > MAX)
-	            return alloc(size);
-	        if (offset + size > SIZE) {
-	            slab = alloc(SIZE);
-	            offset = 0;
-	        }
-	        var buf = slice.call(slab, offset, offset += size);
-	        if (offset & 7) // align to 32 bit
-	            offset = (offset | 7) + 1;
-	        return buf;
-	    };
-	}
-	return pool_1;
-}
-
-export { requireBase64 as a, requireEventemitter as b, requireFloat as c, requireInquire as d, requireUtf8 as e, requirePool as f, commonjsGlobal as g, getAugmentedNamespace as h, getDefaultExportFromCjs as i, requireAspromise as r };