@waku/core 0.0.26 → 0.0.27

package/bundle/{browser-mTOOnVZp.js → browser-BQyFvtq6.js}

@@ -1,795 +1,622 @@
+function coerce(o) {
+    if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array')
+        return o;
+    if (o instanceof ArrayBuffer)
+        return new Uint8Array(o);
+    if (ArrayBuffer.isView(o)) {
+        return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+    }
+    throw new Error('Unknown type, must be binary type');
+}
+function fromString(str) {
+    return new TextEncoder().encode(str);
+}
+function toString(b) {
+    return new TextDecoder().decode(b);
+}
+
+/* eslint-disable */
 // base-x encoding / decoding
 // Copyright (c) 2018 base-x contributors
 // Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
 // Distributed under the MIT software license, see the accompanying
 // file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-function base (ALPHABET, name) {
-  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }
-  var BASE_MAP = new Uint8Array(256);
-  for (var j = 0; j < BASE_MAP.length; j++) {
-    BASE_MAP[j] = 255;
-  }
-  for (var i = 0; i < ALPHABET.length; i++) {
-    var x = ALPHABET.charAt(i);
-    var xc = x.charCodeAt(0);
-    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }
-    BASE_MAP[xc] = i;
-  }
-  var BASE = ALPHABET.length;
-  var LEADER = ALPHABET.charAt(0);
-  var FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
-  var iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
-  function encode (source) {
-    if (source instanceof Uint8Array) ; else if (ArrayBuffer.isView(source)) {
-      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-    } else if (Array.isArray(source)) {
-      source = Uint8Array.from(source);
+/**
+ * @param {string} ALPHABET
+ * @param {any} name
+ */
+function base(ALPHABET, name) {
+    if (ALPHABET.length >= 255) {
+        throw new TypeError('Alphabet too long');
     }
-    if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }
-    if (source.length === 0) { return '' }
-        // Skip & count leading zeroes.
-    var zeroes = 0;
-    var length = 0;
-    var pbegin = 0;
-    var pend = source.length;
-    while (pbegin !== pend && source[pbegin] === 0) {
-      pbegin++;
-      zeroes++;
+    var BASE_MAP = new Uint8Array(256);
+    for (var j = 0; j < BASE_MAP.length; j++) {
+        BASE_MAP[j] = 255;
+    }
+    for (var i = 0; i < ALPHABET.length; i++) {
+        var x = ALPHABET.charAt(i);
+        var xc = x.charCodeAt(0);
+        if (BASE_MAP[xc] !== 255) {
+            throw new TypeError(x + ' is ambiguous');
+        }
+        BASE_MAP[xc] = i;
     }
+    var BASE = ALPHABET.length;
+    var LEADER = ALPHABET.charAt(0);
+    var FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
+    var iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
+    /**
+     * @param {any[] | Iterable<number>} source
+     */
+    function encode(source) {
+        // @ts-ignore
+        if (source instanceof Uint8Array)
+            ;
+        else if (ArrayBuffer.isView(source)) {
+            source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+        }
+        else if (Array.isArray(source)) {
+            source = Uint8Array.from(source);
+        }
+        if (!(source instanceof Uint8Array)) {
+            throw new TypeError('Expected Uint8Array');
+        }
+        if (source.length === 0) {
+            return '';
+        }
+        // Skip & count leading zeroes.
+        var zeroes = 0;
+        var length = 0;
+        var pbegin = 0;
+        var pend = source.length;
+        while (pbegin !== pend && source[pbegin] === 0) {
+            pbegin++;
+            zeroes++;
+        }
         // Allocate enough space in big-endian base58 representation.
-    var size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
-    var b58 = new Uint8Array(size);
+        var size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+        var b58 = new Uint8Array(size);
         // Process the bytes.
-    while (pbegin !== pend) {
-      var carry = source[pbegin];
+        while (pbegin !== pend) {
+            var carry = source[pbegin];
             // Apply "b58 = b58 * 256 + ch".
-      var i = 0;
-      for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
-        carry += (256 * b58[it1]) >>> 0;
-        b58[it1] = (carry % BASE) >>> 0;
-        carry = (carry / BASE) >>> 0;
-      }
-      if (carry !== 0) { throw new Error('Non-zero carry') }
-      length = i;
-      pbegin++;
-    }
+            var i = 0;
+            for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
+                carry += (256 * b58[it1]) >>> 0;
+                b58[it1] = (carry % BASE) >>> 0;
+                carry = (carry / BASE) >>> 0;
+            }
+            if (carry !== 0) {
+                throw new Error('Non-zero carry');
+            }
+            length = i;
+            pbegin++;
+        }
         // Skip leading zeroes in base58 result.
-    var it2 = size - length;
-    while (it2 !== size && b58[it2] === 0) {
-      it2++;
-    }
+        var it2 = size - length;
+        while (it2 !== size && b58[it2] === 0) {
+            it2++;
+        }
         // Translate the result into a string.
-    var str = LEADER.repeat(zeroes);
-    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]); }
-    return str
-  }
-  function decodeUnsafe (source) {
-    if (typeof source !== 'string') { throw new TypeError('Expected String') }
-    if (source.length === 0) { return new Uint8Array() }
-    var psz = 0;
+        var str = LEADER.repeat(zeroes);
+        for (; it2 < size; ++it2) {
+            str += ALPHABET.charAt(b58[it2]);
+        }
+        return str;
+    }
+    /**
+     * @param {string | string[]} source
+     */
+    function decodeUnsafe(source) {
+        if (typeof source !== 'string') {
+            throw new TypeError('Expected String');
+        }
+        if (source.length === 0) {
+            return new Uint8Array();
+        }
+        var psz = 0;
         // Skip leading spaces.
-    if (source[psz] === ' ') { return }
+        if (source[psz] === ' ') {
+            return;
+        }
         // Skip and count leading '1's.
-    var zeroes = 0;
-    var length = 0;
-    while (source[psz] === LEADER) {
-      zeroes++;
-      psz++;
-    }
+        var zeroes = 0;
+        var length = 0;
+        while (source[psz] === LEADER) {
+            zeroes++;
+            psz++;
+        }
         // Allocate enough space in big-endian base256 representation.
-    var size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
-    var b256 = new Uint8Array(size);
+        var size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
+        var b256 = new Uint8Array(size);
         // Process the characters.
-    while (source[psz]) {
+        while (source[psz]) {
             // Decode character
-      var carry = BASE_MAP[source.charCodeAt(psz)];
+            var carry = BASE_MAP[source.charCodeAt(psz)];
             // Invalid character
-      if (carry === 255) { return }
-      var i = 0;
-      for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
-        carry += (BASE * b256[it3]) >>> 0;
-        b256[it3] = (carry % 256) >>> 0;
-        carry = (carry / 256) >>> 0;
-      }
-      if (carry !== 0) { throw new Error('Non-zero carry') }
-      length = i;
-      psz++;
-    }
+            if (carry === 255) {
+                return;
+            }
+            var i = 0;
+            for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
+                carry += (BASE * b256[it3]) >>> 0;
+                b256[it3] = (carry % 256) >>> 0;
+                carry = (carry / 256) >>> 0;
+            }
+            if (carry !== 0) {
+                throw new Error('Non-zero carry');
+            }
+            length = i;
+            psz++;
+        }
         // Skip trailing spaces.
