@waku/enr 0.0.16 → 0.0.18

package/bundle/index.js

@@ -22,7 +22,7 @@ function asUint8Array(buf) {
 // 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) {
+function base$1 (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++) {
@@ -139,9 +139,9 @@ function base (ALPHABET, name) {
     decode: decode
   }
 }
-var src = base;
+var src$1 = base$1;
 
-var _brrp__multiformats_scope_baseX = src;
+var _brrp__multiformats_scope_baseX$1 = src$1;
 
 /**
  * @param {Uint8Array} aa
@@ -166,7 +166,7 @@ const equals$2 = (aa, bb) => {
  * @param {ArrayBufferView|ArrayBuffer|Uint8Array} o
  * @returns {Uint8Array}
  */
-const coerce = o => {
+const coerce$1 = o => {
   if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array') return o
   if (o instanceof ArrayBuffer) return new Uint8Array(o)
   if (ArrayBuffer.isView(o)) {
@@ -179,7 +179,7 @@ const coerce = o => {
  * @param {string} str
  * @returns {Uint8Array}
  */
-const fromString$2 = str => (new TextEncoder()).encode(str);
+const fromString$1 = str => (new TextEncoder()).encode(str);
 
 /**
  * @param {Uint8Array} b
@@ -198,7 +198,7 @@ const toString$2 = b => (new TextDecoder()).decode(b);
  * @implements {API.MultibaseEncoder<Prefix>}
  * @implements {API.BaseEncoder}
  */
-class Encoder {
+let Encoder$1 = class Encoder {
   /**
    * @param {Base} name
    * @param {Prefix} prefix
@@ -221,7 +221,7 @@ class Encoder {
       throw Error('Unknown type, must be binary type')
     }
   }
-}
+};
 
 /**
  * @template {string} Prefix
@@ -238,7 +238,7 @@ class Encoder {
  * @implements {API.UnibaseDecoder<Prefix>}
  * @implements {API.BaseDecoder}
  */
-class Decoder {
+let Decoder$1 = class Decoder {
   /**
    * @param {Base} name
    * @param {Prefix} prefix
@@ -276,9 +276,9 @@ class Decoder {
    * @returns {ComposedDecoder<Prefix|OtherPrefix>}
    */
   or (decoder) {
-    return or(this, decoder)
+    return or$1(this, decoder)
   }
-}
+};
 
 /**
  * @template {string} Prefix
@@ -290,7 +290,7 @@ class Decoder {
  * @implements {API.MultibaseDecoder<Prefix>}
  * @implements {API.CombobaseDecoder<Prefix>}
  */
-class ComposedDecoder {
+let ComposedDecoder$1 = class ComposedDecoder {
   /**
    * @param {Decoders<Prefix>} decoders
    */
@@ -304,7 +304,7 @@ class ComposedDecoder {
    * @returns {ComposedDecoder<Prefix|OtherPrefix>}
    */
   or (decoder) {
-    return or(this, decoder)
+    return or$1(this, decoder)
   }
 
   /**
@@ -320,7 +320,7 @@ class ComposedDecoder {
       throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`)
     }
   }
-}
+};
 
 /**
  * @template {string} L
@@ -329,7 +329,7 @@ class ComposedDecoder {
  * @param {API.UnibaseDecoder<R>|API.CombobaseDecoder<R>} right
  * @returns {ComposedDecoder<L|R>}
  */
-const or = (left, right) => new ComposedDecoder(/** @type {Decoders<L|R>} */({
+const or$1 = (left, right) => new ComposedDecoder$1(/** @type {Decoders<L|R>} */({
   ...(left.decoders || { [/** @type API.UnibaseDecoder<L> */(left).prefix]: left }),
   ...(right.decoders || { [/** @type API.UnibaseDecoder<R> */(right).prefix]: right })
 }));
@@ -345,7 +345,7 @@ const or = (left, right) => new ComposedDecoder(/** @type {Decoders<L|R>} */({
  * @implements {API.BaseEncoder}
  * @implements {API.BaseDecoder}
  */
-class Codec {
+let Codec$1 = class Codec {
   /**
    * @param {Base} name
    * @param {Prefix} prefix
@@ -357,8 +357,8 @@ class Codec {
     this.prefix = prefix;
     this.baseEncode = baseEncode;
     this.baseDecode = baseDecode;
-    this.encoder = new Encoder(name, prefix, baseEncode);
-    this.decoder = new Decoder(name, prefix, baseDecode);
+    this.encoder = new Encoder$1(name, prefix, baseEncode);
+    this.decoder = new Decoder$1(name, prefix, baseDecode);
   }
 
   /**
@@ -374,7 +374,7 @@ class Codec {
   decode (input) {
     return this.decoder.decode(input)
   }
-}
+};
 
 /**
  * @template {string} Base
@@ -386,8 +386,8 @@ class Codec {
  * @param {(input:string) => Uint8Array} options.decode
  * @returns {Codec<Base, Prefix>}
  */
-const from$1 = ({ name, prefix, encode, decode }) =>
-  new Codec(name, prefix, encode, decode);
+const from$3 = ({ name, prefix, encode, decode }) =>
+  new Codec$1(name, prefix, encode, decode);
 
 /**
  * @template {string} Base
@@ -398,16 +398,16 @@ const from$1 = ({ name, prefix, encode, decode }) =>
  * @param {string} options.alphabet
  * @returns {Codec<Base, Prefix>}
  */
-const baseX = ({ prefix, name, alphabet }) => {
-  const { encode, decode } = _brrp__multiformats_scope_baseX(alphabet, name);
-  return from$1({
+const baseX$1 = ({ prefix, name, alphabet }) => {
+  const { encode, decode } = _brrp__multiformats_scope_baseX$1(alphabet, name);
+  return from$3({
     prefix,
     name,
     encode,
     /**
      * @param {string} text
      */
-    decode: text => coerce(decode(text))
+    decode: text => coerce$1(decode(text))
   })
 };
 
@@ -418,7 +418,7 @@ const baseX = ({ prefix, name, alphabet }) => {
  * @param {string} name
  * @returns {Uint8Array}
  */
-const decode$6 = (string, alphabet, bitsPerChar, name) => {
+const decode$8 = (string, alphabet, bitsPerChar, name) => {
   // Build the character lookup table:
   /** @type {Record<string, number>} */
   const codes = {};
@@ -471,7 +471,7 @@ const decode$6 = (string, alphabet, bitsPerChar, name) => {
  * @param {number} bitsPerChar
  * @returns {string}
  */
-const encode$5 = (data, alphabet, bitsPerChar) => {
+const encode$8 = (data, alphabet, bitsPerChar) => {
   const pad = alphabet[alphabet.length - 1] === '=';
   const mask = (1 << bitsPerChar) - 1;
   let out = '';
@@ -516,62 +516,20 @@ const encode$5 = (data, alphabet, bitsPerChar) => {
  * @param {string} options.alphabet
  * @param {number} options.bitsPerChar
  */
-const rfc4648 = ({ name, prefix, bitsPerChar, alphabet }) => {
-  return from$1({
+const rfc4648$1 = ({ name, prefix, bitsPerChar, alphabet }) => {
+  return from$3({
     prefix,
     name,
     encode (input) {
-      return encode$5(input, alphabet, bitsPerChar)
+      return encode$8(input, alphabet, bitsPerChar)
     },
     decode (input) {
-      return decode$6(input, alphabet, bitsPerChar, name)
+      return decode$8(input, alphabet, bitsPerChar, name)
     }
   })
 };
 
-// @ts-check
-
-const identity$1 = from$1({
-  prefix: '\x00',
-  name: 'identity',
-  encode: (buf) => toString$2(buf),
-  decode: (str) => fromString$2(str)
-});
-
-var identityBase = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    identity: identity$1
-});
-
-// @ts-check
-
-const base2 = rfc4648({
-  prefix: '0',
-  name: 'base2',
-  alphabet: '01',
-  bitsPerChar: 1
-});
-
-var base2$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base2: base2
-});
-
-// @ts-check
-
-const base8 = rfc4648({
-  prefix: '7',
-  name: 'base8',
-  alphabet: '01234567',
-  bitsPerChar: 3
-});
-
-var base8$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base8: base8
-});
-
-const base10 = baseX({
+const base10 = baseX$1({
   prefix: '9',
   name: 'base10',
   alphabet: '0123456789'
@@ -584,14 +542,15 @@ var base10$1 = /*#__PURE__*/Object.freeze({
 
 // @ts-check
 
-const base16 = rfc4648({
+
+const base16 = rfc4648$1({
   prefix: 'f',
   name: 'base16',
   alphabet: '0123456789abcdef',
   bitsPerChar: 4
 });
 
-const base16upper = rfc4648({
+const base16upper = rfc4648$1({
   prefix: 'F',
   name: 'base16upper',
   alphabet: '0123456789ABCDEF',
@@ -604,63 +563,121 @@ var base16$1 = /*#__PURE__*/Object.freeze({
     base16upper: base16upper
 });
 
-const base32 = rfc4648({
+// @ts-check
+
+
+const base2 = rfc4648$1({
+  prefix: '0',
+  name: 'base2',
+  alphabet: '01',
+  bitsPerChar: 1
+});
+
+var base2$1 = /*#__PURE__*/Object.freeze({
+    __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$7 (data) {
+  return data.reduce((p, c) => {
+    p += alphabetBytesToChars[c];
+    return p
+  }, '')
+}
+
+/**
+ * @param {string} str
+ * @returns {Uint8Array}
+ */
+function decode$7 (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}`)
+    }
+    byts.push(byt);
+  }
+  return new Uint8Array(byts)
+}
+
+const base256emoji = from$3({
+  prefix: '🚀',
+  name: 'base256emoji',
+  encode: encode$7,
+  decode: decode$7
+});
+
+var base256emoji$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base256emoji: base256emoji
+});
+
+const base32 = rfc4648$1({
   prefix: 'b',
   name: 'base32',
   alphabet: 'abcdefghijklmnopqrstuvwxyz234567',
   bitsPerChar: 5
 });
 
-const base32upper = rfc4648({
+const base32upper = rfc4648$1({
   prefix: 'B',
   name: 'base32upper',
   alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
   bitsPerChar: 5
 });
 
-const base32pad = rfc4648({
+const base32pad = rfc4648$1({
   prefix: 'c',
   name: 'base32pad',
   alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',
   bitsPerChar: 5
 });
 
-const base32padupper = rfc4648({
+const base32padupper = rfc4648$1({
   prefix: 'C',
   name: 'base32padupper',
   alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',
   bitsPerChar: 5
 });
 
-const base32hex = rfc4648({
+const base32hex = rfc4648$1({
   prefix: 'v',
   name: 'base32hex',
   alphabet: '0123456789abcdefghijklmnopqrstuv',
   bitsPerChar: 5
 });
 
-const base32hexupper = rfc4648({
+const base32hexupper = rfc4648$1({
   prefix: 'V',
   name: 'base32hexupper',
   alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',
   bitsPerChar: 5
 });
 
-const base32hexpad = rfc4648({
+const base32hexpad = rfc4648$1({
   prefix: 't',
   name: 'base32hexpad',
   alphabet: '0123456789abcdefghijklmnopqrstuv=',
   bitsPerChar: 5
 });
 
-const base32hexpadupper = rfc4648({
+const base32hexpadupper = rfc4648$1({
   prefix: 'T',
   name: 'base32hexpadupper',
   alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',
   bitsPerChar: 5
 });
 
-const base32z = rfc4648({
+const base32z = rfc4648$1({
   prefix: 'h',
   name: 'base32z',
   alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',
@@ -680,13 +697,13 @@ var base32$1 = /*#__PURE__*/Object.freeze({
     base32z: base32z
 });
 
-const base36 = baseX({
+const base36 = baseX$1({
   prefix: 'k',
   name: 'base36',
   alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'
 });
 
-const base36upper = baseX({
+const base36upper = baseX$1({
   prefix: 'K',
   name: 'base36upper',
   alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
@@ -698,13 +715,13 @@ var base36$1 = /*#__PURE__*/Object.freeze({
     base36upper: base36upper
 });
 
-const base58btc = baseX({
+const base58btc$1 = baseX$1({
   name: 'base58btc',
   prefix: 'z',
   alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
 });
 
-const base58flickr = baseX({
+const base58flickr = baseX$1({
   name: 'base58flickr',
   prefix: 'Z',
   alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
@@ -712,119 +729,117 @@ const base58flickr = baseX({
 
 var base58 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    base58btc: base58btc,
+    base58btc: base58btc$1,
     base58flickr: base58flickr
 });
 
 // @ts-check
 
-const base64$2 = rfc4648({
+
+const base64$3 = rfc4648$1({
   prefix: 'm',
   name: 'base64',
   alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
   bitsPerChar: 6
 });
 
-const base64pad = rfc4648({
+const base64pad = rfc4648$1({
   prefix: 'M',
   name: 'base64pad',
   alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
   bitsPerChar: 6
 });
 
-const base64url = rfc4648({
+const base64url = rfc4648$1({
   prefix: 'u',
   name: 'base64url',
   alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
   bitsPerChar: 6
 });
 
-const base64urlpad = rfc4648({
+const base64urlpad = rfc4648$1({
   prefix: 'U',
   name: 'base64urlpad',
   alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',
   bitsPerChar: 6
 });
 
-var base64$3 = /*#__PURE__*/Object.freeze({
+var base64$4 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    base64: base64$2,
+    base64: base64$3,
     base64pad: base64pad,
     base64url: base64url,
     base64urlpad: base64urlpad
 });
 
-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[]} */([])));
+// @ts-check
 
-/**
- * @param {Uint8Array} data
- * @returns {string}
- */
-function encode$4 (data) {
-  return data.reduce((p, c) => {
-    p += alphabetBytesToChars[c];
-    return p
-  }, '')
-}
 
-/**
- * @param {string} str
- * @returns {Uint8Array}
- */
-function decode$5 (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}`)
-    }
-    byts.push(byt);
-  }
-  return new Uint8Array(byts)
-}
+const base8 = rfc4648$1({
+  prefix: '7',
+  name: 'base8',
+  alphabet: '01234567',
+  bitsPerChar: 3
+});
 
-const base256emoji = from$1({
-  prefix: '🚀',
-  name: 'base256emoji',
-  encode: encode$4,
-  decode: decode$5
+var base8$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base8: base8
 });
 
-var base256emoji$1 = /*#__PURE__*/Object.freeze({
+// @ts-check
+
+
+const identity$2 = from$3({
+  prefix: '\x00',
+  name: 'identity',
+  encode: (buf) => toString$2(buf),
+  decode: (str) => fromString$1(str)
+});
+
+var identityBase = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    base256emoji: base256emoji
+    identity: identity$2
 });
 
-var encode_1$1 = encode$3;
+// @ts-check
+
+/**
+ * @template T
+ * @typedef {import('./interface.js').ByteView<T>} ByteView
+ */
+
+new TextEncoder();
+new TextDecoder();
+
+var encode_1$1 = encode$6;
 
-var MSB$2 = 0x80
-  , REST$2 = 0x7F
-  , MSBALL$1 = ~REST$2
+var MSB$3 = 0x80
+  , REST$3 = 0x7F
+  , MSBALL$1 = ~REST$3
   , INT$1 = Math.pow(2, 31);
 
-function encode$3(num, out, offset) {
+function encode$6(num, out, offset) {
   out = out || [];
   offset = offset || 0;
   var oldOffset = offset;
 
   while(num >= INT$1) {
-    out[offset++] = (num & 0xFF) | MSB$2;
+    out[offset++] = (num & 0xFF) | MSB$3;
     num /= 128;
   }
   while(num & MSBALL$1) {
-    out[offset++] = (num & 0xFF) | MSB$2;
+    out[offset++] = (num & 0xFF) | MSB$3;
     num >>>= 7;
   }
   out[offset] = num | 0;
   
-  encode$3.bytes = offset - oldOffset + 1;
+  encode$6.bytes = offset - oldOffset + 1;
   
   return out
 }
 
-var decode$4 = read$1;
+var decode$6 = read$1;
 
 var MSB$1$1 = 0x80
   , REST$1$1 = 0x7F;
@@ -854,47 +869,47 @@ function read$1(buf, offset) {
   return res
 }
 
-var N1$1 = Math.pow(2,  7);
-var N2$1 = Math.pow(2, 14);
-var N3$1 = Math.pow(2, 21);
-var N4$1 = Math.pow(2, 28);
-var N5$1 = Math.pow(2, 35);
-var N6$1 = Math.pow(2, 42);
-var N7$1 = Math.pow(2, 49);
+var N1$2 = Math.pow(2,  7);
+var N2$2 = Math.pow(2, 14);
+var N3$2 = Math.pow(2, 21);
+var N4$2 = Math.pow(2, 28);
+var N5$2 = Math.pow(2, 35);
+var N6$2 = Math.pow(2, 42);
+var N7$2 = Math.pow(2, 49);
 var N8$1 = Math.pow(2, 56);
 var N9$1 = Math.pow(2, 63);
 
 var length$1 = function (value) {
   return (
-    value < N1$1 ? 1
-  : value < N2$1 ? 2
-  : value < N3$1 ? 3
-  : value < N4$1 ? 4
-  : value < N5$1 ? 5
-  : value < N6$1 ? 6
-  : value < N7$1 ? 7
+    value < N1$2 ? 1
+  : value < N2$2 ? 2
+  : value < N3$2 ? 3
+  : value < N4$2 ? 4
+  : value < N5$2 ? 5
+  : value < N6$2 ? 6
+  : value < N7$2 ? 7
   : value < N8$1 ? 8
   : value < N9$1 ? 9
   :              10
   )
 };
 
-var varint$2 = {
+var varint$1 = {
     encode: encode_1$1
-  , decode: decode$4
+  , decode: decode$6
   , encodingLength: length$1
 };
 
-var _brrp_varint = varint$2;
+var _brrp_varint$1 = varint$1;
 
 /**
  * @param {Uint8Array} data
  * @param {number} [offset=0]
  * @returns {[number, number]}
  */
-const decode$3 = (data, offset = 0) => {
-  const code = _brrp_varint.decode(data, offset);
-  return [code, _brrp_varint.decode.bytes]
+const decode$5 = (data, offset = 0) => {
+  const code = _brrp_varint$1.decode(data, offset);
+  return [code, _brrp_varint$1.decode.bytes]
 };
 
 /**
@@ -902,8 +917,8 @@ const decode$3 = (data, offset = 0) => {
  * @param {Uint8Array} target
  * @param {number} [offset=0]
  */
-const encodeTo = (int, target, offset = 0) => {
-  _brrp_varint.encode(int, target, offset);
+const encodeTo$1 = (int, target, offset = 0) => {
+  _brrp_varint$1.encode(int, target, offset);
   return target
 };
 
@@ -911,8 +926,8 @@ const encodeTo = (int, target, offset = 0) => {
  * @param {number} int
  * @returns {number}
  */
-const encodingLength = (int) => {
-  return _brrp_varint.encodingLength(int)
+const encodingLength$2 = (int) => {
+  return _brrp_varint$1.encodingLength(int)
 };
 
 /**
@@ -922,17 +937,17 @@ const encodingLength = (int) => {
  * @param {Code} code
  * @param {Uint8Array} digest
  */
-const create$3 = (code, digest) => {
+const create$4 = (code, digest) => {
   const size = digest.byteLength;
-  const sizeOffset = encodingLength(code);
-  const digestOffset = sizeOffset + encodingLength(size);
+  const sizeOffset = encodingLength$2(code);
+  const digestOffset = sizeOffset + encodingLength$2(size);
 
   const bytes = new Uint8Array(digestOffset + size);
-  encodeTo(code, bytes, 0);
-  encodeTo(size, bytes, sizeOffset);
+  encodeTo$1(code, bytes, 0);
+  encodeTo$1(size, bytes, sizeOffset);
   bytes.set(digest, digestOffset);
 
-  return new Digest(code, size, digest, bytes)
+  return new Digest$1(code, size, digest, bytes)
 };
 
 /**
@@ -941,17 +956,17 @@ const create$3 = (code, digest) => {
  * @param {Uint8Array} multihash
  * @returns {MultihashDigest}
  */
-const decode$2 = (multihash) => {
-  const bytes = coerce(multihash);
-  const [code, sizeOffset] = decode$3(bytes);
-  const [size, digestOffset] = decode$3(bytes.subarray(sizeOffset));
+const decode$4 = (multihash) => {
+  const bytes = coerce$1(multihash);
+  const [code, sizeOffset] = decode$5(bytes);
+  const [size, digestOffset] = decode$5(bytes.subarray(sizeOffset));
   const digest = bytes.subarray(sizeOffset + digestOffset);
 
   if (digest.byteLength !== size) {
     throw new Error('Incorrect length')
   }
 
-  return new Digest(code, size, digest, bytes)
+  return new Digest$1(code, size, digest, bytes)
 };
 
 /**
@@ -987,7 +1002,7 @@ const equals$1 = (a, b) => {
  * @class
  * @implements {MultihashDigest}
  */
-class Digest {
+let Digest$1 = class Digest {
   /**
    * Creates a multihash digest.
    *
@@ -1002,7 +1017,21 @@ class Digest {
     this.digest = digest;
     this.bytes = bytes;
   }
-}
+};
+
+const code$1 = 0x0;
+const name$1 = 'identity';
+
+/** @type {(input:Uint8Array) => Uint8Array} */
+const encode$5 = coerce$1;
+
+/**
+ * @param {Uint8Array} input
+ * @returns {Digest.Digest<typeof code, number>}
+ */
+const digest$1 = (input) => create$4(code$1, encode$5(input));
+
+const identity$1 = { code: code$1, name: name$1, encode: encode$5, digest: digest$1 };
 
 /**
  * @template {string} Name
@@ -1012,7 +1041,7 @@ class Digest {
  * @param {Code} options.code
  * @param {(input: Uint8Array) => Await<Uint8Array>} options.encode
  */
-const from = ({ name, code, encode }) => new Hasher(name, code, encode);
+const from$2 = ({ name, code, encode }) => new Hasher$1(name, code, encode);
 
 /**
  * Hasher represents a hashing algorithm implementation that produces as
@@ -1023,7 +1052,7 @@ const from = ({ name, code, encode }) => new Hasher(name, code, encode);
  * @class
  * @implements {MultihashHasher<Code>}
  */
-class Hasher {
+let Hasher$1 = class Hasher {
   /**
    *
    * @param {Name} name
@@ -1044,15 +1073,15 @@ class Hasher {
     if (input instanceof Uint8Array) {
       const result = this.encode(input);
       return result instanceof Uint8Array
-        ? create$3(this.code, result)
+        ? create$4(this.code, result)
         /* c8 ignore next 1 */
-        : result.then(digest => create$3(this.code, digest))
+        : result.then(digest => create$4(this.code, digest))
     } else {
       throw Error('Unknown type, must be binary type')
       /* c8 ignore next 1 */
     }
   }
-}
+};
 
 /**
  * @template {number} Alg
@@ -1066,45 +1095,22 @@ class Hasher {
 
 /* global crypto */
 
+
 /**
  * @param {AlgorithmIdentifier} name
  */
-const sha = name =>
+const sha$1 = name =>
   /**
    * @param {Uint8Array} data
    */
   async data => new Uint8Array(await crypto.subtle.digest(name, data));
 
-const sha256$1 = from({
+const sha256$2 = from$2({
   name: 'sha2-256',
   code: 0x12,
-  encode: sha('SHA-256')
+  encode: sha$1('SHA-256')
 });
 
-const code = 0x0;
-const name = 'identity';
-
-/** @type {(input:Uint8Array) => Uint8Array} */
-const encode$2 = coerce;
-
-/**
- * @param {Uint8Array} input
- * @returns {Digest.Digest<typeof code, number>}
- */
-const digest = (input) => create$3(code, encode$2(input));
-
-const identity = { code, name, encode: encode$2, digest };
-
-// @ts-check
-
-/**
- * @template T
- * @typedef {import('./interface.js').ByteView<T>} ByteView
- */
-
-new TextEncoder();
-new TextDecoder();
-
 /**
  * @template {API.Link<unknown, number, number, API.Version>} T
  * @template {string} Prefix
@@ -1119,7 +1125,7 @@ const format = (link, base) => {
       return toStringV0(
         bytes,
         baseCache(link),
-        /** @type {API.MultibaseEncoder<"z">} */ (base) || base58btc.encoder
+        /** @type {API.MultibaseEncoder<"z">} */ (base) || base58btc$1.encoder
       )
     default:
       return toStringV1(
@@ -1161,7 +1167,6 @@ class CID {
    * @param {Format} code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
    * @param {API.MultihashDigest<Alg>} multihash - (Multi)hash of the of the content.
    * @param {Uint8Array} bytes
-   *
    */
   constructor (version, code, multihash, bytes) {
     /** @readonly */
@@ -1240,7 +1245,7 @@ class CID {
     switch (this.version) {
       case 0: {
         const { code, digest } = this.multihash;
-        const multihash = create$3(code, digest);
+        const multihash = create$4(code, digest);
         return /** @type {CID<Data, Format, Alg, 1>} */ (
           CID.createV1(this.code, multihash)
         )
@@ -1294,6 +1299,9 @@ class CID {
     return format(this, base)
   }
 
+  /**
+   * @returns {API.LinkJSON<this>}
+   */
   toJSON () {
     return { '/': format(this) }
   }
@@ -1359,7 +1367,7 @@ class CID {
       const { version, multihash, code } = value;
       const digest =
         /** @type {API.MultihashDigest<Alg>} */
-        (decode$2(multihash));
+        (decode$4(multihash));
       return CID.create(version, code, digest)
     } else {
       // Otherwise value is not a CID (or an incompatible version of it) in
@@ -1474,7 +1482,7 @@ class CID {
   static decodeFirst (bytes) {
     const specs = CID.inspectBytes(bytes);
     const prefixSize = specs.size - specs.multihashSize;
-    const multihashBytes = coerce(
+    const multihashBytes = coerce$1(
       bytes.subarray(prefixSize, prefixSize + specs.multihashSize)
     );
     if (multihashBytes.byteLength !== specs.multihashSize) {
@@ -1483,7 +1491,7 @@ class CID {
     const digestBytes = multihashBytes.subarray(
       specs.multihashSize - specs.digestSize
     );
-    const digest = new Digest(
+    const digest = new Digest$1(
       specs.multihashCode,
       specs.digestSize,
       digestBytes,
@@ -1515,7 +1523,7 @@ class CID {
   static inspectBytes (initialBytes) {
     let offset = 0;
     const next = () => {
-      const [i, length] = decode$3(initialBytes.subarray(offset));
+      const [i, length] = decode$5(initialBytes.subarray(offset));
       offset += length;
       return i
     };
@@ -1588,15 +1596,15 @@ const parseCIDtoBytes = (source, base) => {
   switch (source[0]) {
     // CIDv0 is parsed differently
     case 'Q': {
-      const decoder = base || base58btc;
+      const decoder = base || base58btc$1;
       return [
-        /** @type {Prefix} */ (base58btc.prefix),
-        decoder.decode(`${base58btc.prefix}${source}`)
+        /** @type {Prefix} */ (base58btc$1.prefix),
+        decoder.decode(`${base58btc$1.prefix}${source}`)
       ]
     }
-    case base58btc.prefix: {
-      const decoder = base || base58btc;
-      return [/** @type {Prefix} */(base58btc.prefix), decoder.decode(source)]
+    case base58btc$1.prefix: {
+      const decoder = base || base58btc$1;
+      return [/** @type {Prefix} */(base58btc$1.prefix), decoder.decode(source)]
     }
     case base32.prefix: {
       const decoder = base || base32;
@@ -1621,7 +1629,7 @@ const parseCIDtoBytes = (source, base) => {
  */
 const toStringV0 = (bytes, cache, base) => {
   const { prefix } = base;
-  if (prefix !== base58btc.prefix) {
+  if (prefix !== base58btc$1.prefix) {
     throw Error(`Cannot string encode V0 in ${base.name} encoding`)
   }
 
@@ -1663,11 +1671,11 @@ const SHA_256_CODE = 0x12;
  * @returns {Uint8Array}
  */
 const encodeCID = (version, code, multihash) => {
-  const codeOffset = encodingLength(version);
-  const hashOffset = codeOffset + encodingLength(code);
+  const codeOffset = encodingLength$2(version);
+  const hashOffset = codeOffset + encodingLength$2(code);
   const bytes = new Uint8Array(hashOffset + multihash.byteLength);
-  encodeTo(version, bytes, 0);
-  encodeTo(code, bytes, codeOffset);
+  encodeTo$1(version, bytes, 0);
+  encodeTo$1(code, bytes, codeOffset);
   bytes.set(multihash, hashOffset);
   return bytes
 };
@@ -1676,7 +1684,8 @@ const cidSymbol = Symbol.for('@ipld/js-cid/CID');
 
 // @ts-check
 
-const bases = { ...identityBase, ...base2$1, ...base8$1, ...base10$1, ...base16$1, ...base32$1, ...base36$1, ...base58, ...base64$3, ...base256emoji$1 };
+
+const bases = { ...identityBase, ...base2$1, ...base8$1, ...base10$1, ...base16$1, ...base32$1, ...base36$1, ...base58, ...base64$4, ...base256emoji$1 };
 
 /**
  * Where possible returns a Uint8Array of the requested size that references
@@ -1742,7 +1751,7 @@ const BASES = {
  *
  * Also `ascii` which is similar to node's 'binary' encoding.
  */
-function fromString$1(string, encoding = 'utf8') {
+function fromString(string, encoding = 'utf8') {
     const base = BASES[encoding];
     if (base == null) {
         throw new Error(`Unsupported encoding "${encoding}"`);
@@ -1781,7 +1790,7 @@ function toString$1(array, encoding = 'utf8') {
 function hexToBytes$2(hex) {
     if (typeof hex === "string") {
         const _hex = hex.replace(/^0x/i, "");
-        return fromString$1(_hex.toLowerCase(), "base16");
+        return fromString(_hex.toLowerCase(), "base16");
     }
     return hex;
 }
@@ -1796,7 +1805,7 @@ const bytesToUtf8 = (b) => toString$1(b, "utf8");
 /**
  * Encode utf-8 string to byte array.
  */
-const utf8ToBytes = (s) => fromString$1(s, "utf8");
+const utf8ToBytes = (s) => fromString(s, "utf8");
 /**
  * Concatenate using Uint8Arrays as `Buffer` has a different behavior with `DataView`
  */
@@ -2868,10 +2877,7 @@ function getAugmentedNamespace(n) {
 	if (typeof f == "function") {
 		var a = function a () {
 			if (this instanceof a) {
-				var args = [null];
-				args.push.apply(args, arguments);
-				var Ctor = Function.bind.apply(f, args);
-				return new Ctor();
+        return Reflect.construct(f, arguments, this.constructor);
 			}
 			return f.apply(this, arguments);
 		};
@@ -2895,9 +2901,9 @@ var sha3$1 = {exports: {}};
 /**
  * [js-sha3]{@link https://github.com/emn178/js-sha3}
  *
- * @version 0.8.0
+ * @version 0.9.2
  * @author Chen, Yi-Cyuan [emn178@gmail.com]
- * @copyright Chen, Yi-Cyuan 2015-2018
+ * @copyright Chen, Yi-Cyuan 2015-2023
  * @license MIT
  */
 
@@ -2940,17 +2946,40 @@ var sha3$1 = {exports: {}};
 	    '256': 136
 	  };
 
-	  if (root.JS_SHA3_NO_NODE_JS || !Array.isArray) {
-	    Array.isArray = function (obj) {
-	      return Object.prototype.toString.call(obj) === '[object Array]';
-	    };
-	  }
 
-	  if (ARRAY_BUFFER && (root.JS_SHA3_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView)) {
-	    ArrayBuffer.isView = function (obj) {
-	      return typeof obj === 'object' && obj.buffer && obj.buffer.constructor === ArrayBuffer;
-	    };
-	  }
+	  var isArray = root.JS_SHA3_NO_NODE_JS || !Array.isArray
+	    ? function (obj) {
+	        return Object.prototype.toString.call(obj) === '[object Array]';
+	      }
+	    : Array.isArray;
+
+	  var isView = (ARRAY_BUFFER && (root.JS_SHA3_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView))
+	    ? function (obj) {
+	        return typeof obj === 'object' && obj.buffer && obj.buffer.constructor === ArrayBuffer;
+	      }
+	    : ArrayBuffer.isView;
+
+	  // [message: string, isString: bool]
+	  var formatMessage = function (message) {
+	    var type = typeof message;
+	    if (type === 'string') {
+	      return [message, true];
+	    }
+	    if (type !== 'object' || message === null) {
+	      throw new Error(INPUT_ERROR);
+	    }
+	    if (ARRAY_BUFFER && message.constructor === ArrayBuffer) {
+	      return [new Uint8Array(message), false];
+	    }
+	    if (!isArray(message) && !isView(message)) {
+	      throw new Error(INPUT_ERROR);
+	    }
+	    return [message, false];
+	  };
+
+	  var empty = function (message) {
+	    return formatMessage(message)[0].length === 0;
+	  };
 
 	  var createOutputMethod = function (bits, padding, outputType) {
 	    return function (message) {
@@ -3010,7 +3039,7 @@ var sha3$1 = {exports: {}};
 	    var w = CSHAKE_BYTEPAD[bits];
 	    var method = createCshakeOutputMethod(bits, padding, 'hex');
 	    method.create = function (outputBits, n, s) {
-	      if (!n && !s) {
+	      if (empty(n) && empty(s)) {
 	        return methods['shake' + bits].create(outputBits);
 	      } else {
 	        return new Keccak(bits, padding, outputBits).bytepad([n, s], w);
@@ -3082,23 +3111,9 @@ var sha3$1 = {exports: {}};
 	    if (this.finalized) {
 	      throw new Error(FINALIZE_ERROR);
 	    }
-	    var notString, type = typeof message;
-	    if (type !== 'string') {
-	      if (type === 'object') {
-	        if (message === null) {
-	          throw new Error(INPUT_ERROR);
-	        } else if (ARRAY_BUFFER && message.constructor === ArrayBuffer) {
-	          message = new Uint8Array(message);
-	        } else if (!Array.isArray(message)) {
-	          if (!ARRAY_BUFFER || !ArrayBuffer.isView(message)) {
-	            throw new Error(INPUT_ERROR);
-	          }
-	        }
-	      } else {
-	        throw new Error(INPUT_ERROR);
-	      }
-	      notString = true;
-	    }
+	    var result = formatMessage(message);
+	    message = result[0];
+	    var isString = result[1];
 	    var blocks = this.blocks, byteCount = this.byteCount, length = message.length,
 	      blockCount = this.blockCount, index = 0, s = this.s, i, code;
 
@@ -3110,11 +3125,7 @@ var sha3$1 = {exports: {}};
 	          blocks[i] = 0;
 	        }
 	      }
-	      if (notString) {
-	        for (i = this.start; index < length && i < byteCount; ++index) {
-	          blocks[i >> 2] |= message[index] << SHIFT[i++ & 3];
-	        }
-	      } else {
+	      if (isString) {
 	        for (i = this.start; index < length && i < byteCount; ++index) {
 	          code = message.charCodeAt(index);
 	          if (code < 0x80) {
@@ -3134,6 +3145,10 @@ var sha3$1 = {exports: {}};
 	            blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
 	          }
 	        }
+	      } else {
+	        for (i = this.start; index < length && i < byteCount; ++index) {
+	          blocks[i >> 2] |= message[index] << SHIFT[i++ & 3];
+	        }
 	      }
 	      this.lastByteIndex = i;
 	      if (i >= byteCount) {
@@ -3172,27 +3187,11 @@ var sha3$1 = {exports: {}};
 	  };
 
 	  Keccak.prototype.encodeString = function (str) {
-	    var notString, type = typeof str;
-	    if (type !== 'string') {
-	      if (type === 'object') {
-	        if (str === null) {
-	          throw new Error(INPUT_ERROR);
-	        } else if (ARRAY_BUFFER && str.constructor === ArrayBuffer) {
-	          str = new Uint8Array(str);
-	        } else if (!Array.isArray(str)) {
-	          if (!ARRAY_BUFFER || !ArrayBuffer.isView(str)) {
-	            throw new Error(INPUT_ERROR);
-	          }
-	        }
-	      } else {
-	        throw new Error(INPUT_ERROR);
-	      }
-	      notString = true;
-	    }
+	    var result = formatMessage(str);
+	    str = result[0];
+	    var isString = result[1];
 	    var bytes = 0, length = str.length;
-	    if (notString) {
-	      bytes = length;
-	    } else {
+	    if (isString) {
 	      for (var i = 0; i < str.length; ++i) {
 	        var code = str.charCodeAt(i);
 	        if (code < 0x80) {
@@ -3206,6 +3205,8 @@ var sha3$1 = {exports: {}};
 	          bytes += 4;
 	        }
 	      }
+	    } else {
+	      bytes = length;
 	    }
 	    bytes += this.encode(bytes * 8);
 	    this.update(str);
@@ -3217,7 +3218,7 @@ var sha3$1 = {exports: {}};
 	    for (var i = 0; i < strs.length; ++i) {
 	      bytes += this.encodeString(strs[i]);
 	    }
-	    var paddingBytes = w - bytes % w;
+	    var paddingBytes = (w - bytes % w) % w;
 	    var zeros = [];
 	    zeros.length = paddingBytes;
 	    this.update(zeros);
@@ -3559,7 +3560,7 @@ var sha3 = /*@__PURE__*/getDefaultExportFromCjs(sha3Exports);
 async function sign$2(message, privateKey) {
     const [signature, recoveryId] = await sign$3(message, privateKey, {
         recovered: true,
-        der: false,
+        der: false
     });
     return concat$1([signature, new Uint8Array([recoveryId])], signature.length + 1);
 }
@@ -4308,6 +4309,281 @@ var common = setup;
 var browserExports = browser.exports;
 var debug = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
+/**
+ * When this error is thrown it means an operation was aborted,
+ * usually in response to the `abort` event being emitted by an
+ * AbortSignal.
+ */
+let CodeError$1 = class CodeError extends Error {
+    code;
+    props;
+    constructor(message, code, props) {
+        super(message);
+        this.code = code;
+        this.name = props?.name ?? 'CodeError';
+        this.props = props ?? {}; // eslint-disable-line @typescript-eslint/consistent-type-assertions
+    }
+};
+
+/**
+ * Returns true if the two passed Uint8Arrays have the same content
+ */
+function equals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a.byteLength !== b.byteLength) {
+        return false;
+    }
+    for (let i = 0; i < a.byteLength; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/* eslint-disable no-fallthrough */
+const N1$1 = Math.pow(2, 7);
+const N2$1 = Math.pow(2, 14);
+const N3$1 = Math.pow(2, 21);
+const N4$1 = Math.pow(2, 28);
+const N5$1 = Math.pow(2, 35);
+const N6$1 = Math.pow(2, 42);
+const N7$1 = Math.pow(2, 49);
+/** Most significant bit of a byte */
+const MSB$2 = 0x80;
+/** Rest of the bits in a byte */
+const REST$2 = 0x7f;
+function encodingLength$1(value) {
+    if (value < N1$1) {
+        return 1;
+    }
+    if (value < N2$1) {
+        return 2;
+    }
+    if (value < N3$1) {
+        return 3;
+    }
+    if (value < N4$1) {
+        return 4;
+    }
+    if (value < N5$1) {
+        return 5;
+    }
+    if (value < N6$1) {
+        return 6;
+    }
+    if (value < N7$1) {
+        return 7;
+    }
+    if (Number.MAX_SAFE_INTEGER != null && value > Number.MAX_SAFE_INTEGER) {
+        throw new RangeError('Could not encode varint');
+    }
+    return 8;
+}
+function encodeUint8Array(value, buf, offset = 0) {
+    switch (encodingLength$1(value)) {
+        case 8: {
+            buf[offset++] = (value & 0xFF) | MSB$2;
+            value /= 128;
+        }
+        case 7: {
+            buf[offset++] = (value & 0xFF) | MSB$2;
+            value /= 128;
+        }
+        case 6: {
+            buf[offset++] = (value & 0xFF) | MSB$2;
+            value /= 128;
+        }
+        case 5: {
+            buf[offset++] = (value & 0xFF) | MSB$2;
+            value /= 128;
+        }
+        case 4: {
+            buf[offset++] = (value & 0xFF) | MSB$2;
+            value >>>= 7;
+        }
+        case 3: {
+            buf[offset++] = (value & 0xFF) | MSB$2;
+            value >>>= 7;
+        }
+        case 2: {
+            buf[offset++] = (value & 0xFF) | MSB$2;
+            value >>>= 7;
+        }
+        case 1: {
+            buf[offset++] = (value & 0xFF);
+            value >>>= 7;
+            break;
+        }
+        default: throw new Error('unreachable');
+    }
+    return buf;
+}
+function encodeUint8ArrayList(value, buf, offset = 0) {
+    switch (encodingLength$1(value)) {
+        case 8: {
+            buf.set(offset++, (value & 0xFF) | MSB$2);
+            value /= 128;
+        }
+        case 7: {
+            buf.set(offset++, (value & 0xFF) | MSB$2);
+            value /= 128;
+        }
+        case 6: {
+            buf.set(offset++, (value & 0xFF) | MSB$2);
+            value /= 128;
+        }
+        case 5: {
+            buf.set(offset++, (value & 0xFF) | MSB$2);
+            value /= 128;
+        }
+        case 4: {
+            buf.set(offset++, (value & 0xFF) | MSB$2);
+            value >>>= 7;
+        }
+        case 3: {
+            buf.set(offset++, (value & 0xFF) | MSB$2);
+            value >>>= 7;
+        }
+        case 2: {
+            buf.set(offset++, (value & 0xFF) | MSB$2);
+            value >>>= 7;
+        }
+        case 1: {
+            buf.set(offset++, (value & 0xFF));
+            value >>>= 7;
+            break;
+        }
+        default: throw new Error('unreachable');
+    }
+    return buf;
+}
+function decodeUint8Array(buf, offset) {
+    let b = buf[offset];
+    let res = 0;
+    res += b & REST$2;
+    if (b < MSB$2) {
+        return res;
+    }
+    b = buf[offset + 1];
+    res += (b & REST$2) << 7;
+    if (b < MSB$2) {
+        return res;
+    }
+    b = buf[offset + 2];
+    res += (b & REST$2) << 14;
+    if (b < MSB$2) {
+        return res;
+    }
+    b = buf[offset + 3];
+    res += (b & REST$2) << 21;
+    if (b < MSB$2) {
+        return res;
+    }
+    b = buf[offset + 4];
+    res += (b & REST$2) * N4$1;
+    if (b < MSB$2) {
+        return res;
+    }
+    b = buf[offset + 5];
+    res += (b & REST$2) * N5$1;
+    if (b < MSB$2) {
+        return res;
+    }
+    b = buf[offset + 6];
+    res += (b & REST$2) * N6$1;
+    if (b < MSB$2) {
+        return res;
+    }
+    b = buf[offset + 7];
+    res += (b & REST$2) * N7$1;
+    if (b < MSB$2) {
+        return res;
+    }
+    throw new RangeError('Could not decode varint');
+}
+function decodeUint8ArrayList(buf, offset) {
+    let b = buf.get(offset);
+    let res = 0;
+    res += b & REST$2;
+    if (b < MSB$2) {
+        return res;
+    }
+    b = buf.get(offset + 1);
+    res += (b & REST$2) << 7;
+    if (b < MSB$2) {
+        return res;
+    }
+    b = buf.get(offset + 2);
+    res += (b & REST$2) << 14;
+    if (b < MSB$2) {
+        return res;
+    }
+    b = buf.get(offset + 3);
+    res += (b & REST$2) << 21;
+    if (b < MSB$2) {
+        return res;
+    }
+    b = buf.get(offset + 4);
+    res += (b & REST$2) * N4$1;
+    if (b < MSB$2) {
+        return res;
+    }
+    b = buf.get(offset + 5);
+    res += (b & REST$2) * N5$1;
+    if (b < MSB$2) {
+        return res;
+    }
+    b = buf.get(offset + 6);
+    res += (b & REST$2) * N6$1;
+    if (b < MSB$2) {
+        return res;
+    }
+    b = buf.get(offset + 7);
+    res += (b & REST$2) * N7$1;
+    if (b < MSB$2) {
+        return res;
+    }
+    throw new RangeError('Could not decode varint');
+}
+function encode$4(value, buf, offset = 0) {
+    if (buf == null) {
+        buf = allocUnsafe(encodingLength$1(value));
+    }
+    if (buf instanceof Uint8Array) {
+        return encodeUint8Array(value, buf, offset);
+    }
+    else {
+        return encodeUint8ArrayList(value, buf, offset);
+    }
+}
+function decode$3(buf, offset = 0) {
+    if (buf instanceof Uint8Array) {
+        return decodeUint8Array(buf, offset);
+    }
+    else {
+        return decodeUint8ArrayList(buf, offset);
+    }
+}
+
+/**
+ * Returns a new Uint8Array created by concatenating the passed ArrayLikes
+ */
+function concat(arrays, length) {
+    if (length == null) {
+        length = arrays.reduce((acc, curr) => acc + curr.length, 0);
+    }
+    const output = allocUnsafe(length);
+    let offset = 0;
+    for (const arr of arrays) {
+        output.set(arr, offset);
+        offset += arr.length;
+    }
+    return asUint8Array(output);
+}
+
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 class Parser {
     index = 0;
@@ -4522,6 +4798,10 @@ function parseIPv4(input) {
 }
 /** Parse `input` into IPv6 bytes. */
 function parseIPv6(input) {
+    // strip zone index if it is present
+    if (input.includes("%")) {
+        input = input.split("%")[0];
+    }
     if (input.length > MAX_IPV6_LENGTH) {
         return undefined;
     }
@@ -4529,6 +4809,10 @@ function parseIPv6(input) {
 }
 /** Parse `input` into IPv4 or IPv6 bytes. */
 function parseIP(input) {
+    // strip zone index if it is present
+    if (input.includes("%")) {
+        input = input.split("%")[0];
+    }
     if (input.length > MAX_IPV6_LENGTH) {
         return undefined;
     }
@@ -4719,116 +5003,6 @@ function getProtocol(proto) {
     throw new Error(`invalid protocol id type: ${typeof proto}`);
 }
 
-var encode_1 = encode$1;
-
-var MSB$1 = 0x80
-  , REST$1 = 0x7F
-  , MSBALL = ~REST$1
-  , INT = Math.pow(2, 31);
-
-function encode$1(num, out, offset) {
-  if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
-    encode$1.bytes = 0;
-    throw new RangeError('Could not encode varint')
-  }
-  out = out || [];
-  offset = offset || 0;
-  var oldOffset = offset;
-
-  while(num >= INT) {
-    out[offset++] = (num & 0xFF) | MSB$1;
-    num /= 128;
-  }
-  while(num & MSBALL) {
-    out[offset++] = (num & 0xFF) | MSB$1;
-    num >>>= 7;
-  }
-  out[offset] = num | 0;
-  
-  encode$1.bytes = offset - oldOffset + 1;
-  
-  return out
-}
-
-var decode$1 = read;
-
-var MSB = 0x80
-  , REST = 0x7F;
-
-function read(buf, offset) {
-  var res    = 0
-    , offset = offset || 0
-    , shift  = 0
-    , counter = offset
-    , b
-    , l = buf.length;
-
-  do {
-    if (counter >= l || shift > 49) {
-      read.bytes = 0;
-      throw new RangeError('Could not decode varint')
-    }
-    b = buf[counter++];
-    res += shift < 28
-      ? (b & REST) << shift
-      : (b & REST) * Math.pow(2, shift);
-    shift += 7;
-  } while (b >= MSB)
-
-  read.bytes = counter - offset;
-
-  return res
-}
-
-var N1 = Math.pow(2,  7);
-var N2 = Math.pow(2, 14);
-var N3 = Math.pow(2, 21);
-var N4 = Math.pow(2, 28);
-var N5 = Math.pow(2, 35);
-var N6 = Math.pow(2, 42);
-var N7 = Math.pow(2, 49);
-var N8 = Math.pow(2, 56);
-var N9 = Math.pow(2, 63);
-
-var length = function (value) {
-  return (
-    value < N1 ? 1
-  : value < N2 ? 2
-  : value < N3 ? 3
-  : value < N4 ? 4
-  : value < N5 ? 5
-  : value < N6 ? 6
-  : value < N7 ? 7
-  : value < N8 ? 8
-  : value < N9 ? 9
-  :              10
-  )
-};
-
-var varint = {
-    encode: encode_1
-  , decode: decode$1
-  , encodingLength: length
-};
-
-var varint$1 = /*@__PURE__*/getDefaultExportFromCjs(varint);
-
-/**
- * Returns a new Uint8Array created by concatenating the passed ArrayLikes
- */
-function concat(arrays, length) {
-    if (length == null) {
-        length = arrays.reduce((acc, curr) => acc + curr.length, 0);
-    }
-    const output = allocUnsafe(length);
-    let offset = 0;
-    for (const arr of arrays) {
-        output.set(arr, offset);
-        offset += arr.length;
-    }
-    return asUint8Array(output);
-}
-
 /**
  * @packageDocumentation
  *
@@ -4904,7 +5078,7 @@ function convertToBytes(proto, str) {
         case 466: // certhash
             return mb2bytes(str);
         default:
-            return fromString$1(str, 'base16'); // no clue. convert from hex
+            return fromString(str, 'base16'); // no clue. convert from hex
     }
 }
 const decoders = Object.values(bases).map((c) => c.decoder);
@@ -4940,13 +5114,13 @@ function bytes2port(buf) {
     return view.getUint16(buf.byteOffset);
 }
 function str2bytes(str) {
-    const buf = fromString$1(str);
-    const size = Uint8Array.from(varint$1.encode(buf.length));
+    const buf = fromString(str);
+    const size = Uint8Array.from(encode$4(buf.length));
     return concat([size, buf], size.length + buf.length);
 }
 function bytes2str(buf) {
-    const size = varint$1.decode(buf);
-    buf = buf.slice(varint$1.decode.bytes);
+    const size = decode$3(buf);
+    buf = buf.slice(encodingLength$1(size));
     if (buf.length !== size) {
         throw new Error('inconsistent lengths');
     }
@@ -4955,23 +5129,23 @@ function bytes2str(buf) {
 function mh2bytes(hash) {
     let mh;
     if (hash[0] === 'Q' || hash[0] === '1') {
-        mh = decode$2(base58btc.decode(`z${hash}`)).bytes;
+        mh = decode$4(base58btc$1.decode(`z${hash}`)).bytes;
     }
     else {
         mh = CID.parse(hash).multihash.bytes;
     }
     // the address is a varint prefixed multihash string representation
-    const size = Uint8Array.from(varint$1.encode(mh.length));
+    const size = Uint8Array.from(encode$4(mh.length));
     return concat([size, mh], size.length + mh.length);
 }
 function mb2bytes(mbstr) {
     const mb = anybaseDecoder.decode(mbstr);
-    const size = Uint8Array.from(varint$1.encode(mb.length));
+    const size = Uint8Array.from(encode$4(mb.length));
     return concat([size, mb], size.length + mb.length);
 }
 function bytes2mb(buf) {
-    const size = varint$1.decode(buf);
-    const hash = buf.slice(varint$1.decode.bytes);
+    const size = decode$3(buf);
+    const hash = buf.slice(encodingLength$1(size));
     if (hash.length !== size) {
         throw new Error('inconsistent lengths');
     }
@@ -4981,8 +5155,8 @@ function bytes2mb(buf) {
  * Converts bytes to bas58btc string
  */
 function bytes2mh(buf) {
-    const size = varint$1.decode(buf);
-    const address = buf.slice(varint$1.decode.bytes);
+    const size = decode$3(buf);
+    const address = buf.slice(encodingLength$1(size));
     if (address.length !== size) {
         throw new Error('inconsistent lengths');
     }
@@ -5032,20 +5206,27 @@ function bytes2onion(buf) {
     return `${addr}:${port}`;
 }
 
-/**
- * string -> [[str name, str addr]... ]
- */
-function stringToStringTuples(str) {
+function stringToMultiaddrParts(str) {
+    str = cleanPath(str);
     const tuples = [];
-    const parts = str.split('/').slice(1); // skip first empty elem
+    const stringTuples = [];
+    let path = null;
+    const parts = str.split('/').slice(1);
     if (parts.length === 1 && parts[0] === '') {
-        return [];
+        return {
+            bytes: new Uint8Array(),
+            string: '/',
+            tuples: [],
+            stringTuples: [],
+            path: null
+        };
     }
     for (let p = 0; p < parts.length; p++) {
         const part = parts[p];
         const proto = getProtocol(part);
         if (proto.size === 0) {
-            tuples.push([part]);
+            tuples.push([proto.code]);
+            stringTuples.push([proto.code]);
             // eslint-disable-next-line no-continue
             continue;
         }
@@ -5055,18 +5236,67 @@ function stringToStringTuples(str) {
         }
         // if it's a path proto, take the rest
         if (proto.path === true) {
-            tuples.push([
-                part,
-                // should we need to check each path part to see if it's a proto?
-                // This would allow for other protocols to be added after a unix path,
-                // however it would have issues if the path had a protocol name in the path
-                cleanPath(parts.slice(p).join('/'))
-            ]);
+            // should we need to check each path part to see if it's a proto?
+            // This would allow for other protocols to be added after a unix path,
+            // however it would have issues if the path had a protocol name in the path
+            path = cleanPath(parts.slice(p).join('/'));
+            tuples.push([proto.code, convertToBytes(proto.code, path)]);
+            stringTuples.push([proto.code, path]);
+            break;
+        }
+        const bytes = convertToBytes(proto.code, parts[p]);
+        tuples.push([proto.code, bytes]);
+        stringTuples.push([proto.code, convertToString(proto.code, bytes)]);
+    }
+    return {
+        string: stringTuplesToString(stringTuples),
+        bytes: tuplesToBytes(tuples),
+        tuples,
+        stringTuples,
+        path
+    };
+}
+function bytesToMultiaddrParts(bytes) {
+    const tuples = [];
+    const stringTuples = [];
+    let path = null;
+    let i = 0;
+    while (i < bytes.length) {
+        const code = decode$3(bytes, i);
+        const n = encodingLength$1(code);
+        const p = getProtocol(code);
+        const size = sizeForAddr(p, bytes.slice(i + n));
+        if (size === 0) {
+            tuples.push([code]);
+            stringTuples.push([code]);
+            i += n;
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        const addr = bytes.slice(i + n, i + n + size);
+        i += (size + n);
+        if (i > bytes.length) { // did not end _exactly_ at buffer.length
+            throw ParseError('Invalid address Uint8Array: ' + toString$1(bytes, 'base16'));
+        }
+        // ok, tuple seems good.
+        tuples.push([code, addr]);
+        const stringAddr = convertToString(code, addr);
+        stringTuples.push([code, stringAddr]);
+        if (p.path === true) {
+            // should we need to check each path part to see if it's a proto?
+            // This would allow for other protocols to be added after a unix path,
+            // however it would have issues if the path had a protocol name in the path
+            path = stringAddr;
             break;
         }
-        tuples.push([part, parts[p]]);
     }
-    return tuples;
+    return {
+        bytes: Uint8Array.from(bytes),
+        string: stringTuplesToString(stringTuples),
+        tuples,
+        stringTuples,
+        path
+    };
 }
 /**
  * [[str name, str addr]... ] -> string
@@ -5074,7 +5304,7 @@ function stringToStringTuples(str) {
 function stringTuplesToString(tuples) {
     const parts = [];
     tuples.map((tup) => {
-        const proto = protoFromTuple(tup);
+        const proto = getProtocol(tup[0]);
         parts.push(proto.name);
         if (tup.length > 1 && tup[1] != null) {
             parts.push(tup[1]);
@@ -5083,47 +5313,18 @@ function stringTuplesToString(tuples) {
     });
     return cleanPath(parts.join('/'));
 }
-/**
- * [[str name, str addr]... ] -> [[int code, Uint8Array]... ]
- */
-function stringTuplesToTuples(tuples) {
-    return tuples.map((tup) => {
-        if (!Array.isArray(tup)) {
-            tup = [tup];
-        }
-        const proto = protoFromTuple(tup);
-        if (tup.length > 1) {
-            return [proto.code, convertToBytes(proto.code, tup[1])];
-        }
-        return [proto.code];
-    });
-}
-/**
- * Convert tuples to string tuples
- *
- * [[int code, Uint8Array]... ] -> [[int code, str addr]... ]
- */
-function tuplesToStringTuples(tuples) {
-    return tuples.map(tup => {
-        const proto = protoFromTuple(tup);
-        if (tup[1] != null) {
-            return [proto.code, convertToString(proto.code, tup[1])];
-        }
-        return [proto.code];
-    });
-}
 /**
  * [[int code, Uint8Array ]... ] -> Uint8Array
  */
 function tuplesToBytes(tuples) {
-    return fromBytes(concat(tuples.map((tup) => {
-        const proto = protoFromTuple(tup);
-        let buf = Uint8Array.from(varint$1.encode(proto.code));
+    return concat(tuples.map((tup) => {
+        const proto = getProtocol(tup[0]);
+        let buf = Uint8Array.from(encode$4(proto.code));
         if (tup.length > 1 && tup[1] != null) {
             buf = concat([buf, tup[1]]); // add address buffer
         }
         return buf;
-    })));
+    }));
 }
 /**
  * For the passed address, return the serialized size
@@ -5136,73 +5337,8 @@ function sizeForAddr(p, addr) {
         return 0;
     }
     else {
-        const size = varint$1.decode(addr);
-        return size + (varint$1.decode.bytes ?? 0);
-    }
-}
-function bytesToTuples(buf) {
-    const tuples = [];
-    let i = 0;
-    while (i < buf.length) {
-        const code = varint$1.decode(buf, i);
-        const n = varint$1.decode.bytes ?? 0;
-        const p = getProtocol(code);
-        const size = sizeForAddr(p, buf.slice(i + n));
-        if (size === 0) {
-            tuples.push([code]);
-            i += n;
-            // eslint-disable-next-line no-continue
-            continue;
-        }
-        const addr = buf.slice(i + n, i + n + size);
-        i += (size + n);
-        if (i > buf.length) { // did not end _exactly_ at buffer.length
-            throw ParseError('Invalid address Uint8Array: ' + toString$1(buf, 'base16'));
-        }
-        // ok, tuple seems good.
-        tuples.push([code, addr]);
-    }
-    return tuples;
-}
-/**
- * Uint8Array -> String
- */
-function bytesToString(buf) {
-    const a = bytesToTuples(buf);
-    const b = tuplesToStringTuples(a);
-    return stringTuplesToString(b);
-}
-/**
- * String -> Uint8Array
- */
-function stringToBytes(str) {
-    str = cleanPath(str);
-    const a = stringToStringTuples(str);
-    const b = stringTuplesToTuples(a);
-    return tuplesToBytes(b);
-}
-/**
- * String -> Uint8Array
- */
-function fromString(str) {
-    return stringToBytes(str);
-}
-/**
- * Uint8Array -> Uint8Array
- */
-function fromBytes(buf) {
-    const err = validateBytes(buf);
-    if (err != null) {
-        throw err;
-    }
-    return Uint8Array.from(buf); // copy
-}
-function validateBytes(buf) {
-    try {
-        bytesToTuples(buf); // try to parse. will throw if breaks
-    }
-    catch (err) {
-        return err;
+        const size = decode$3(addr instanceof Uint8Array ? addr : Uint8Array.from(addr));
+        return size + encodingLength$1(size);
     }
 }
 function cleanPath(str) {
@@ -5211,44 +5347,6 @@ function cleanPath(str) {
 function ParseError(str) {
     return new Error('Error parsing address: ' + str);
 }
-function protoFromTuple(tup) {
-    const proto = getProtocol(tup[0]);
-    return proto;
-}
-
-/**
- * When this error is thrown it means an operation was aborted,
- * usually in response to the `abort` event being emitted by an
- * AbortSignal.
- */
-class CodeError extends Error {
-    code;
-    props;
-    constructor(message, code, props) {
-        super(message);
-        this.code = code;
-        this.name = props?.name ?? 'CodeError';
-        this.props = props ?? {}; // eslint-disable-line @typescript-eslint/consistent-type-assertions
-    }
-}
-
-/**
- * Returns true if the two passed Uint8Arrays have the same content
- */
-function equals(a, b) {
-    if (a === b) {
-        return true;
-    }
-    if (a.byteLength !== b.byteLength) {
-        return false;
-    }
-    for (let i = 0; i < a.byteLength; i++) {
-        if (a[i] !== b[i]) {
-            return false;
-        }
-    }
-    return true;
-}
 
 /**
  * @packageDocumentation
@@ -5263,18 +5361,6 @@ function equals(a, b) {
  * const ma = multiaddr('/ip4/127.0.0.1/tcp/1234')
  * ```
  */
-var __classPrivateFieldGet = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _DefaultMultiaddr_string, _DefaultMultiaddr_tuples, _DefaultMultiaddr_stringTuples, _DefaultMultiaddr_path, _a;
 const inspect$1 = Symbol.for('nodejs.util.inspect.custom');
 const DNS_CODES = [
     getProtocol('dns').code,
@@ -5308,37 +5394,41 @@ function isMultiaddr(value) {
  * Creates a {@link Multiaddr} from a {@link MultiaddrInput}
  */
 class DefaultMultiaddr {
+    bytes;
+    #string;
+    #tuples;
+    #stringTuples;
+    #path;
+    [symbol$1] = true;
     constructor(addr) {
-        _DefaultMultiaddr_string.set(this, void 0);
-        _DefaultMultiaddr_tuples.set(this, void 0);
-        _DefaultMultiaddr_stringTuples.set(this, void 0);
-        _DefaultMultiaddr_path.set(this, void 0);
-        this[_a] = true;
         // default
         if (addr == null) {
             addr = '';
         }
+        let parts;
         if (addr instanceof Uint8Array) {
-            this.bytes = fromBytes(addr);
+            parts = bytesToMultiaddrParts(addr);
         }
         else if (typeof addr === 'string') {
             if (addr.length > 0 && addr.charAt(0) !== '/') {
                 throw new Error(`multiaddr "${addr}" must start with a "/"`);
             }
-            this.bytes = fromString(addr);
+            parts = stringToMultiaddrParts(addr);
         }
         else if (isMultiaddr(addr)) { // Multiaddr
-            this.bytes = fromBytes(addr.bytes); // validate + copy buffer
+            parts = bytesToMultiaddrParts(addr.bytes);
         }
         else {
             throw new Error('addr must be a string, Buffer, or another Multiaddr');
         }
+        this.bytes = parts.bytes;
+        this.#string = parts.string;
+        this.#tuples = parts.tuples;
+        this.#stringTuples = parts.stringTuples;
+        this.#path = parts.path;
     }
     toString() {
-        if (__classPrivateFieldGet(this, _DefaultMultiaddr_string, "f") == null) {
-            __classPrivateFieldSet(this, _DefaultMultiaddr_string, bytesToString(this.bytes), "f");
-        }
-        return __classPrivateFieldGet(this, _DefaultMultiaddr_string, "f");
+        return this.#string;
     }
     toJSON() {
         return this.toString();
@@ -5388,36 +5478,19 @@ class DefaultMultiaddr {
         return opts;
     }
     protos() {
-        return this.protoCodes().map(code => Object.assign({}, getProtocol(code)));
+        return this.#tuples.map(([code]) => Object.assign({}, getProtocol(code)));
     }
     protoCodes() {
-        const codes = [];
-        const buf = this.bytes;
-        let i = 0;
-        while (i < buf.length) {
-            const code = varint$1.decode(buf, i);
-            const n = varint$1.decode.bytes ?? 0;
-            const p = getProtocol(code);
-            const size = sizeForAddr(p, buf.slice(i + n));
-            i += (size + n);
-            codes.push(code);
-        }
-        return codes;
+        return this.#tuples.map(([code]) => code);
     }
     protoNames() {
-        return this.protos().map(proto => proto.name);
+        return this.#tuples.map(([code]) => getProtocol(code).name);
     }
     tuples() {
-        if (__classPrivateFieldGet(this, _DefaultMultiaddr_tuples, "f") == null) {
-            __classPrivateFieldSet(this, _DefaultMultiaddr_tuples, bytesToTuples(this.bytes), "f");
-        }
-        return __classPrivateFieldGet(this, _DefaultMultiaddr_tuples, "f");
+        return this.#tuples;
     }
     stringTuples() {
-        if (__classPrivateFieldGet(this, _DefaultMultiaddr_stringTuples, "f") == null) {
-            __classPrivateFieldSet(this, _DefaultMultiaddr_stringTuples, tuplesToStringTuples(this.tuples()), "f");
-        }
-        return __classPrivateFieldGet(this, _DefaultMultiaddr_stringTuples, "f");
+        return this.#stringTuples;
     }
     encapsulate(addr) {
         addr = new DefaultMultiaddr(addr);
@@ -5443,20 +5516,25 @@ class DefaultMultiaddr {
     }
     getPeerId() {
         try {
-            const tuples = this.stringTuples().filter((tuple) => {
-                if (tuple[0] === names.ipfs.code) {
-                    return true;
+            let tuples = [];
+            this.stringTuples().forEach(([code, name]) => {
+                if (code === names.p2p.code) {
+                    tuples.push([code, name]);
+                }
+                // if this is a p2p-circuit address, return the target peer id if present
+                // not the peer id of the relay
+                if (code === names['p2p-circuit'].code) {
+                    tuples = [];
                 }
-                return false;
             });
-            // Get the last ipfs tuple ['ipfs', 'peerid string']
+            // Get the last ipfs tuple ['p2p', 'peerid string']
             const tuple = tuples.pop();
             if (tuple?.[1] != null) {
                 const peerIdStr = tuple[1];
                 // peer id is base58btc encoded string but not multibase encoded so add the `z`
                 // prefix so we can validate that it is correctly encoded
                 if (peerIdStr[0] === 'Q' || peerIdStr[0] === '1') {
-                    return toString$1(base58btc.decode(`z${peerIdStr}`), 'base58btc');
+                    return toString$1(base58btc$1.decode(`z${peerIdStr}`), 'base58btc');
                 }
                 // try to parse peer id as CID
                 return toString$1(CID.parse(peerIdStr).multihash.bytes, 'base58btc');
@@ -5468,26 +5546,7 @@ class DefaultMultiaddr {
         }
     }
     getPath() {
-        // on initialization, this.#path is undefined
-        // after the first call, it is either a string or null
-        if (__classPrivateFieldGet(this, _DefaultMultiaddr_path, "f") === undefined) {
-            try {
-                __classPrivateFieldSet(this, _DefaultMultiaddr_path, this.stringTuples().filter((tuple) => {
-                    const proto = getProtocol(tuple[0]);
-                    if (proto.path === true) {
-                        return true;
-                    }
-                    return false;
-                })[0][1], "f");
-                if (__classPrivateFieldGet(this, _DefaultMultiaddr_path, "f") == null) {
-                    __classPrivateFieldSet(this, _DefaultMultiaddr_path, null, "f");
-                }
-            }
-            catch {
-                __classPrivateFieldSet(this, _DefaultMultiaddr_path, null, "f");
-            }
-        }
-        return __classPrivateFieldGet(this, _DefaultMultiaddr_path, "f");
+        return this.#path;
     }
     equals(addr) {
         return equals(this.bytes, addr.bytes);
@@ -5500,7 +5559,7 @@ class DefaultMultiaddr {
         }
         const resolver = resolvers.get(resolvableProto.name);
         if (resolver == null) {
-            throw new CodeError(`no available resolver for ${resolvableProto.name}`, 'ERR_NO_AVAILABLE_RESOLVER');
+            throw new CodeError$1(`no available resolver for ${resolvableProto.name}`, 'ERR_NO_AVAILABLE_RESOLVER');
         }
         const addresses = await resolver(this, options);
         return addresses.map((a) => new DefaultMultiaddr(a));
@@ -5541,8 +5600,8 @@ class DefaultMultiaddr {
      * // 'Multiaddr(/ip4/127.0.0.1/tcp/4001)'
      * ```
      */
-    [(_DefaultMultiaddr_string = new WeakMap(), _DefaultMultiaddr_tuples = new WeakMap(), _DefaultMultiaddr_stringTuples = new WeakMap(), _DefaultMultiaddr_path = new WeakMap(), _a = symbol$1, inspect$1)]() {
-        return `Multiaddr(${bytesToString(this.bytes)})`;
+    [inspect$1]() {
+        return `Multiaddr(${this.#string})`;
     }
 }
 /**
@@ -13525,15 +13584,15 @@ var forge$a = forge$m;
 
 
 
-var sha256 = forge$a.sha256 = forge$a.sha256 || {};
-forge$a.md.sha256 = forge$a.md.algorithms.sha256 = sha256;
+var sha256$1 = forge$a.sha256 = forge$a.sha256 || {};
+forge$a.md.sha256 = forge$a.md.algorithms.sha256 = sha256$1;
 
 /**
  * Creates a SHA-256 message digest object.
  *
  * @return a message digest object.
  */
-sha256.create = function() {
+sha256$1.create = function() {
   // do initialization as necessary
   if(!_initialized$2) {
     _init$2();
@@ -19952,9 +20011,768 @@ function createPbkdf2Params(salt, countBytes, dkLen, prfAlgorithm) {
         asn1.create(asn1.Class.UNIVERSAL, asn1.Type.NULL, false, '')
       ]));
   }
-  return params;
+  return params;
+}
+
+/**
+ * When this error is thrown it means an operation was aborted,
+ * usually in response to the `abort` event being emitted by an
+ * AbortSignal.
+ */
+class CodeError extends Error {
+    code;
+    props;
+    constructor(message, code, props) {
+        super(message);
+        this.code = code;
+        this.name = props?.name ?? 'CodeError';
+        this.props = props ?? {}; // eslint-disable-line @typescript-eslint/consistent-type-assertions
+    }
+}
+
+// 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);
+    }
+    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);
+        // Process the bytes.
+    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++;
+    }
+        // Skip leading zeroes in base58 result.
+    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;
+        // Skip leading spaces.
+    if (source[psz] === ' ') { return }
+        // Skip and count leading '1's.
+    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);
+        // Process the characters.
+    while (source[psz]) {
+            // Decode character
+      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++;
+    }
+        // Skip trailing spaces.
+    if (source[psz] === ' ') { return }
+        // Skip leading zeroes in b256.
+    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
+  }
+  function decode (string) {
+    var buffer = decodeUnsafe(string);
+    if (buffer) { return buffer }
+    throw new Error(`Non-${name} character`)
+  }
+  return {
+    encode: encode,
+    decodeUnsafe: decodeUnsafe,
+    decode: decode
+  }
+}
+var src = base;
+
+var _brrp__multiformats_scope_baseX = src;
+
+/**
+ * @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')
+};
+
+/**
+ * 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')
+    }
+  }
+}
+
+/**
+ * @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')
+    }
+    /** @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')
+    }
+  }
+
+  /**
+   * @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`)
+    }
+  }
+}
+
+/**
+ * @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}
+ */
+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)
+  }
+}
+
+/**
+ * @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$1 = ({ 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$1({
+    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$2 = (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`)
+    }
+
+    // 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);
+    }
+  }
+
+  // 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$3 = (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) {
+    out += alphabet[mask & (buffer << (bitsPerChar - bits))];
+  }
+
+  // Add padding characters until we hit a byte boundary:
+  if (pad) {
+    while ((out.length * bitsPerChar) & 7) {
+      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$1({
+    prefix,
+    name,
+    encode (input) {
+      return encode$3(input, alphabet, bitsPerChar)
+    },
+    decode (input) {
+      return decode$2(input, alphabet, bitsPerChar, name)
+    }
+  })
+};
+
+const base58btc = baseX({
+  name: 'base58btc',
+  prefix: 'z',
+  alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+});
+
+baseX({
+  name: 'base58flickr',
+  prefix: 'Z',
+  alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
+});
+
+var encode_1 = encode$2;
+
+var MSB = 0x80
+  , REST = 0x7F
+  , MSBALL = ~REST
+  , INT = Math.pow(2, 31);
+
+function encode$2(num, out, offset) {
+  out = out || [];
+  offset = offset || 0;
+  var oldOffset = offset;
+
+  while(num >= INT) {
+    out[offset++] = (num & 0xFF) | MSB;
+    num /= 128;
+  }
+  while(num & MSBALL) {
+    out[offset++] = (num & 0xFF) | MSB;
+    num >>>= 7;
+  }
+  out[offset] = num | 0;
+  
+  encode$2.bytes = offset - oldOffset + 1;
+  
+  return out
+}
+
+var decode$1 = read;
+
+var MSB$1 = 0x80
+  , REST$1 = 0x7F;
+
+function read(buf, offset) {
+  var res    = 0
+    , offset = offset || 0
+    , shift  = 0
+    , counter = offset
+    , b
+    , l = buf.length;
+
+  do {
+    if (counter >= l) {
+      read.bytes = 0;
+      throw new RangeError('Could not decode varint')
+    }
+    b = buf[counter++];
+    res += shift < 28
+      ? (b & REST$1) << shift
+      : (b & REST$1) * Math.pow(2, shift);
+    shift += 7;
+  } while (b >= MSB$1)
+
+  read.bytes = counter - offset;
+
+  return res
+}
+
+var N1 = Math.pow(2,  7);
+var N2 = Math.pow(2, 14);
+var N3 = Math.pow(2, 21);
+var N4 = Math.pow(2, 28);
+var N5 = Math.pow(2, 35);
+var N6 = Math.pow(2, 42);
+var N7 = Math.pow(2, 49);
+var N8 = Math.pow(2, 56);
+var N9 = Math.pow(2, 63);
+
+var length = function (value) {
+  return (
+    value < N1 ? 1
+  : value < N2 ? 2
+  : value < N3 ? 3
+  : value < N4 ? 4
+  : value < N5 ? 5
+  : value < N6 ? 6
+  : value < N7 ? 7
+  : value < N8 ? 8
+  : value < N9 ? 9
+  :              10
+  )
+};
+
+var varint = {
+    encode: encode_1
+  , decode: decode$1
+  , encodingLength: length
+};
+
+var _brrp_varint = varint;
+
+/**
+ * @param {number} int
+ * @param {Uint8Array} target
+ * @param {number} [offset=0]
+ */
+const encodeTo = (int, target, offset = 0) => {
+  _brrp_varint.encode(int, target, offset);
+  return target
+};
+
+/**
+ * @param {number} int
+ * @returns {number}
+ */
+const encodingLength = (int) => {
+  return _brrp_varint.encodingLength(int)
+};
+
+/**
+ * Creates a multihash digest.
+ *
+ * @template {number} Code
+ * @param {Code} code
+ * @param {Uint8Array} digest
+ */
+const create$3 = (code, digest) => {
+  const size = digest.byteLength;
+  const sizeOffset = encodingLength(code);
+  const digestOffset = sizeOffset + encodingLength(size);
+
+  const bytes = new Uint8Array(digestOffset + size);
+  encodeTo(code, bytes, 0);
+  encodeTo(size, bytes, sizeOffset);
+  bytes.set(digest, digestOffset);
+
+  return new Digest(code, size, digest, bytes)
+};
+
+/**
+ * @typedef {import('./interface.js').MultihashDigest} MultihashDigest
+ */
+
+/**
+ * Represents a multihash digest which carries information about the
+ * hashing algorithm and an actual hash digest.
+ *
+ * @template {number} Code
+ * @template {number} Size
+ * @class
+ * @implements {MultihashDigest}
+ */
+class Digest {
+  /**
+   * Creates a multihash digest.
+   *
+   * @param {Code} code
+   * @param {Size} size
+   * @param {Uint8Array} digest
+   * @param {Uint8Array} bytes
+   */
+  constructor (code, size, digest, bytes) {
+    this.code = code;
+    this.size = size;
+    this.digest = digest;
+    this.bytes = bytes;
+  }
+}
+
+const code = 0x0;
+const name = 'identity';
+
+/** @type {(input:Uint8Array) => Uint8Array} */
+const encode$1 = coerce;
+
+/**
+ * @param {Uint8Array} input
+ * @returns {Digest.Digest<typeof code, number>}
+ */
+const digest = (input) => create$3(code, encode$1(input));
+
+const identity = { code, name, encode: encode$1, digest };
+
+/**
+ * @template {string} Name
+ * @template {number} Code
+ * @param {object} options
+ * @param {Name} options.name
+ * @param {Code} options.code
+ * @param {(input: Uint8Array) => Await<Uint8Array>} options.encode
+ */
+const from = ({ name, code, encode }) => new Hasher(name, code, encode);
+
+/**
+ * Hasher represents a hashing algorithm implementation that produces as
+ * `MultihashDigest`.
+ *
+ * @template {string} Name
+ * @template {number} Code
+ * @class
+ * @implements {MultihashHasher<Code>}
+ */
+class Hasher {
+  /**
+   *
+   * @param {Name} name
+   * @param {Code} code
+   * @param {(input: Uint8Array) => Await<Uint8Array>} encode
+   */
+  constructor (name, code, encode) {
+    this.name = name;
+    this.code = code;
+    this.encode = encode;
+  }
+
+  /**
+   * @param {Uint8Array} input
+   * @returns {Await<Digest.Digest<Code, number>>}
+   */
+  digest (input) {
+    if (input instanceof Uint8Array) {
+      const result = this.encode(input);
+      return result instanceof Uint8Array
+        ? create$3(this.code, result)
+        /* c8 ignore next 1 */
+        : result.then(digest => create$3(this.code, digest))
+    } else {
+      throw Error('Unknown type, must be binary type')
+      /* c8 ignore next 1 */
+    }
+  }
 }
 
+/**
+ * @template {number} Alg
+ * @typedef {import('./interface.js').MultihashHasher} MultihashHasher
+ */
+
+/**
+ * @template T
+ * @typedef {Promise<T>|T} Await
+ */
+
+/* global crypto */
+
+
+/**
+ * @param {AlgorithmIdentifier} name
+ */
+const sha = name =>
+  /**
+   * @param {Uint8Array} data
+   */
+  async data => new Uint8Array(await crypto.subtle.digest(name, data));
+
+const sha256 = from({
+  name: 'sha2-256',
+  code: 0x12,
+  encode: sha('SHA-256')
+});
+
 /*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
 const _0n = BigInt(0);
 const _1n = BigInt(1);
@@ -20775,6 +21593,37 @@ function concatKeys(privateKeyRaw, publicKey) {
     return privateKey;
 }
 
+// @ts-check
+
+
+const base64$2 = rfc4648({
+  prefix: 'm',
+  name: 'base64',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+  bitsPerChar: 6
+});
+
+rfc4648({
+  prefix: 'M',
+  name: 'base64pad',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
+  bitsPerChar: 6
+});
+
+rfc4648({
+  prefix: 'u',
+  name: 'base64url',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
+  bitsPerChar: 6
+});
+
+rfc4648({
+  prefix: 'U',
+  name: 'base64urlpad',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',
+  bitsPerChar: 6
+});
+
 /* eslint-env browser */
 // Check native crypto exists and is enabled (In insecure context `self.crypto`
 // exists but `self.crypto.subtle` does not).
@@ -20822,7 +21671,7 @@ function create$2(opts) {
         const nonce = crypto.getRandomValues(new Uint8Array(nonceLength));
         const aesGcm = { name: algorithm, iv: nonce };
         if (typeof password === 'string') {
-            password = fromString$1(password);
+            password = fromString(password);
         }
         let cryptoKey;
         if (password.length === 0) {
@@ -20858,7 +21707,7 @@ function create$2(opts) {
         const ciphertext = data.subarray(saltLength + nonceLength);
         const aesGcm = { name: algorithm, iv: nonce };
         if (typeof password === 'string') {
-            password = fromString$1(password);
+            password = fromString(password);
         }
         let cryptoKey;
         if (password.length === 0) {
@@ -21096,588 +21945,628 @@ var base64$1 = {};
 	}; 
 } (base64$1));
 
-var eventemitter = EventEmitter;
+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() {
+	/**
+	 * Constructs a new event emitter instance.
+	 * @classdesc A minimal event emitter.
+	 * @memberof util
+	 * @constructor
+	 */
+	function EventEmitter() {
 
-    /**
-     * Registered listeners.
-     * @type {Object.<string,*>}
-     * @private
-     */
-    this._listeners = {};
-}
+	    /**
+	     * 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;
-};
+	/**
+	 * 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;
-};
+	/**
+	 * Removes an event listener or any matching listeners if arguments are omitted.
+	 * @param {string} [evt] Event name. Removes all listeners if omitted.
+	 * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
+	 * @returns {util.EventEmitter} `this`
+	 */
+	EventEmitter.prototype.off = function off(evt, fn) {
+	    if (evt === undefined)
+	        this._listeners = {};
+	    else {
+	        if (fn === undefined)
+	            this._listeners[evt] = [];
+	        else {
+	            var listeners = this._listeners[evt];
+	            for (var i = 0; i < listeners.length;)
+	                if (listeners[i].fn === fn)
+	                    listeners.splice(i, 1);
+	                else
+	                    ++i;
+	        }
+	    }
+	    return this;
+	};
 
-/**
- * Emits an event by calling its listeners with the specified arguments.
- * @param {string} evt Event name
- * @param {...*} args Arguments
- * @returns {util.EventEmitter} `this`
- */
-EventEmitter.prototype.emit = function emit(evt) {
-    var listeners = this._listeners[evt];
-    if (listeners) {
-        var args = [],
-            i = 1;
-        for (; i < arguments.length;)
-            args.push(arguments[i++]);
-        for (i = 0; i < listeners.length;)
-            listeners[i].fn.apply(listeners[i++].ctx, args);
-    }
-    return this;
-};
-
-var float = factory(factory);
+	/**
+	 * 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;
 
-/**
- * Reads / writes floats / doubles from / to buffers.
- * @name util.float
- * @namespace
- */
+	float = factory(factory);
 
-/**
- * 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}
- */
+	/**
+	 * Reads / writes floats / doubles from / to buffers.
+	 * @name util.float
+	 * @namespace
+	 */
 
-/**
- * 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}
- */
+	/**
+	 * 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}
+	 */
 
-/**
- * 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
- */
+	/**
+	 * 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 big endian byte order.
- * @name util.float.readFloatBE
- * @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 little endian byte order.
+	 * @name util.float.readFloatLE
+	 * @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}
- */
+	/**
+	 * 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 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}
- */
+	/**
+	 * 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}
+	 */
 
-/**
- * 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
- */
+	/**
+	 * 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 big endian byte order.
- * @name util.float.readDoubleBE
- * @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 little endian byte order.
+	 * @name util.float.readDoubleLE
+	 * @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) {
+	/**
+	 * 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
+	 */
 
-    // float: typed array
-    if (typeof Float32Array !== "undefined") (function() {
+	// Factory function for the purpose of node-based testing in modified global environments
+	function factory(exports) {
 
-        var f32 = new Float32Array([ -0 ]),
-            f8b = new Uint8Array(f32.buffer),
-            le  = f8b[3] === 128;
+	    // float: typed array
+	    if (typeof Float32Array !== "undefined") (function() {
 
-        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];
-        }
+	        var f32 = new Float32Array([ -0 ]),
+	            f8b = new Uint8Array(f32.buffer),
+	            le  = f8b[3] === 128;
 
-        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 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];
+	        }
 
-        /* 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 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_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];
-        }
+	        /* 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_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];
-        }
+	        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];
+	        }
 
-        /* istanbul ignore next */
-        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
-        /* istanbul ignore next */
-        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
+	        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];
+	        }
 
-    // float: ieee754
-    })(); else (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;
 
-        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);
-            }
-        }
+	    // float: ieee754
+	    })(); else (function() {
 
-        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
-        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
+	        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 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.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
+	        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
 
-        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
-        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
+	        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;
+	    // double: typed array
+	    if (typeof Float64Array !== "undefined") (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];
-        }
+	        var f64 = new Float64Array([-0]),
+	            f8b = new Uint8Array(f64.buffer),
+	            le  = f8b[7] === 128;
 
-        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 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];
+	        }
 
-        /* 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 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_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];
-        }
+	        /* 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_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];
-        }
+	        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];
+	        }
 
-        /* istanbul ignore next */
-        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
-        /* istanbul ignore next */
-        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
+	        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];
+	        }
 
-    // double: ieee754
-    })(); else (function() {
+	        /* istanbul ignore next */
+	        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
+	        /* istanbul ignore next */
+	        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
 
-        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);
-                }
-            }
-        }
+	    // double: ieee754
+	    })(); else (function() {
 
-        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
-        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
+	        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 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.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
+	        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
 
-        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
-        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 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
+	    return exports;
+	}
 
-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;
-}
+	// uint helpers
 
-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 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 readUintLE(buf, pos) {
-    return (buf[pos    ]
-          | buf[pos + 1] << 8
-          | buf[pos + 2] << 16
-          | buf[pos + 3] << 24) >>> 0;
-}
+	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 readUintBE(buf, pos) {
-    return (buf[pos    ] << 24
-          | buf[pos + 1] << 16
-          | buf[pos + 2] << 8
-          | buf[pos + 3]) >>> 0;
-}
-
-var inquire_1 = inquire;
+	function readUintLE(buf, pos) {
+	    return (buf[pos    ]
+	          | buf[pos + 1] << 8
+	          | buf[pos + 2] << 16
+	          | buf[pos + 3] << 24) >>> 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;
+	function readUintBE(buf, pos) {
+	    return (buf[pos    ] << 24
+	          | buf[pos + 1] << 16
+	          | buf[pos + 2] << 8
+	          | buf[pos + 3]) >>> 0;
+	}
+	return float;
 }
 
-var utf8$2 = {};
+var inquire_1;
+var hasRequiredInquire;
 
-(function (exports) {
+function requireInquire () {
+	if (hasRequiredInquire) return inquire_1;
+	hasRequiredInquire = 1;
+	inquire_1 = inquire;
 
 	/**
-	 * A minimal UTF8 implementation for number arrays.
+	 * Requires a module only if available.
 	 * @memberof util
-	 * @namespace
+	 * @param {string} moduleName Module to require
+	 * @returns {?Object} Required module if available and not empty, otherwise `null`
 	 */
-	var utf8 = exports;
+	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;
+
+		/**
+		 * Calculates the UTF8 byte length of a string.
+		 * @param {string} string String
+		 * @returns {number} Byte length
+		 */
+		utf8.length = function utf8_length(string) {
+		    var len = 0,
+		        c = 0;
+		    for (var i = 0; i < string.length; ++i) {
+		        c = string.charCodeAt(i);
+		        if (c < 128)
+		            len += 1;
+		        else if (c < 2048)
+		            len += 2;
+		        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
+		            ++i;
+		            len += 4;
+		        } else
+		            len += 3;
+		    }
+		    return len;
+		};
+
+		/**
+		 * Reads UTF8 bytes as a string.
+		 * @param {Uint8Array} buffer Source buffer
+		 * @param {number} start Source start
+		 * @param {number} end Source end
+		 * @returns {string} String read
+		 */
+		utf8.read = function utf8_read(buffer, start, end) {
+		    var len = end - start;
+		    if (len < 1)
+		        return "";
+		    var parts = null,
+		        chunk = [],
+		        i = 0, // char offset
+		        t;     // temporary
+		    while (start < end) {
+		        t = buffer[start++];
+		        if (t < 128)
+		            chunk[i++] = t;
+		        else if (t > 191 && t < 224)
+		            chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
+		        else if (t > 239 && t < 365) {
+		            t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;
+		            chunk[i++] = 0xD800 + (t >> 10);
+		            chunk[i++] = 0xDC00 + (t & 1023);
+		        } else
+		            chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
+		        if (i > 8191) {
+		            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+		            i = 0;
+		        }
+		    }
+		    if (parts) {
+		        if (i)
+		            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+		        return parts.join("");
+		    }
+		    return String.fromCharCode.apply(String, chunk.slice(0, i));
+		};
+
+		/**
+		 * Writes a string as UTF8 bytes.
+		 * @param {string} string Source string
+		 * @param {Uint8Array} buffer Destination buffer
+		 * @param {number} offset Destination offset
+		 * @returns {number} Bytes written
+		 */
+		utf8.write = function utf8_write(string, buffer, offset) {
+		    var start = offset,
+		        c1, // character 1
+		        c2; // character 2
+		    for (var i = 0; i < string.length; ++i) {
+		        c1 = string.charCodeAt(i);
+		        if (c1 < 128) {
+		            buffer[offset++] = c1;
+		        } else if (c1 < 2048) {
+		            buffer[offset++] = c1 >> 6       | 192;
+		            buffer[offset++] = c1       & 63 | 128;
+		        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
+		            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
+		            ++i;
+		            buffer[offset++] = c1 >> 18      | 240;
+		            buffer[offset++] = c1 >> 12 & 63 | 128;
+		            buffer[offset++] = c1 >> 6  & 63 | 128;
+		            buffer[offset++] = c1       & 63 | 128;
+		        } else {
+		            buffer[offset++] = c1 >> 12      | 224;
+		            buffer[offset++] = c1 >> 6  & 63 | 128;
+		            buffer[offset++] = c1       & 63 | 128;
+		        }
+		    }
+		    return offset - start;
+		}; 
+	} (utf8$2));
+	return utf8$2;
+}
+
+var pool_1;
+var hasRequiredPool;
+
+function requirePool () {
+	if (hasRequiredPool) return pool_1;
+	hasRequiredPool = 1;
+	pool_1 = pool;
 
 	/**
-	 * Calculates the UTF8 byte length of a string.
-	 * @param {string} string String
-	 * @returns {number} Byte length
+	 * An allocator as used by {@link util.pool}.
+	 * @typedef PoolAllocator
+	 * @type {function}
+	 * @param {number} size Buffer size
+	 * @returns {Uint8Array} Buffer
 	 */
-	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
+	 * 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}
 	 */
-	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
+	 * 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
 	 */
-	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;
+	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;
 	        }
-	    }
-	    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 buf = slice.call(slab, offset, offset += size);
+	        if (offset & 7) // align to 32 bit
+	            offset = (offset | 7) + 1;
+	        return buf;
+	    };
+	}
+	return pool_1;
 }
 
 var longbits;
@@ -21903,19 +22792,19 @@ function requireMinimal () {
 		util.base64 = base64$1;
 
 		// base class of rpc.Service
-		util.EventEmitter = eventemitter;
+		util.EventEmitter = requireEventemitter();
 
 		// float handling accross browsers
-		util.float = float;
+		util.float = requireFloat();
 
 		// requires modules optionally and hides the call from bundlers
-		util.inquire = inquire_1;
+		util.inquire = requireInquire();
 
 		// converts to / from utf8 encoded strings
-		util.utf8 = utf8$2;
+		util.utf8 = requireUtf8();
 
 		// provides a node-like buffer pool in the browser
-		util.pool = pool_1;
+		util.pool = requirePool();
 
 		// utility to work with the low and high bits of a 64 bit value
 		util.LongBits = requireLongbits();
@@ -22648,9 +23537,14 @@ Reader$1.prototype.bytes = function read_bytes() {
     this.pos += length;
     if (Array.isArray(this.buf)) // plain array
         return this.buf.slice(start, end);
-    return start === end // fix for IE 10/Win8 and others' subarray returning array of size 1
-        ? new this.buf.constructor(0)
-        : this._slice.call(this.buf, start, end);
+
+    if (start === end) { // fix for IE 10/Win8 and others' subarray returning array of size 1
+        var nativeBuffer = util$4.Buffer;
+        return nativeBuffer
+            ? nativeBuffer.alloc(0)
+            : new this.buf.constructor(0);
+    }
+    return this._slice.call(this.buf, start, end);
 };
 
 /**
@@ -23459,6 +24353,10 @@ function message(encode, decode) {
 }
 
 /* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
 var KeyType;
 (function (KeyType) {
     KeyType["RSA"] = "RSA";
@@ -23596,7 +24494,7 @@ class Ed25519PublicKey {
         return equals(this.bytes, key.bytes);
     }
     async hash() {
-        const { bytes } = await sha256$1.digest(this.bytes);
+        const { bytes } = await sha256.digest(this.bytes);
         return bytes;
     }
 }
@@ -23628,7 +24526,7 @@ class Ed25519PrivateKey {
         return equals(this.bytes, key.bytes);
     }
     async hash() {
-        const { bytes } = await sha256$1.digest(this.bytes);
+        const { bytes } = await sha256.digest(this.bytes);
         return bytes;
     }
     /**
@@ -23720,7 +24618,7 @@ function base64urlToBigInteger(str) {
     return new forge$n.jsbn.BigInteger(toString$1(buf, 'base16'), 16);
 }
 function base64urlToBuffer(str, len) {
-    let buf = fromString$1(str, 'base64urlpad');
+    let buf = fromString(str, 'base64urlpad');
     if (len != null) {
         if (buf.length > len)
             throw new Error('byte array longer than desired length');
@@ -24350,7 +25248,7 @@ function jwkToPkcs1(jwk) {
         dQ: base64urlToBigInteger(jwk.dq),
         qInv: base64urlToBigInteger(jwk.qi)
     });
-    return fromString$1(forge$n.asn1.toDer(asn1).getBytes(), 'ascii');
+    return fromString(forge$n.asn1.toDer(asn1).getBytes(), 'ascii');
 }
 // Convert a PKCIX in ASN1 DER format to a JWK key
 function pkixToJwk(bytes) {
@@ -24371,7 +25269,7 @@ function jwkToPkix(jwk) {
         n: base64urlToBigInteger(jwk.n),
         e: base64urlToBigInteger(jwk.e)
     });
-    return fromString$1(forge$n.asn1.toDer(asn1).getBytes(), 'ascii');
+    return fromString(forge$n.asn1.toDer(asn1).getBytes(), 'ascii');
 }
 
 async function generateKey$1(bits) {
@@ -24455,7 +25353,7 @@ function convertKey(key, pub, msg, handle) {
     const fkey = pub ? jwk2pub(key) : jwk2priv(key);
     const fmsg = toString$1(Uint8Array.from(msg), 'ascii');
     const fomsg = handle(fmsg, fkey);
-    return fromString$1(fomsg, 'ascii');
+    return fromString(fomsg, 'ascii');
 }
 function encrypt(key, msg) {
     return convertKey(key, true, msg, (msg, key) => key.encrypt(msg));
@@ -24488,7 +25386,7 @@ class RsaPublicKey {
         return equals(this.bytes, key.bytes);
     }
     async hash() {
-        const { bytes } = await sha256$1.digest(this.bytes);
+        const { bytes } = await sha256.digest(this.bytes);
         return bytes;
     }
 }
@@ -24527,7 +25425,7 @@ class RsaPrivateKey {
         return equals(this.bytes, key.bytes);
     }
     async hash() {
-        const { bytes } = await sha256$1.digest(this.bytes);
+        const { bytes } = await sha256.digest(this.bytes);
         return bytes;
     }
     /**
@@ -24600,7 +25498,7 @@ function generateKey() {
  * Hash and sign message with private key
  */
 async function hashAndSign(key, msg) {
-    const { digest } = await sha256$1.digest(msg);
+    const { digest } = await sha256.digest(msg);
     try {
         return await sign$3(digest, key);
     }
@@ -24613,7 +25511,7 @@ async function hashAndSign(key, msg) {
  */
 async function hashAndVerify(key, sig, msg) {
     try {
-        const { digest } = await sha256$1.digest(msg);
+        const { digest } = await sha256.digest(msg);
         return verify$1(sig, digest, key);
     }
     catch (err) {
@@ -24671,7 +25569,7 @@ class Secp256k1PublicKey {
         return equals(this.bytes, key.bytes);
     }
     async hash() {
-        const { bytes } = await sha256$1.digest(this.bytes);
+        const { bytes } = await sha256.digest(this.bytes);
         return bytes;
     }
 }
@@ -24703,7 +25601,7 @@ class Secp256k1PrivateKey {
         return equals(this.bytes, key.bytes);
     }
     async hash() {
-        const { bytes } = await sha256$1.digest(this.bytes);
+        const { bytes } = await sha256.digest(this.bytes);
         return bytes;
     }
     /**
@@ -24825,7 +25723,7 @@ class PeerIdImpl {
     [symbol] = true;
     toString() {
         if (this.string == null) {
-            this.string = base58btc.encode(this.multihash.bytes).slice(1);
+            this.string = base58btc$1.encode(this.multihash.bytes).slice(1);
         }
         return this.string;
     }
@@ -24904,7 +25802,7 @@ function peerIdFromString(str, decoder) {
     if (str.charAt(0) === '1' || str.charAt(0) === 'Q') {
         // identity hash ed25519/secp256k1 key or sha2-256 hash of
         // rsa public key - base58btc encoded either way
-        const multihash = decode$2(base58btc.decode(`z${str}`));
+        const multihash = decode$4(base58btc$1.decode(`z${str}`));
         if (str.startsWith('12D')) {
             return new Ed25519PeerIdImpl({ multihash });
         }
@@ -24919,8 +25817,8 @@ function peerIdFromString(str, decoder) {
 }
 function peerIdFromBytes(buf) {
     try {
-        const multihash = decode$2(buf);
-        if (multihash.code === identity.code) {
+        const multihash = decode$4(buf);
+        if (multihash.code === identity$1.code) {
             if (multihash.digest.length === MARSHALLED_ED225519_PUBLIC_KEY_LENGTH) {
                 return new Ed25519PeerIdImpl({ multihash });
             }
@@ -24928,7 +25826,7 @@ function peerIdFromBytes(buf) {
                 return new Secp256k1PeerIdImpl({ multihash });
             }
         }
-        if (multihash.code === sha256$1.code) {
+        if (multihash.code === sha256$2.code) {
             return new RSAPeerIdImpl({ multihash });
         }
     }
@@ -24942,10 +25840,10 @@ function peerIdFromCID(cid) {
         throw new Error('Supplied PeerID CID is invalid');
     }
     const multihash = cid.multihash;
-    if (multihash.code === sha256$1.code) {
+    if (multihash.code === sha256$2.code) {
         return new RSAPeerIdImpl({ multihash: cid.multihash });
     }
-    else if (multihash.code === identity.code) {
+    else if (multihash.code === identity$1.code) {
         if (multihash.digest.length === MARSHALLED_ED225519_PUBLIC_KEY_LENGTH) {
             return new Ed25519PeerIdImpl({ multihash: cid.multihash });
         }
@@ -24961,12 +25859,12 @@ function peerIdFromCID(cid) {
  */
 async function peerIdFromKeys(publicKey, privateKey) {
     if (publicKey.length === MARSHALLED_ED225519_PUBLIC_KEY_LENGTH) {
-        return new Ed25519PeerIdImpl({ multihash: create$3(identity.code, publicKey), privateKey });
+        return new Ed25519PeerIdImpl({ multihash: create$4(identity$1.code, publicKey), privateKey });
     }
     if (publicKey.length === MARSHALLED_SECP256K1_PUBLIC_KEY_LENGTH) {
-        return new Secp256k1PeerIdImpl({ multihash: create$3(identity.code, publicKey), privateKey });
+        return new Secp256k1PeerIdImpl({ multihash: create$4(identity$1.code, publicKey), privateKey });
     }
-    return new RSAPeerIdImpl({ multihash: await sha256$1.digest(publicKey), publicKey, privateKey });
+    return new RSAPeerIdImpl({ multihash: await sha256$2.digest(publicKey), publicKey, privateKey });
 }
 
 function createPeerIdFromPublicKey(publicKey) {
@@ -25021,6 +25919,60 @@ function encodeMultiaddrs(multiaddrs) {
     return bytes;
 }
 
+const decodeRelayShard = (bytes) => {
+    // explicitly converting to Uint8Array to avoid Buffer
+    // https://github.com/libp2p/js-libp2p/issues/2146
+    bytes = new Uint8Array(bytes);
+    if (bytes.length < 3)
+        throw new Error("Insufficient data");
+    const view = new DataView(bytes.buffer);
+    const cluster = view.getUint16(0);
+    const indexList = [];
+    if (bytes.length === 130) {
+        // rsv format (Bit Vector)
+        for (let i = 0; i < 1024; i++) {
+            const byteIndex = Math.floor(i / 8) + 2; // Adjusted for the 2-byte cluster field
+            const bitIndex = 7 - (i % 8);
+            if (view.getUint8(byteIndex) & (1 << bitIndex)) {
+                indexList.push(i);
+            }
+        }
+    }
+    else {
+        // rs format (Index List)
+        const numIndices = view.getUint8(2);
+        for (let i = 0, offset = 3; i < numIndices; i++, offset += 2) {
+            if (offset + 1 >= bytes.length)
+                throw new Error("Unexpected end of data");
+            indexList.push(view.getUint16(offset));
+        }
+    }
+    return { cluster, indexList };
+};
+const encodeRelayShard = (shardInfo) => {
+    const { cluster, indexList } = shardInfo;
+    const totalLength = indexList.length >= 64 ? 130 : 3 + 2 * indexList.length;
+    const buffer = new ArrayBuffer(totalLength);
+    const view = new DataView(buffer);
+    view.setUint16(0, cluster);
+    if (indexList.length >= 64) {
+        // rsv format (Bit Vector)
+        for (const index of indexList) {
+            const byteIndex = Math.floor(index / 8) + 2; // Adjusted for the 2-byte cluster field
+            const bitIndex = 7 - (index % 8);
+            view.setUint8(byteIndex, view.getUint8(byteIndex) | (1 << bitIndex));
+        }
+    }
+    else {
+        // rs format (Index List)
+        view.setUint8(2, indexList.length);
+        for (let i = 0, offset = 3; i < indexList.length; i++, offset += 2) {
+            view.setUint16(offset, indexList[i]);
+        }
+    }
+    return new Uint8Array(buffer);
+};
+
 function encodeWaku2(protocols) {
     let byte = 0;
     if (protocols.lightPush)
@@ -25041,7 +25993,7 @@ function decodeWaku2(byte) {
         relay: false,
         store: false,
         filter: false,
-        lightPush: false,
+        lightPush: false
     };
     if (byte % 2)
         waku2.relay = true;
@@ -25084,6 +26036,18 @@ class RawEnr extends Map {
                 throw new Error(ERR_INVALID_ID);
         }
     }
+    get rs() {
+        const rs = this.get("rs");
+        if (!rs)
+            return undefined;
+        return decodeRelayShard(rs);
+    }
+    get rsv() {
+        const rsv = this.get("rsv");
+        if (!rsv)
+            return undefined;
+        return decodeRelayShard(rsv);
+    }
     get ip() {
         return getStringValue(this, "ip", "ip4");
     }
@@ -25198,7 +26162,7 @@ function deleteUndefined(map, key, value, transform) {
 
 async function sign(privKey, msg) {
     return sign$3(keccak256(msg), privKey, {
-        der: false,
+        der: false
     });
 }
 function nodeId(pubKey) {
@@ -25245,6 +26209,12 @@ class ENR extends RawEnr {
         }
     }
     getLocationMultiaddr = locationMultiaddrFromEnrFields.bind({}, this);
+    get shardInfo() {
+        if (this.rs && this.rsv) {
+            log("Warning: ENR contains both `rs` and `rsv` fields.");
+        }
+        return this.rs || this.rsv;
+    }
     setLocationMultiaddr(multiaddr) {
         const protoNames = multiaddr.protoNames();
         if (protoNames.length !== 2 &&
@@ -25283,7 +26253,7 @@ class ENR extends RawEnr {
         return {
             id,
             multiaddrs: this.getAllLocationMultiaddrs(),
-            protocols: [],
+            protocols: []
         };
     }
     /**
@@ -25345,7 +26315,7 @@ class EnrCreator {
         return ENR.create({
             ...kvs,
             id: utf8ToBytes("v4"),
-            secp256k1: publicKey,
+            secp256k1: publicKey
         });
     }
     static async fromPeerId(peerId, kvs = {}) {
@@ -25988,7 +26958,7 @@ class EnrDecoder {
         if (!encoded.startsWith(ENR.RECORD_PREFIX)) {
             throw new Error(`"string encoded ENR must start with '${ENR.RECORD_PREFIX}'`);
         }
-        return EnrDecoder.fromRLP(fromString$1(encoded.slice(4), "base64url"));
+        return EnrDecoder.fromRLP(fromString(encoded.slice(4), "base64url"));
     }
     static fromRLP(encoded) {
         const decoded = decode(encoded).map(hexToBytes$2);
@@ -26040,4 +27010,4 @@ function checkSignature(seq, kvs, enr, signature) {
     }
 }
 
-export { ENR, ERR_INVALID_ID, ERR_NO_SIGNATURE, EnrCreator, EnrDecoder, MAX_RECORD_SIZE, MULTIADDR_LENGTH_SIZE, TransportProtocol, TransportProtocolPerIpVersion, compressPublicKey$1 as compressPublicKey, createPeerIdFromPublicKey, decodeWaku2, encodeWaku2, getPrivateKeyFromPeerId, getPublicKeyFromPeerId, keccak256, sign$2 as sign, verifySignature };
+export { ENR, ERR_INVALID_ID, ERR_NO_SIGNATURE, EnrCreator, EnrDecoder, MAX_RECORD_SIZE, MULTIADDR_LENGTH_SIZE, TransportProtocol, TransportProtocolPerIpVersion, compressPublicKey$1 as compressPublicKey, createPeerIdFromPublicKey, decodeRelayShard, decodeWaku2, encodeRelayShard, encodeWaku2, getPrivateKeyFromPeerId, getPublicKeyFromPeerId, keccak256, sign$2 as sign, verifySignature };