-    if (source[psz] === ' ') { return }
+        if (source[psz] === ' ') {
+            return;
+        }
         // Skip leading zeroes in b256.
-    var it4 = size - length;
-    while (it4 !== size && b256[it4] === 0) {
-      it4++;
+        var it4 = size - length;
+        while (it4 !== size && b256[it4] === 0) {
+            it4++;
+        }
+        var vch = new Uint8Array(zeroes + (size - it4));
+        var j = zeroes;
+        while (it4 !== size) {
+            vch[j++] = b256[it4++];
+        }
+        return vch;
     }
-    var vch = new Uint8Array(zeroes + (size - it4));
-    var j = zeroes;
-    while (it4 !== size) {
-      vch[j++] = b256[it4++];
+    /**
+     * @param {string | string[]} string
+     */
+    function decode(string) {
+        var buffer = decodeUnsafe(string);
+        if (buffer) {
+            return buffer;
+        }
+        throw new Error(`Non-${name} character`);
     }
-    return vch
-  }
-  function decode (string) {
-    var buffer = decodeUnsafe(string);
-    if (buffer) { return buffer }
-    throw new Error(`Non-${name} character`)
-  }
-  return {
-    encode: encode,
-    decodeUnsafe: decodeUnsafe,
-    decode: decode
-  }
+    return {
+        encode: encode,
+        decodeUnsafe: decodeUnsafe,
+        decode: decode
+    };
 }
 var src = base;
-
 var _brrp__multiformats_scope_baseX = src;
 
-/**
- * @param {Uint8Array} aa
- * @param {Uint8Array} bb
- */
-const equals = (aa, bb) => {
-  if (aa === bb) return true
-  if (aa.byteLength !== bb.byteLength) {
-    return false
-  }
-
-  for (let ii = 0; ii < aa.byteLength; ii++) {
-    if (aa[ii] !== bb[ii]) {
-      return false
-    }
-  }
-
-  return true
-};
-
-/**
- * @param {ArrayBufferView|ArrayBuffer|Uint8Array} o
- * @returns {Uint8Array}
- */
-const coerce = o => {
-  if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array') return o
-  if (o instanceof ArrayBuffer) return new Uint8Array(o)
-  if (ArrayBuffer.isView(o)) {
-    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength)
-  }
-  throw new Error('Unknown type, must be binary type')
-};
-
-/**
- * @param {string} str
- * @returns {Uint8Array}
- */
-const fromString = str => (new TextEncoder()).encode(str);
-
-/**
- * @param {Uint8Array} b
- * @returns {string}
- */
-const toString = b => (new TextDecoder()).decode(b);
-
 /**
  * Class represents both BaseEncoder and MultibaseEncoder meaning it
  * can be used to encode to multibase or base encode without multibase
  * prefix.
- *
- * @class
- * @template {string} Base
- * @template {string} Prefix
- * @implements {API.MultibaseEncoder<Prefix>}
- * @implements {API.BaseEncoder}
  */
 class Encoder {
-  /**
-   * @param {Base} name
-   * @param {Prefix} prefix
-   * @param {(bytes:Uint8Array) => string} baseEncode
-   */
-  constructor (name, prefix, baseEncode) {
-    this.name = name;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-  }
-
-  /**
-   * @param {Uint8Array} bytes
-   * @returns {API.Multibase<Prefix>}
-   */
-  encode (bytes) {
-    if (bytes instanceof Uint8Array) {
-      return `${this.prefix}${this.baseEncode(bytes)}`
-    } else {
-      throw Error('Unknown type, must be binary type')
+    name;
+    prefix;
+    baseEncode;
+    constructor(name, prefix, baseEncode) {
+        this.name = name;
+        this.prefix = prefix;
+        this.baseEncode = baseEncode;
+    }
+    encode(bytes) {
+        if (bytes instanceof Uint8Array) {
+            return `${this.prefix}${this.baseEncode(bytes)}`;
+        }
+        else {
+            throw Error('Unknown type, must be binary type');
+        }
     }
-  }
 }
-
-/**
- * @template {string} Prefix
- */
 /**
  * Class represents both BaseDecoder and MultibaseDecoder so it could be used
  * to decode multibases (with matching prefix) or just base decode strings
  * with corresponding base encoding.
- *
- * @class
- * @template {string} Base
- * @template {string} Prefix
- * @implements {API.MultibaseDecoder<Prefix>}
- * @implements {API.UnibaseDecoder<Prefix>}
- * @implements {API.BaseDecoder}
  */
 class Decoder {
-  /**
-   * @param {Base} name
-   * @param {Prefix} prefix
-   * @param {(text:string) => Uint8Array} baseDecode
-   */
-  constructor (name, prefix, baseDecode) {
-    this.name = name;
-    this.prefix = prefix;
-    /* c8 ignore next 3 */
-    if (prefix.codePointAt(0) === undefined) {
-      throw new Error('Invalid prefix character')
+    name;
+    prefix;
+    baseDecode;
+    prefixCodePoint;
+    constructor(name, prefix, baseDecode) {
+        this.name = name;
+        this.prefix = prefix;
+        /* c8 ignore next 3 */
+        if (prefix.codePointAt(0) === undefined) {
+            throw new Error('Invalid prefix character');
+        }
+        this.prefixCodePoint = prefix.codePointAt(0);
+        this.baseDecode = baseDecode;
+    }
+    decode(text) {
+        if (typeof text === 'string') {
+            if (text.codePointAt(0) !== this.prefixCodePoint) {
+                throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+            }
+            return this.baseDecode(text.slice(this.prefix.length));
+        }
+        else {
+            throw Error('Can only multibase decode strings');
+        }
     }
-    /** @private */
-    this.prefixCodePoint = /** @type {number} */ (prefix.codePointAt(0));
-    this.baseDecode = baseDecode;
-  }
-
-  /**
-   * @param {string} text
-   */
-  decode (text) {
-    if (typeof text === 'string') {
-      if (text.codePointAt(0) !== this.prefixCodePoint) {
-        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`)
-      }
-      return this.baseDecode(text.slice(this.prefix.length))
-    } else {
-      throw Error('Can only multibase decode strings')
+    or(decoder) {
+        return or(this, decoder);
     }
-  }
-
-  /**
-   * @template {string} OtherPrefix
-   * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
-   * @returns {ComposedDecoder<Prefix|OtherPrefix>}
-   */
-  or (decoder) {
-    return or(this, decoder)
-  }
 }
-
-/**
- * @template {string} Prefix
- * @typedef {Record<Prefix, API.UnibaseDecoder<Prefix>>} Decoders
- */
-
-/**
- * @template {string} Prefix
- * @implements {API.MultibaseDecoder<Prefix>}
- * @implements {API.CombobaseDecoder<Prefix>}
- */
 class ComposedDecoder {
-  /**
-   * @param {Decoders<Prefix>} decoders
-   */
-  constructor (decoders) {
-    this.decoders = decoders;
-  }
-
-  /**
-   * @template {string} OtherPrefix
-   * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
-   * @returns {ComposedDecoder<Prefix|OtherPrefix>}
-   */
-  or (decoder) {
-    return or(this, decoder)
-  }
-
-  /**
-   * @param {string} input
-   * @returns {Uint8Array}
-   */
-  decode (input) {
-    const prefix = /** @type {Prefix} */ (input[0]);
-    const decoder = this.decoders[prefix];
-    if (decoder) {
-      return decoder.decode(input)
-    } else {
-      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`)
+    decoders;
+    constructor(decoders) {
+        this.decoders = decoders;
+    }
+    or(decoder) {
+        return or(this, decoder);
+    }
+    decode(input) {
+        const prefix = input[0];
+        const decoder = this.decoders[prefix];
+        if (decoder != null) {
+            return decoder.decode(input);
+        }
+        else {
+            throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+        }
     }
-  }
 }
-
-/**
- * @template {string} L
- * @template {string} R
- * @param {API.UnibaseDecoder<L>|API.CombobaseDecoder<L>} left
- * @param {API.UnibaseDecoder<R>|API.CombobaseDecoder<R>} right
- * @returns {ComposedDecoder<L|R>}
- */
-const or = (left, right) => new ComposedDecoder(/** @type {Decoders<L|R>} */({
-  ...(left.decoders || { [/** @type API.UnibaseDecoder<L> */(left).prefix]: left }),
-  ...(right.decoders || { [/** @type API.UnibaseDecoder<R> */(right).prefix]: right })
-}));
-
-/**
- * @class
- * @template {string} Base
- * @template {string} Prefix
- * @implements {API.MultibaseCodec<Prefix>}
- * @implements {API.MultibaseEncoder<Prefix>}
- * @implements {API.MultibaseDecoder<Prefix>}
- * @implements {API.BaseCodec}
- * @implements {API.BaseEncoder}
- * @implements {API.BaseDecoder}
- */
+function or(left, right) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return new ComposedDecoder({
+        ...(left.decoders ?? { [left.prefix]: left }),
+        ...(right.decoders ?? { [right.prefix]: right })
+    });
+}
 class Codec {
-  /**
-   * @param {Base} name
-   * @param {Prefix} prefix
-   * @param {(bytes:Uint8Array) => string} baseEncode
-   * @param {(text:string) => Uint8Array} baseDecode
-   */
-  constructor (name, prefix, baseEncode, baseDecode) {
-    this.name = name;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-    this.baseDecode = baseDecode;
-    this.encoder = new Encoder(name, prefix, baseEncode);
-    this.decoder = new Decoder(name, prefix, baseDecode);
-  }
-
-  /**
-   * @param {Uint8Array} input
-   */
-  encode (input) {
-    return this.encoder.encode(input)
-  }
-
-  /**
-   * @param {string} input
-   */
-  decode (input) {
-    return this.decoder.decode(input)
-  }
+    name;
+    prefix;
+    baseEncode;
+    baseDecode;
+    encoder;
+    decoder;
+    constructor(name, prefix, baseEncode, baseDecode) {
+        this.name = name;
+        this.prefix = prefix;
+        this.baseEncode = baseEncode;
+        this.baseDecode = baseDecode;
+        this.encoder = new Encoder(name, prefix, baseEncode);
+        this.decoder = new Decoder(name, prefix, baseDecode);
+    }
+    encode(input) {
+        return this.encoder.encode(input);
+    }
+    decode(input) {
+        return this.decoder.decode(input);
+    }
 }
-
-/**
- * @template {string} Base
- * @template {string} Prefix
- * @param {object} options
- * @param {Base} options.name
- * @param {Prefix} options.prefix
- * @param {(bytes:Uint8Array) => string} options.encode
- * @param {(input:string) => Uint8Array} options.decode
- * @returns {Codec<Base, Prefix>}
- */
-const from = ({ name, prefix, encode, decode }) =>
-  new Codec(name, prefix, encode, decode);
-
-/**
- * @template {string} Base
- * @template {string} Prefix
- * @param {object} options
- * @param {Base} options.name
- * @param {Prefix} options.prefix
- * @param {string} options.alphabet
- * @returns {Codec<Base, Prefix>}
- */
-const baseX = ({ prefix, name, alphabet }) => {
-  const { encode, decode } = _brrp__multiformats_scope_baseX(alphabet, name);
-  return from({
-    prefix,
-    name,
-    encode,
-    /**
-     * @param {string} text
-     */
-    decode: text => coerce(decode(text))
-  })
-};
-
-/**
- * @param {string} string
- * @param {string} alphabet
- * @param {number} bitsPerChar
- * @param {string} name
- * @returns {Uint8Array}
- */
-const decode$1 = (string, alphabet, bitsPerChar, name) => {
-  // Build the character lookup table:
-  /** @type {Record<string, number>} */
-  const codes = {};
-  for (let i = 0; i < alphabet.length; ++i) {
-    codes[alphabet[i]] = i;
-  }
-
-  // Count the padding bytes:
-  let end = string.length;
-  while (string[end - 1] === '=') {
-    --end;
-  }
-
-  // Allocate the output:
-  const out = new Uint8Array((end * bitsPerChar / 8) | 0);
-
-  // Parse the data:
-  let bits = 0; // Number of bits currently in the buffer
-  let buffer = 0; // Bits waiting to be written out, MSB first
-  let written = 0; // Next byte to write
-  for (let i = 0; i < end; ++i) {
-    // Read one character from the string:
-    const value = codes[string[i]];
-    if (value === undefined) {
-      throw new SyntaxError(`Non-${name} character`)
+function from({ name, prefix, encode, decode }) {
+    return new Codec(name, prefix, encode, decode);
+}
+function baseX({ name, prefix, alphabet }) {
+    const { encode, decode } = _brrp__multiformats_scope_baseX(alphabet, name);
+    return from({
+        prefix,
+        name,
+        encode,
+        decode: (text) => coerce(decode(text))
+    });
+}
+function decode$1(string, alphabet, bitsPerChar, name) {
+    // Build the character lookup table:
+    const codes = {};
+    for (let i = 0; i < alphabet.length; ++i) {
+        codes[alphabet[i]] = i;
     }
-
-    // Append the bits to the buffer:
-    buffer = (buffer << bitsPerChar) | value;
-    bits += bitsPerChar;
-
-    // Write out some bits if the buffer has a byte's worth:
-    if (bits >= 8) {
-      bits -= 8;
-      out[written++] = 0xff & (buffer >> bits);
+    // Count the padding bytes:
+    let end = string.length;
+    while (string[end - 1] === '=') {
+        --end;
     }
-  }
-
-  // Verify that we have received just enough bits:
-  if (bits >= bitsPerChar || 0xff & (buffer << (8 - bits))) {
-    throw new SyntaxError('Unexpected end of data')
-  }
-
-  return out
-};
-
-/**
- * @param {Uint8Array} data
- * @param {string} alphabet
- * @param {number} bitsPerChar
- * @returns {string}
- */
-const encode$1 = (data, alphabet, bitsPerChar) => {
-  const pad = alphabet[alphabet.length - 1] === '=';
-  const mask = (1 << bitsPerChar) - 1;
-  let out = '';
-
-  let bits = 0; // Number of bits currently in the buffer
-  let buffer = 0; // Bits waiting to be written out, MSB first
-  for (let i = 0; i < data.length; ++i) {
-    // Slurp data into the buffer:
-    buffer = (buffer << 8) | data[i];
-    bits += 8;
-
-    // Write out as much as we can:
-    while (bits > bitsPerChar) {
-      bits -= bitsPerChar;
-      out += alphabet[mask & (buffer >> bits)];
+    // Allocate the output:
+    const out = new Uint8Array((end * bitsPerChar / 8) | 0);
+    // Parse the data:
+    let bits = 0; // Number of bits currently in the buffer
+    let buffer = 0; // Bits waiting to be written out, MSB first
+    let written = 0; // Next byte to write
+    for (let i = 0; i < end; ++i) {
+        // Read one character from the string:
+        const value = codes[string[i]];
+        if (value === undefined) {
+            throw new SyntaxError(`Non-${name} character`);
+        }
+        // Append the bits to the buffer:
+        buffer = (buffer << bitsPerChar) | value;
+        bits += bitsPerChar;
+        // Write out some bits if the buffer has a byte's worth:
+        if (bits >= 8) {
+            bits -= 8;
+            out[written++] = 0xff & (buffer >> bits);
+        }
     }
-  }
-
-  // Partial character:
-  if (bits) {
-    out += alphabet[mask & (buffer << (bitsPerChar - bits))];
-  }
-
-  // Add padding characters until we hit a byte boundary:
-  if (pad) {
-    while ((out.length * bitsPerChar) & 7) {
-      out += '=';
+    // Verify that we have received just enough bits:
+    if (bits >= bitsPerChar || (0xff & (buffer << (8 - bits))) !== 0) {
+        throw new SyntaxError('Unexpected end of data');
     }
-  }
-
-  return out
-};
-
+    return out;
+}
+function encode$1(data, alphabet, bitsPerChar) {
+    const pad = alphabet[alphabet.length - 1] === '=';
+    const mask = (1 << bitsPerChar) - 1;
+    let out = '';
+    let bits = 0; // Number of bits currently in the buffer
+    let buffer = 0; // Bits waiting to be written out, MSB first
+    for (let i = 0; i < data.length; ++i) {
+        // Slurp data into the buffer:
+        buffer = (buffer << 8) | data[i];
+        bits += 8;
+        // Write out as much as we can:
+        while (bits > bitsPerChar) {
+            bits -= bitsPerChar;
+            out += alphabet[mask & (buffer >> bits)];
+        }
+    }
+    // Partial character:
+    if (bits !== 0) {
+        out += alphabet[mask & (buffer << (bitsPerChar - bits))];
+    }
+    // Add padding characters until we hit a byte boundary:
+    if (pad) {
+        while (((out.length * bitsPerChar) & 7) !== 0) {
+            out += '=';
+        }
+    }
+    return out;
+}
 /**
  * RFC4648 Factory
- *
- * @template {string} Base
- * @template {string} Prefix
- * @param {object} options
- * @param {Base} options.name
- * @param {Prefix} options.prefix
- * @param {string} options.alphabet
- * @param {number} options.bitsPerChar
  */
-const rfc4648 = ({ name, prefix, bitsPerChar, alphabet }) => {
-  return from({
-    prefix,
-    name,
-    encode (input) {
-      return encode$1(input, alphabet, bitsPerChar)
-    },
-    decode (input) {
-      return decode$1(input, alphabet, bitsPerChar, name)
-    }
-  })
-};
-
-const base58btc = baseX({
-  name: 'base58btc',
-  prefix: 'z',
-  alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-});
-
-const base58flickr = baseX({
-  name: 'base58flickr',
-  prefix: 'Z',
-  alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
-});
-
-var base58 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  base58btc: base58btc,
-  base58flickr: base58flickr
-});
-
-const base32 = rfc4648({
-  prefix: 'b',
-  name: 'base32',
-  alphabet: 'abcdefghijklmnopqrstuvwxyz234567',
-  bitsPerChar: 5
-});
-
-const base32upper = rfc4648({
-  prefix: 'B',
-  name: 'base32upper',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
-  bitsPerChar: 5
-});
-
-const base32pad = rfc4648({
-  prefix: 'c',
-  name: 'base32pad',
-  alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',
-  bitsPerChar: 5
-});
-
-const base32padupper = rfc4648({
-  prefix: 'C',
-  name: 'base32padupper',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',
-  bitsPerChar: 5
-});
-
-const base32hex = rfc4648({
-  prefix: 'v',
-  name: 'base32hex',
-  alphabet: '0123456789abcdefghijklmnopqrstuv',
-  bitsPerChar: 5
-});
-
-const base32hexupper = rfc4648({
-  prefix: 'V',
-  name: 'base32hexupper',
-  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',
-  bitsPerChar: 5
-});
-
-const base32hexpad = rfc4648({
-  prefix: 't',
-  name: 'base32hexpad',
-  alphabet: '0123456789abcdefghijklmnopqrstuv=',
-  bitsPerChar: 5
-});
-
-const base32hexpadupper = rfc4648({
-  prefix: 'T',
-  name: 'base32hexpadupper',
-  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',
-  bitsPerChar: 5
-});
-
-const base32z = rfc4648({
-  prefix: 'h',
-  name: 'base32z',
-  alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',
-  bitsPerChar: 5
-});
-
-var base32$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  base32: base32,
-  base32hex: base32hex,
-  base32hexpad: base32hexpad,
-  base32hexpadupper: base32hexpadupper,
-  base32hexupper: base32hexupper,
-  base32pad: base32pad,
-  base32padupper: base32padupper,
-  base32upper: base32upper,
-  base32z: base32z
-});
+function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
+    return from({
+        prefix,
+        name,
+        encode(input) {
+            return encode$1(input, alphabet, bitsPerChar);
+        },
+        decode(input) {
+            return decode$1(input, alphabet, bitsPerChar, name);
+        }
+    });
+}
 
 const base10 = baseX({
-  prefix: '9',
-  name: 'base10',
-  alphabet: '0123456789'
+    prefix: '9',
+    name: 'base10',
+    alphabet: '0123456789'
 });
 
 var base10$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  base10: base10
+    __proto__: null,
+    base10: base10
 });
 
-// @ts-check
-
-
 const base16 = rfc4648({
-  prefix: 'f',
-  name: 'base16',
-  alphabet: '0123456789abcdef',
-  bitsPerChar: 4
+    prefix: 'f',
+    name: 'base16',
+    alphabet: '0123456789abcdef',
+    bitsPerChar: 4
 });
-
 const base16upper = rfc4648({
-  prefix: 'F',
-  name: 'base16upper',
-  alphabet: '0123456789ABCDEF',
-  bitsPerChar: 4
+    prefix: 'F',
+    name: 'base16upper',
+    alphabet: '0123456789ABCDEF',
+    bitsPerChar: 4
 });
 
 var base16$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  base16: base16,
-  base16upper: base16upper
+    __proto__: null,
+    base16: base16,
+    base16upper: base16upper
 });
 
-// @ts-check
-
-
 const base2 = rfc4648({
-  prefix: '0',
-  name: 'base2',
-  alphabet: '01',
-  bitsPerChar: 1
+    prefix: '0',
+    name: 'base2',
+    alphabet: '01',
+    bitsPerChar: 1
 });
 
 var base2$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  base2: base2
+    __proto__: null,
+    base2: base2
 });
 
 const alphabet = Array.from('🚀🪐☄🛰🌌🌑🌒🌓🌔🌕🌖🌗🌘🌍🌏🌎🐉☀💻🖥💾💿😂❤😍🤣😊🙏💕😭😘👍😅👏😁🔥🥰💔💖💙😢🤔😆🙄💪😉☺👌🤗💜😔😎😇🌹🤦🎉💞✌✨🤷😱😌🌸🙌😋💗💚😏💛🙂💓🤩😄😀🖤😃💯🙈👇🎶😒🤭❣😜💋👀😪😑💥🙋😞😩😡🤪👊🥳😥🤤👉💃😳✋😚😝😴🌟😬🙃🍀🌷😻😓⭐✅🥺🌈😈🤘💦✔😣🏃💐☹🎊💘😠☝😕🌺🎂🌻😐🖕💝🙊😹🗣💫💀👑🎵🤞😛🔴😤🌼😫⚽🤙☕🏆🤫👈😮🙆🍻🍃🐶💁😲🌿🧡🎁⚡🌞🎈❌✊👋😰🤨😶🤝🚶💰🍓💢🤟🙁🚨💨🤬✈🎀🍺🤓😙💟🌱😖👶🥴▶➡❓💎💸⬇😨🌚🦋😷🕺⚠🙅😟😵👎🤲🤠🤧📌🔵💅🧐🐾🍒😗🤑🌊🤯🐷☎💧😯💆👆🎤🙇🍑❄🌴💣🐸💌📍🥀🤢👅💡💩👐📸👻🤐🤮🎼🥵🚩🍎🍊👼💍📣🥂');
-const alphabetBytesToChars = /** @type {string[]} */ (alphabet.reduce((p, c, i) => { p[i] = c; return p }, /** @type {string[]} */([])));
-const alphabetCharsToBytes = /** @type {number[]} */ (alphabet.reduce((p, c, i) => { p[/** @type {number} */ (c.codePointAt(0))] = i; return p }, /** @type {number[]} */([])));
-
-/**
- * @param {Uint8Array} data
- * @returns {string}
- */
-function encode (data) {
-  return data.reduce((p, c) => {
-    p += alphabetBytesToChars[c];
-    return p
-  }, '')
+const alphabetBytesToChars = (alphabet.reduce((p, c, i) => { p[i] = c; return p; }, ([])));
+const alphabetCharsToBytes = (alphabet.reduce((p, c, i) => { p[c.codePointAt(0)] = i; return p; }, ([])));
+function encode(data) {
+    return data.reduce((p, c) => {
+        p += alphabetBytesToChars[c];
+        return p;
+    }, '');
 }
-
-/**
- * @param {string} str
- * @returns {Uint8Array}
- */
-function decode (str) {
-  const byts = [];
-  for (const char of str) {
-    const byt = alphabetCharsToBytes[/** @type {number} */ (char.codePointAt(0))];
-    if (byt === undefined) {
-      throw new Error(`Non-base256emoji character: ${char}`)
+function decode(str) {
+    const byts = [];
+    for (const char of str) {
+        const byt = alphabetCharsToBytes[char.codePointAt(0)];
+        if (byt === undefined) {
+            throw new Error(`Non-base256emoji character: ${char}`);
+        }
+        byts.push(byt);
     }
-    byts.push(byt);
-  }
-  return new Uint8Array(byts)
+    return new Uint8Array(byts);
 }
-
 const base256emoji = from({
-  prefix: '🚀',
-  name: 'base256emoji',
-  encode,
-  decode
+    prefix: '🚀',
+    name: 'base256emoji',
+    encode,
+    decode
 });
 
 var base256emoji$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  base256emoji: base256emoji
+    __proto__: null,
+    base256emoji: base256emoji
 });
 
-const base36 = baseX({
-  prefix: 'k',
-  name: 'base36',
-  alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'
+const base32 = rfc4648({
+    prefix: 'b',
+    name: 'base32',
+    alphabet: 'abcdefghijklmnopqrstuvwxyz234567',
+    bitsPerChar: 5
+});
+const base32upper = rfc4648({
+    prefix: 'B',
+    name: 'base32upper',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
+    bitsPerChar: 5
+});
+const base32pad = rfc4648({
+    prefix: 'c',
+    name: 'base32pad',
+    alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',
+    bitsPerChar: 5
+});
+const base32padupper = rfc4648({
+    prefix: 'C',
+    name: 'base32padupper',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',
+    bitsPerChar: 5
+});
+const base32hex = rfc4648({
+    prefix: 'v',
+    name: 'base32hex',
+    alphabet: '0123456789abcdefghijklmnopqrstuv',
+    bitsPerChar: 5
+});
+const base32hexupper = rfc4648({
+    prefix: 'V',
+    name: 'base32hexupper',
+    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',
+    bitsPerChar: 5
+});
+const base32hexpad = rfc4648({
+    prefix: 't',
+    name: 'base32hexpad',
+    alphabet: '0123456789abcdefghijklmnopqrstuv=',
+    bitsPerChar: 5
+});
+const base32hexpadupper = rfc4648({
+    prefix: 'T',
+    name: 'base32hexpadupper',
+    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',
+    bitsPerChar: 5
+});
+const base32z = rfc4648({
+    prefix: 'h',
+    name: 'base32z',
+    alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',
+    bitsPerChar: 5
+});
+
+var base32$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base32: base32,
+    base32hex: base32hex,
+    base32hexpad: base32hexpad,
+    base32hexpadupper: base32hexpadupper,
+    base32hexupper: base32hexupper,
+    base32pad: base32pad,
+    base32padupper: base32padupper,
+    base32upper: base32upper,
+    base32z: base32z
 });
 
+const base36 = baseX({
+    prefix: 'k',
+    name: 'base36',
+    alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'
+});
 const base36upper = baseX({
-  prefix: 'K',
-  name: 'base36upper',
-  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    prefix: 'K',
+    name: 'base36upper',
+    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 });
 
 var base36$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  base36: base36,
-  base36upper: base36upper
+    __proto__: null,
+    base36: base36,
+    base36upper: base36upper
 });
 
-// @ts-check
+const base58btc = baseX({
+    name: 'base58btc',
+    prefix: 'z',
+    alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+});
+const base58flickr = baseX({
+    name: 'base58flickr',
+    prefix: 'Z',
+    alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
+});
 
+var base58 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base58btc: base58btc,
+    base58flickr: base58flickr
+});
 
 const base64 = rfc4648({
-  prefix: 'm',
-  name: 'base64',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
-  bitsPerChar: 6
+    prefix: 'm',
+    name: 'base64',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+    bitsPerChar: 6
 });
-
 const base64pad = rfc4648({
-  prefix: 'M',
-  name: 'base64pad',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
-  bitsPerChar: 6
+    prefix: 'M',
+    name: 'base64pad',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
+    bitsPerChar: 6
 });
-
 const base64url = rfc4648({
-  prefix: 'u',
-  name: 'base64url',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
-  bitsPerChar: 6
+    prefix: 'u',
+    name: 'base64url',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
+    bitsPerChar: 6
 });
-
 const base64urlpad = rfc4648({
-  prefix: 'U',
-  name: 'base64urlpad',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',
-  bitsPerChar: 6
+    prefix: 'U',
+    name: 'base64urlpad',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',
+    bitsPerChar: 6
 });
 
 var base64$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  base64: base64,
-  base64pad: base64pad,
-  base64url: base64url,
-  base64urlpad: base64urlpad
+    __proto__: null,
+    base64: base64,
+    base64pad: base64pad,
+    base64url: base64url,
+    base64urlpad: base64urlpad
 });
 
-// @ts-check
-
-
 const base8 = rfc4648({
-  prefix: '7',
-  name: 'base8',
-  alphabet: '01234567',
-  bitsPerChar: 3
+    prefix: '7',
+    name: 'base8',
+    alphabet: '01234567',
+    bitsPerChar: 3
 });
 
 var base8$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  base8: base8
+    __proto__: null,
+    base8: base8
 });
 
-// @ts-check
-
-
 const identity = from({
-  prefix: '\x00',
-  name: 'identity',
-  encode: (buf) => toString(buf),
-  decode: (str) => fromString(str)
+    prefix: '\x00',
+    name: 'identity',
+    encode: (buf) => toString(buf),
+    decode: (str) => fromString(str)
 });
 
 var identityBase = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  identity: identity
+    __proto__: null,
+    identity: identity
 });
 
-// @ts-check
-
-/**
- * @template T
- * @typedef {import('./interface.js').ByteView<T>} ByteView
- */
-
 new TextEncoder();
 new TextDecoder();
 
@@ -859,6 +686,7 @@ var Tags;
 (function (Tags) {
     Tags["BOOTSTRAP"] = "bootstrap";
     Tags["PEER_EXCHANGE"] = "peer-exchange";
+    Tags["LOCAL"] = "local-peer-cache";
 })(Tags || (Tags = {}));
 var EPeersByDiscoveryEvents;
 (function (EPeersByDiscoveryEvents) {
@@ -872,37 +700,10 @@ var EConnectionStateEvents;
     EConnectionStateEvents["CONNECTION_STATUS"] = "waku:connection";
 })(EConnectionStateEvents || (EConnectionStateEvents = {}));
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-function getAugmentedNamespace(n) {
-  if (n.__esModule) return n;
-  var f = n.default;
-	if (typeof f == "function") {
-		var a = function a () {
-			if (this instanceof a) {
-        return Reflect.construct(f, arguments, this.constructor);
-			}
-			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 browser = {exports: {}};
 
 /**
@@ -1625,4 +1426,4 @@ var common = setup;
 var browserExports = browser.exports;
 var debug = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
-export { EConnectionStateEvents as E, Protocols as P, SendError as S, Tags as T, base58btc as a, base32 as b, coerce as c, commonjsGlobal as d, equals as e, EPeersByDiscoveryEvents as f, getAugmentedNamespace as g, getDefaultExportFromCjs as h, identityBase as i, base2$1 as j, base8$1 as k, base10$1 as l, base16$1 as m, base32$1 as n, base36$1 as o, base58 as p, base64$1 as q, base256emoji$1 as r, debug as s };
+export { EConnectionStateEvents as E, Protocols as P, SendError as S, Tags as T, EPeersByDiscoveryEvents as a, base2$1 as b, base8$1 as c, base10$1 as d, base16$1 as e, base32$1 as f, getDefaultExportFromCjs as g, base36$1 as h, identityBase as i, base58 as j, base64$1 as k, base256emoji$1 as l, debug as m };