@waku/core 0.0.1

package/bundle/index-0a4bdddc.js

@@ -0,0 +1,2976 @@
+import { e as errCode } from './index-64ce43f0.js';
+
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+// We don't care about how the IP is invalid. Save time in the error case by using a single error
+const err = new Error("Invalid IP");
+class Parser {
+    index = 0;
+    input = "";
+    new(input) {
+        this.index = 0;
+        this.input = input;
+        return this;
+    }
+    /** Run a parser, and restore the pre-parse state if it fails. */
+    readAtomically(fn) {
+        const index = this.index;
+        try {
+            return fn();
+        }
+        catch (e) {
+            this.index = index;
+            throw e;
+        }
+    }
+    /** Run a parser, but fail if the entire input wasn't consumed. Doesn't run atomically. */
+    parseWith(fn) {
+        const result = fn();
+        if (this.index !== this.input.length) {
+            throw err;
+        }
+        return result;
+    }
+    /** Peek the next character from the input */
+    peekChar() {
+        if (this.index >= this.input.length) {
+            throw err;
+        }
+        return this.input[this.index];
+    }
+    /** Read the next character from the input */
+    readChar() {
+        if (this.index >= this.input.length) {
+            throw err;
+        }
+        return this.input[this.index++];
+    }
+    /** Read the next character from the input if it matches the target. */
+    readGivenChar(target) {
+        return this.readAtomically(() => {
+            const char = this.readChar();
+            if (char !== target) {
+                throw err;
+            }
+        });
+    }
+    /**
+     * Helper for reading separators in an indexed loop. Reads the separator
+     * character iff index > 0, then runs the parser. When used in a loop,
+     * the separator character will only be read on index > 0 (see
+     * readIPv4Addr for an example)
+     */
+    readSeparator(sep, index, inner) {
+        return this.readAtomically(() => {
+            if (index > 0) {
+                this.readGivenChar(sep);
+            }
+            return inner();
+        });
+    }
+    /**
+     * Read a number off the front of the input in the given radix, stopping
+     * at the first non-digit character or eof. Fails if the number has more
+     * digits than max_digits or if there is no number.
+     */
+    readNumber(radix, maxDigits, allowZeroPrefix, maxBytes) {
+        return this.readAtomically(() => {
+            let result = 0;
+            let digitCount = 0;
+            const hasLeadingZero = this.peekChar() === "0";
+            const maxValue = 2 ** (8 * maxBytes) - 1;
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                let digit;
+                try {
+                    digit = this.readAtomically(() => {
+                        const num = Number.parseInt(this.readChar(), radix);
+                        if (Number.isNaN(num)) {
+                            throw err;
+                        }
+                        return num;
+                    });
+                }
+                catch (e) {
+                    break;
+                }
+                result *= radix;
+                result += digit;
+                if (result > maxValue) {
+                    throw err;
+                }
+                digitCount += 1;
+                if (maxDigits !== undefined) {
+                    if (digitCount > maxDigits) {
+                        throw err;
+                    }
+                }
+            }
+            if (digitCount === 0) {
+                throw err;
+            }
+            else if (!allowZeroPrefix && hasLeadingZero && digitCount > 1) {
+                throw err;
+            }
+            else {
+                return result;
+            }
+        });
+    }
+    /** Read an IPv4 address. */
+    readIPv4Addr() {
+        return this.readAtomically(() => {
+            const out = new Uint8Array(4);
+            for (let i = 0; i < out.length; i++) {
+                out[i] = this.readSeparator(".", i, () => this.readNumber(10, 3, false, 1));
+            }
+            return out;
+        });
+    }
+    /** Read an IPv6 Address. */
+    readIPv6Addr() {
+        /**
+         * Read a chunk of an IPv6 address into `groups`. Returns the number
+         * of groups read, along with a bool indicating if an embedded
+         * trailing IPv4 address was read. Specifically, read a series of
+         * colon-separated IPv6 groups (0x0000 - 0xFFFF), with an optional
+         * trailing embedded IPv4 address.
+         */
+        const readGroups = (groups) => {
+            for (let i = 0; i < groups.length / 2; i++) {
+                const ix = i * 2;
+                // Try to read a trailing embedded IPv4 address. There must be at least 4 groups left.
+                if (i < groups.length - 3) {
+                    try {
+                        const ipv4 = this.readSeparator(":", i, () => this.readIPv4Addr());
+                        groups[ix] = ipv4[0];
+                        groups[ix + 1] = ipv4[1];
+                        groups[ix + 2] = ipv4[2];
+                        groups[ix + 3] = ipv4[3];
+                        return [ix + 4, true];
+                        // eslint-disable-next-line no-empty
+                    }
+                    catch (e) { }
+                }
+                try {
+                    const group = this.readSeparator(":", i, () => this.readNumber(16, 4, true, 2));
+                    groups[ix] = group >> 8;
+                    groups[ix + 1] = group & 255;
+                }
+                catch (e) {
+                    return [ix, false];
+                }
+            }
+            return [groups.length, false];
+        };
+        return this.readAtomically(() => {
+            // Read the front part of the address; either the whole thing, or up to the first ::
+            const head = new Uint8Array(16);
+            const [headSize, headIp4] = readGroups(head);
+            if (headSize === 16) {
+                return head;
+            }
+            // IPv4 part is not allowed before `::`
+            if (headIp4) {
+                throw err;
+            }
+            // Read `::` if previous code parsed less than 8 groups.
+            // `::` indicates one or more groups of 16 bits of zeros.
+            this.readGivenChar(":");
+            this.readGivenChar(":");
+            // Read the back part of the address. The :: must contain at least one
+            // set of zeroes, so our max length is 7.
+            const tail = new Uint8Array(14);
+            const limit = 16 - (headSize + 2);
+            const [tailSize] = readGroups(tail.subarray(0, limit));
+            // Concat the head and tail of the IP address
+            head.set(tail.subarray(0, tailSize), 16 - tailSize);
+            return head;
+        });
+    }
+    /** Read an IP Address, either IPv4 or IPv6. */
+    readIPAddr() {
+        try {
+            return this.readIPv4Addr();
+        }
+        catch (e) {
+            return this.readIPv6Addr();
+        }
+    }
+}
+
+// See https://stackoverflow.com/questions/166132/maximum-length-of-the-textual-representation-of-an-ipv6-address
+const MAX_IPV6_LENGTH = 45;
+const MAX_IPV4_LENGTH = 15;
+const parser = new Parser();
+/** Parse `input` into IPv4 bytes. */
+function parseIPv4(input) {
+    if (input.length > MAX_IPV4_LENGTH) {
+        throw err;
+    }
+    return parser.new(input).parseWith(() => parser.readIPv4Addr());
+}
+/** Parse `input` into IPv6 bytes. */
+function parseIPv6(input) {
+    if (input.length > MAX_IPV6_LENGTH) {
+        throw err;
+    }
+    return parser.new(input).parseWith(() => parser.readIPv6Addr());
+}
+/** Parse `input` into IPv4 or IPv6 bytes. */
+function parseIP(input) {
+    if (input.length > MAX_IPV6_LENGTH) {
+        throw err;
+    }
+    return parser.new(input).parseWith(() => parser.readIPAddr());
+}
+/** Check if `input` is IPv4. */
+function isIPv4(input) {
+    try {
+        parseIPv4(input);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+/** Check if `input` is IPv6. */
+function isIPv6(input) {
+    try {
+        parseIPv6(input);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+/** Check if `input` is IPv4 or IPv6. */
+function isIP(input) {
+    try {
+        parseIP(input);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+
+// 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 {Uint8Array} aa
+ * @param {Uint8Array} bb
+ */
+const equals$2 = (aa, bb) => {
+  if (aa === bb) return true
+  if (aa.byteLength !== bb.byteLength) {
+    return false
+  }
+
+  for (let ii = 0; ii < aa.byteLength; ii++) {
+    if (aa[ii] !== bb[ii]) {
+      return false
+    }
+  }
+
+  return true
+};
+
+/**
+ * @param {ArrayBufferView|ArrayBuffer|Uint8Array} o
+ * @returns {Uint8Array}
+ */
+const coerce = o => {
+  if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array') return o
+  if (o instanceof ArrayBuffer) return new Uint8Array(o)
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength)
+  }
+  throw new Error('Unknown type, must be binary type')
+};
+
+/**
+ * @param {string} str
+ * @returns {Uint8Array}
+ */
+const fromString$2 = str => (new TextEncoder()).encode(str);
+
+/**
+ * @param {Uint8Array} b
+ * @returns {string}
+ */
+const toString$2 = b => (new TextDecoder()).decode(b);
+
+/**
+ * Class represents both BaseEncoder and MultibaseEncoder meaning it
+ * can be used to encode to multibase or base encode without multibase
+ * prefix.
+ *
+ * @class
+ * @template {string} Base
+ * @template {string} Prefix
+ * @implements {API.MultibaseEncoder<Prefix>}
+ * @implements {API.BaseEncoder}
+ */
+class Encoder {
+  /**
+   * @param {Base} name
+   * @param {Prefix} prefix
+   * @param {(bytes:Uint8Array) => string} baseEncode
+   */
+  constructor (name, prefix, baseEncode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+  }
+
+  /**
+   * @param {Uint8Array} bytes
+   * @returns {API.Multibase<Prefix>}
+   */
+  encode (bytes) {
+    if (bytes instanceof Uint8Array) {
+      return `${this.prefix}${this.baseEncode(bytes)}`
+    } else {
+      throw Error('Unknown type, must be binary type')
+    }
+  }
+}
+
+/**
+ * @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$5 = (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$4 = (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$4(input, alphabet, bitsPerChar)
+    },
+    decode (input) {
+      return decode$5(input, alphabet, bitsPerChar, name)
+    }
+  })
+};
+
+// @ts-check
+
+const identity$2 = 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$2
+});
+
+// @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({
+  prefix: '9',
+  name: 'base10',
+  alphabet: '0123456789'
+});
+
+var base10$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base10: base10
+});
+
+// @ts-check
+
+const base16 = rfc4648({
+  prefix: 'f',
+  name: 'base16',
+  alphabet: '0123456789abcdef',
+  bitsPerChar: 4
+});
+
+const base16upper = rfc4648({
+  prefix: 'F',
+  name: 'base16upper',
+  alphabet: '0123456789ABCDEF',
+  bitsPerChar: 4
+});
+
+var base16$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base16: base16,
+    base16upper: base16upper
+});
+
+const base32 = rfc4648({
+  prefix: 'b',
+  name: 'base32',
+  alphabet: 'abcdefghijklmnopqrstuvwxyz234567',
+  bitsPerChar: 5
+});
+
+const base32upper = rfc4648({
+  prefix: 'B',
+  name: 'base32upper',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
+  bitsPerChar: 5
+});
+
+const base32pad = rfc4648({
+  prefix: 'c',
+  name: 'base32pad',
+  alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',
+  bitsPerChar: 5
+});
+
+const base32padupper = rfc4648({
+  prefix: 'C',
+  name: 'base32padupper',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',
+  bitsPerChar: 5
+});
+
+const base32hex = rfc4648({
+  prefix: 'v',
+  name: 'base32hex',
+  alphabet: '0123456789abcdefghijklmnopqrstuv',
+  bitsPerChar: 5
+});
+
+const base32hexupper = rfc4648({
+  prefix: 'V',
+  name: 'base32hexupper',
+  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',
+  bitsPerChar: 5
+});
+
+const base32hexpad = rfc4648({
+  prefix: 't',
+  name: 'base32hexpad',
+  alphabet: '0123456789abcdefghijklmnopqrstuv=',
+  bitsPerChar: 5
+});
+
+const base32hexpadupper = rfc4648({
+  prefix: 'T',
+  name: 'base32hexpadupper',
+  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',
+  bitsPerChar: 5
+});
+
+const base32z = rfc4648({
+  prefix: 'h',
+  name: 'base32z',
+  alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',
+  bitsPerChar: 5
+});
+
+var base32$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base32: base32,
+    base32upper: base32upper,
+    base32pad: base32pad,
+    base32padupper: base32padupper,
+    base32hex: base32hex,
+    base32hexupper: base32hexupper,
+    base32hexpad: base32hexpad,
+    base32hexpadupper: base32hexpadupper,
+    base32z: base32z
+});
+
+const base36 = baseX({
+  prefix: 'k',
+  name: 'base36',
+  alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'
+});
+
+const base36upper = baseX({
+  prefix: 'K',
+  name: 'base36upper',
+  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+});
+
+var base36$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base36: base36,
+    base36upper: base36upper
+});
+
+const base58btc = baseX({
+  name: 'base58btc',
+  prefix: 'z',
+  alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+});
+
+const base58flickr = baseX({
+  name: 'base58flickr',
+  prefix: 'Z',
+  alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
+});
+
+var base58 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base58btc: base58btc,
+    base58flickr: base58flickr
+});
+
+// @ts-check
+
+const base64 = rfc4648({
+  prefix: 'm',
+  name: 'base64',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+  bitsPerChar: 6
+});
+
+const base64pad = rfc4648({
+  prefix: 'M',
+  name: 'base64pad',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
+  bitsPerChar: 6
+});
+
+const base64url = rfc4648({
+  prefix: 'u',
+  name: 'base64url',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
+  bitsPerChar: 6
+});
+
+const base64urlpad = rfc4648({
+  prefix: 'U',
+  name: 'base64urlpad',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',
+  bitsPerChar: 6
+});
+
+var base64$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base64: base64,
+    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[]} */([])));
+
+/**
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+function encode$3 (data) {
+  return data.reduce((p, c) => {
+    p += alphabetBytesToChars[c];
+    return p
+  }, '')
+}
+
+/**
+ * @param {string} str
+ * @returns {Uint8Array}
+ */
+function decode$4 (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$1({
+  prefix: '🚀',
+  name: 'base256emoji',
+  encode: encode$3,
+  decode: decode$4
+});
+
+var base256emoji$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base256emoji: base256emoji
+});
+
+var encode_1$1 = encode$2;
+
+var MSB$2 = 0x80
+  , REST$2 = 0x7F
+  , MSBALL$1 = ~REST$2
+  , INT$1 = Math.pow(2, 31);
+
+function encode$2(num, out, offset) {
+  out = out || [];
+  offset = offset || 0;
+  var oldOffset = offset;
+
+  while(num >= INT$1) {
+    out[offset++] = (num & 0xFF) | MSB$2;
+    num /= 128;
+  }
+  while(num & MSBALL$1) {
+    out[offset++] = (num & 0xFF) | MSB$2;
+    num >>>= 7;
+  }
+  out[offset] = num | 0;
+  
+  encode$2.bytes = offset - oldOffset + 1;
+  
+  return out
+}
+
+var decode$3 = read$1;
+
+var MSB$1$1 = 0x80
+  , REST$1$1 = 0x7F;
+
+function read$1(buf, offset) {
+  var res    = 0
+    , offset = offset || 0
+    , shift  = 0
+    , counter = offset
+    , b
+    , l = buf.length;
+
+  do {
+    if (counter >= l) {
+      read$1.bytes = 0;
+      throw new RangeError('Could not decode varint')
+    }
+    b = buf[counter++];
+    res += shift < 28
+      ? (b & REST$1$1) << shift
+      : (b & REST$1$1) * Math.pow(2, shift);
+    shift += 7;
+  } while (b >= MSB$1$1)
+
+  read$1.bytes = counter - 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 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 < N8$1 ? 8
+  : value < N9$1 ? 9
+  :              10
+  )
+};
+
+var varint$1 = {
+    encode: encode_1$1
+  , decode: decode$3
+  , encodingLength: length$1
+};
+
+var _brrp_varint = varint$1;
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} [offset=0]
+ * @returns {[number, number]}
+ */
+const decode$2 = (data, offset = 0) => {
+  const code = _brrp_varint.decode(data, offset);
+  return [code, _brrp_varint.decode.bytes]
+};
+
+/**
+ * @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 = (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)
+};
+
+/**
+ * Turns bytes representation of multihash digest into an instance.
+ *
+ * @param {Uint8Array} multihash
+ * @returns {MultihashDigest}
+ */
+const decode$1 = (multihash) => {
+  const bytes = coerce(multihash);
+  const [code, sizeOffset] = decode$2(bytes);
+  const [size, digestOffset] = decode$2(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)
+};
+
+/**
+ * @param {MultihashDigest} a
+ * @param {unknown} b
+ * @returns {b is MultihashDigest}
+ */
+const equals$1 = (a, b) => {
+  if (a === b) {
+    return true
+  } else {
+    const data = /** @type {{code?:unknown, size?:unknown, bytes?:unknown}} */(b);
+
+    return (
+      a.code === data.code &&
+      a.size === data.size &&
+      data.bytes instanceof Uint8Array &&
+      equals$2(a.bytes, data.bytes)
+    )
+  }
+};
+
+/**
+ * @typedef {import('./interface.js').MultihashDigest} MultihashDigest
+ */
+
+/**
+ * Represents a multihash digest which carries information about the
+ * hashing alogrithm 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;
+  }
+}
+
+/**
+ * @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(this.code, result)
+        /* c8 ignore next 1 */
+        : result.then(digest => create(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')
+});
+
+const sha512 = from({
+  name: 'sha2-512',
+  code: 0x13,
+  encode: sha('SHA-512')
+});
+
+var sha2 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    sha256: sha256,
+    sha512: sha512
+});
+
+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(code, encode$1(input));
+
+const identity = { code, name, encode: encode$1, digest };
+
+var identity$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    identity: identity
+});
+
+// @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
+ * @param {T} link
+ * @param {API.MultibaseEncoder<Prefix>} [base]
+ * @returns {API.ToString<T, Prefix>}
+ */
+const format = (link, base) => {
+  const { bytes, version } = link;
+  switch (version) {
+    case 0:
+      return toStringV0(
+        bytes,
+        baseCache(link),
+        /** @type {API.MultibaseEncoder<"z">} */ (base) || base58btc.encoder
+      )
+    default:
+      return toStringV1(
+        bytes,
+        baseCache(link),
+        /** @type {API.MultibaseEncoder<Prefix>} */ (base || base32.encoder)
+      )
+  }
+};
+
+/** @type {WeakMap<API.UnknownLink, Map<string, string>>} */
+const cache = new WeakMap();
+
+/**
+ * @param {API.UnknownLink} cid
+ * @returns {Map<string, string>}
+ */
+const baseCache = cid => {
+  const baseCache = cache.get(cid);
+  if (baseCache == null) {
+    const baseCache = new Map();
+    cache.set(cid, baseCache);
+    return baseCache
+  }
+  return baseCache
+};
+
+/**
+ * @template {unknown} [Data=unknown]
+ * @template {number} [Format=number]
+ * @template {number} [Alg=number]
+ * @template {API.Version} [Version=API.Version]
+ * @implements {API.Link<Data, Format, Alg, Version>}
+ */
+
+class CID {
+  /**
+   * @param {Version} version - Version of the 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 */
+    this.code = code;
+    /** @readonly */
+    this.version = version;
+    /** @readonly */
+    this.multihash = multihash;
+    /** @readonly */
+    this.bytes = bytes;
+
+    // flag to serializers that this is a CID and
+    // should be treated specially
+    /** @readonly */
+    this['/'] = bytes;
+  }
+
+  /**
+   * Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`
+   * please either use `CID.asCID(cid)` or switch to new signalling mechanism
+   *
+   * @deprecated
+   */
+  get asCID () {
+    return this
+  }
+
+  // ArrayBufferView
+  get byteOffset () {
+    return this.bytes.byteOffset
+  }
+
+  // ArrayBufferView
+  get byteLength () {
+    return this.bytes.byteLength
+  }
+
+  /**
+   * @returns {CID<Data, API.DAG_PB, API.SHA_256, 0>}
+   */
+  toV0 () {
+    switch (this.version) {
+      case 0: {
+        return /** @type {CID<Data, API.DAG_PB, API.SHA_256, 0>} */ (this)
+      }
+      case 1: {
+        const { code, multihash } = this;
+
+        if (code !== DAG_PB_CODE) {
+          throw new Error('Cannot convert a non dag-pb CID to CIDv0')
+        }
+
+        // sha2-256
+        if (multihash.code !== SHA_256_CODE) {
+          throw new Error('Cannot convert non sha2-256 multihash CID to CIDv0')
+        }
+
+        return /** @type {CID<Data, API.DAG_PB, API.SHA_256, 0>} */ (
+          CID.createV0(
+            /** @type {API.MultihashDigest<API.SHA_256>} */ (multihash)
+          )
+        )
+      }
+      default: {
+        throw Error(
+          `Can not convert CID version ${this.version} to version 0. This is a bug please report`
+        )
+      }
+    }
+  }
+
+  /**
+   * @returns {CID<Data, Format, Alg, 1>}
+   */
+  toV1 () {
+    switch (this.version) {
+      case 0: {
+        const { code, digest } = this.multihash;
+        const multihash = create(code, digest);
+        return /** @type {CID<Data, Format, Alg, 1>} */ (
+          CID.createV1(this.code, multihash)
+        )
+      }
+      case 1: {
+        return /** @type {CID<Data, Format, Alg, 1>} */ (this)
+      }
+      default: {
+        throw Error(
+          `Can not convert CID version ${this.version} to version 1. This is a bug please report`
+        )
+      }
+    }
+  }
+
+  /**
+   * @param {unknown} other
+   * @returns {other is CID<Data, Format, Alg, Version>}
+   */
+  equals (other) {
+    return CID.equals(this, other)
+  }
+
+  /**
+   * @template {unknown} Data
+   * @template {number} Format
+   * @template {number} Alg
+   * @template {API.Version} Version
+   * @param {API.Link<Data, Format, Alg, Version>} self
+   * @param {unknown} other
+   * @returns {other is CID}
+   */
+  static equals (self, other) {
+    const unknown =
+      /** @type {{code?:unknown, version?:unknown, multihash?:unknown}} */ (
+        other
+      );
+    return (
+      unknown &&
+      self.code === unknown.code &&
+      self.version === unknown.version &&
+      equals$1(self.multihash, unknown.multihash)
+    )
+  }
+
+  /**
+   * @param {API.MultibaseEncoder<string>} [base]
+   * @returns {string}
+   */
+  toString (base) {
+    return format(this, base)
+  }
+
+  toJSON () {
+    return {
+      code: this.code,
+      version: this.version,
+      hash: this.multihash.bytes
+    }
+  }
+
+  link () {
+    return this
+  }
+
+  get [Symbol.toStringTag] () {
+    return 'CID'
+  }
+
+  // Legacy
+
+  [Symbol.for('nodejs.util.inspect.custom')] () {
+    return `CID(${this.toString()})`
+  }
+
+  /**
+   * Takes any input `value` and returns a `CID` instance if it was
+   * a `CID` otherwise returns `null`. If `value` is instanceof `CID`
+   * it will return value back. If `value` is not instance of this CID
+   * class, but is compatible CID it will return new instance of this
+   * `CID` class. Otherwise returs null.
+   *
+   * This allows two different incompatible versions of CID library to
+   * co-exist and interop as long as binary interface is compatible.
+   *
+   * @template {unknown} Data
+   * @template {number} Format
+   * @template {number} Alg
+   * @template {API.Version} Version
+   * @template {unknown} U
+   * @param {API.Link<Data, Format, Alg, Version>|U} input
+   * @returns {CID<Data, Format, Alg, Version>|null}
+   */
+  static asCID (input) {
+    if (input == null) {
+      return null
+    }
+
+    const value = /** @type {any} */ (input);
+    if (value instanceof CID) {
+      // If value is instance of CID then we're all set.
+      return value
+    } else if ((value['/'] != null && value['/'] === value.bytes) || value.asCID === value) {
+      // If value isn't instance of this CID class but `this.asCID === this` or
+      // `value['/'] === value.bytes` is true it is CID instance coming from a
+      // different implementation (diff version or duplicate). In that case we
+      // rebase it to this `CID` implementation so caller is guaranteed to get
+      // instance with expected API.
+      const { version, code, multihash, bytes } = value;
+      return new CID(
+        version,
+        code,
+        /** @type {API.MultihashDigest<Alg>} */ (multihash),
+        bytes || encodeCID(version, code, multihash.bytes)
+      )
+    } else if (value[cidSymbol] === true) {
+      // If value is a CID from older implementation that used to be tagged via
+      // symbol we still rebase it to the this `CID` implementation by
+      // delegating that to a constructor.
+      const { version, multihash, code } = value;
+      const digest =
+        /** @type {API.MultihashDigest<Alg>} */
+        (decode$1(multihash));
+      return CID.create(version, code, digest)
+    } else {
+      // Otherwise value is not a CID (or an incompatible version of it) in
+      // which case we return `null`.
+      return null
+    }
+  }
+
+  /**
+   *
+   * @template {unknown} Data
+   * @template {number} Format
+   * @template {number} Alg
+   * @template {API.Version} Version
+   * @param {Version} version - Version of the 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>} digest - (Multi)hash of the of the content.
+   * @returns {CID<Data, Format, Alg, Version>}
+   */
+  static create (version, code, digest) {
+    if (typeof code !== 'number') {
+      throw new Error('String codecs are no longer supported')
+    }
+
+    if (!(digest.bytes instanceof Uint8Array)) {
+      throw new Error('Invalid digest')
+    }
+
+    switch (version) {
+      case 0: {
+        if (code !== DAG_PB_CODE) {
+          throw new Error(
+            `Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`
+          )
+        } else {
+          return new CID(version, code, digest, digest.bytes)
+        }
+      }
+      case 1: {
+        const bytes = encodeCID(version, code, digest.bytes);
+        return new CID(version, code, digest, bytes)
+      }
+      default: {
+        throw new Error('Invalid version')
+      }
+    }
+  }
+
+  /**
+   * Simplified version of `create` for CIDv0.
+   *
+   * @template {unknown} [T=unknown]
+   * @param {API.MultihashDigest<typeof SHA_256_CODE>} digest - Multihash.
+   * @returns {CID<T, typeof DAG_PB_CODE, typeof SHA_256_CODE, 0>}
+   */
+  static createV0 (digest) {
+    return CID.create(0, DAG_PB_CODE, digest)
+  }
+
+  /**
+   * Simplified version of `create` for CIDv1.
+   *
+   * @template {unknown} Data
+   * @template {number} Code
+   * @template {number} Alg
+   * @param {Code} code - Content encoding format code.
+   * @param {API.MultihashDigest<Alg>} digest - Miltihash of the content.
+   * @returns {CID<Data, Code, Alg, 1>}
+   */
+  static createV1 (code, digest) {
+    return CID.create(1, code, digest)
+  }
+
+  /**
+   * Decoded a CID from its binary representation. The byte array must contain
+   * only the CID with no additional bytes.
+   *
+   * An error will be thrown if the bytes provided do not contain a valid
+   * binary representation of a CID.
+   *
+   * @template {unknown} Data
+   * @template {number} Code
+   * @template {number} Alg
+   * @template {API.Version} Ver
+   * @param {API.ByteView<API.Link<Data, Code, Alg, Ver>>} bytes
+   * @returns {CID<Data, Code, Alg, Ver>}
+   */
+  static decode (bytes) {
+    const [cid, remainder] = CID.decodeFirst(bytes);
+    if (remainder.length) {
+      throw new Error('Incorrect length')
+    }
+    return cid
+  }
+
+  /**
+   * Decoded a CID from its binary representation at the beginning of a byte
+   * array.
+   *
+   * Returns an array with the first element containing the CID and the second
+   * element containing the remainder of the original byte array. The remainder
+   * will be a zero-length byte array if the provided bytes only contained a
+   * binary CID representation.
+   *
+   * @template {unknown} T
+   * @template {number} C
+   * @template {number} A
+   * @template {API.Version} V
+   * @param {API.ByteView<API.Link<T, C, A, V>>} bytes
+   * @returns {[CID<T, C, A, V>, Uint8Array]}
+   */
+  static decodeFirst (bytes) {
+    const specs = CID.inspectBytes(bytes);
+    const prefixSize = specs.size - specs.multihashSize;
+    const multihashBytes = coerce(
+      bytes.subarray(prefixSize, prefixSize + specs.multihashSize)
+    );
+    if (multihashBytes.byteLength !== specs.multihashSize) {
+      throw new Error('Incorrect length')
+    }
+    const digestBytes = multihashBytes.subarray(
+      specs.multihashSize - specs.digestSize
+    );
+    const digest = new Digest(
+      specs.multihashCode,
+      specs.digestSize,
+      digestBytes,
+      multihashBytes
+    );
+    const cid =
+      specs.version === 0
+        ? CID.createV0(/** @type {API.MultihashDigest<API.SHA_256>} */ (digest))
+        : CID.createV1(specs.codec, digest);
+    return [/** @type {CID<T, C, A, V>} */(cid), bytes.subarray(specs.size)]
+  }
+
+  /**
+   * Inspect the initial bytes of a CID to determine its properties.
+   *
+   * Involves decoding up to 4 varints. Typically this will require only 4 to 6
+   * bytes but for larger multicodec code values and larger multihash digest
+   * lengths these varints can be quite large. It is recommended that at least
+   * 10 bytes be made available in the `initialBytes` argument for a complete
+   * inspection.
+   *
+   * @template {unknown} T
+   * @template {number} C
+   * @template {number} A
+   * @template {API.Version} V
+   * @param {API.ByteView<API.Link<T, C, A, V>>} initialBytes
+   * @returns {{ version:V, codec:C, multihashCode:A, digestSize:number, multihashSize:number, size:number }}
+   */
+  static inspectBytes (initialBytes) {
+    let offset = 0;
+    const next = () => {
+      const [i, length] = decode$2(initialBytes.subarray(offset));
+      offset += length;
+      return i
+    };
+
+    let version = /** @type {V} */ (next());
+    let codec = /** @type {C} */ (DAG_PB_CODE);
+    if (/** @type {number} */(version) === 18) {
+      // CIDv0
+      version = /** @type {V} */ (0);
+      offset = 0;
+    } else {
+      codec = /** @type {C} */ (next());
+    }
+
+    if (version !== 0 && version !== 1) {
+      throw new RangeError(`Invalid CID version ${version}`)
+    }
+
+    const prefixSize = offset;
+    const multihashCode = /** @type {A} */ (next()); // multihash code
+    const digestSize = next(); // multihash length
+    const size = offset + digestSize;
+    const multihashSize = size - prefixSize;
+
+    return { version, codec, multihashCode, digestSize, multihashSize, size }
+  }
+
+  /**
+   * Takes cid in a string representation and creates an instance. If `base`
+   * decoder is not provided will use a default from the configuration. It will
+   * throw an error if encoding of the CID is not compatible with supplied (or
+   * a default decoder).
+   *
+   * @template {string} Prefix
+   * @template {unknown} Data
+   * @template {number} Code
+   * @template {number} Alg
+   * @template {API.Version} Ver
+   * @param {API.ToString<API.Link<Data, Code, Alg, Ver>, Prefix>} source
+   * @param {API.MultibaseDecoder<Prefix>} [base]
+   * @returns {CID<Data, Code, Alg, Ver>}
+   */
+  static parse (source, base) {
+    const [prefix, bytes] = parseCIDtoBytes(source, base);
+
+    const cid = CID.decode(bytes);
+
+    // Cache string representation to avoid computing it on `this.toString()`
+    baseCache(cid).set(prefix, source);
+
+    return cid
+  }
+}
+
+/**
+ * @template {string} Prefix
+ * @template {unknown} Data
+ * @template {number} Code
+ * @template {number} Alg
+ * @template {API.Version} Ver
+ * @param {API.ToString<API.Link<Data, Code, Alg, Ver>, Prefix>} source
+ * @param {API.MultibaseDecoder<Prefix>} [base]
+ * @returns {[Prefix, API.ByteView<API.Link<Data, Code, Alg, Ver>>]}
+ */
+const parseCIDtoBytes = (source, base) => {
+  switch (source[0]) {
+    // CIDv0 is parsed differently
+    case 'Q': {
+      const decoder = base || base58btc;
+      return [
+        /** @type {Prefix} */ (base58btc.prefix),
+        decoder.decode(`${base58btc.prefix}${source}`)
+      ]
+    }
+    case base58btc.prefix: {
+      const decoder = base || base58btc;
+      return [/** @type {Prefix} */(base58btc.prefix), decoder.decode(source)]
+    }
+    case base32.prefix: {
+      const decoder = base || base32;
+      return [/** @type {Prefix} */(base32.prefix), decoder.decode(source)]
+    }
+    default: {
+      if (base == null) {
+        throw Error(
+          'To parse non base32 or base58btc encoded CID multibase decoder must be provided'
+        )
+      }
+      return [/** @type {Prefix} */(source[0]), base.decode(source)]
+    }
+  }
+};
+
+/**
+ *
+ * @param {Uint8Array} bytes
+ * @param {Map<string, string>} cache
+ * @param {API.MultibaseEncoder<'z'>} base
+ */
+const toStringV0 = (bytes, cache, base) => {
+  const { prefix } = base;
+  if (prefix !== base58btc.prefix) {
+    throw Error(`Cannot string encode V0 in ${base.name} encoding`)
+  }
+
+  const cid = cache.get(prefix);
+  if (cid == null) {
+    const cid = base.encode(bytes).slice(1);
+    cache.set(prefix, cid);
+    return cid
+  } else {
+    return cid
+  }
+};
+
+/**
+ * @template {string} Prefix
+ * @param {Uint8Array} bytes
+ * @param {Map<string, string>} cache
+ * @param {API.MultibaseEncoder<Prefix>} base
+ */
+const toStringV1 = (bytes, cache, base) => {
+  const { prefix } = base;
+  const cid = cache.get(prefix);
+  if (cid == null) {
+    const cid = base.encode(bytes);
+    cache.set(prefix, cid);
+    return cid
+  } else {
+    return cid
+  }
+};
+
+const DAG_PB_CODE = 0x70;
+const SHA_256_CODE = 0x12;
+
+/**
+ * @param {API.Version} version
+ * @param {number} code
+ * @param {Uint8Array} multihash
+ * @returns {Uint8Array}
+ */
+const encodeCID = (version, code, multihash) => {
+  const codeOffset = encodingLength(version);
+  const hashOffset = codeOffset + encodingLength(code);
+  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+  encodeTo(version, bytes, 0);
+  encodeTo(code, bytes, codeOffset);
+  bytes.set(multihash, hashOffset);
+  return bytes
+};
+
+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$1, ...base256emoji$1 };
+({ ...sha2, ...identity$1 });
+
+/**
+ * To guarantee Uint8Array semantics, convert nodejs Buffers
+ * into vanilla Uint8Arrays
+ */
+function asUint8Array(buf) {
+    if (globalThis.Buffer != null) {
+        return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    return buf;
+}
+
+/**
+ * Where possible returns a Uint8Array of the requested size that references
+ * uninitialized memory. Only use if you are certain you will immediately
+ * overwrite every value in the returned `Uint8Array`.
+ */
+function allocUnsafe(size = 0) {
+    if (globalThis.Buffer?.allocUnsafe != null) {
+        return asUint8Array(globalThis.Buffer.allocUnsafe(size));
+    }
+    return new Uint8Array(size);
+}
+
+function createCodec(name, prefix, encode, decode) {
+    return {
+        name,
+        prefix,
+        encoder: {
+            name,
+            prefix,
+            encode
+        },
+        decoder: {
+            decode
+        }
+    };
+}
+const string = createCodec('utf8', 'u', (buf) => {
+    const decoder = new TextDecoder('utf8');
+    return 'u' + decoder.decode(buf);
+}, (str) => {
+    const encoder = new TextEncoder();
+    return encoder.encode(str.substring(1));
+});
+const ascii = createCodec('ascii', 'a', (buf) => {
+    let string = 'a';
+    for (let i = 0; i < buf.length; i++) {
+        string += String.fromCharCode(buf[i]);
+    }
+    return string;
+}, (str) => {
+    str = str.substring(1);
+    const buf = allocUnsafe(str.length);
+    for (let i = 0; i < str.length; i++) {
+        buf[i] = str.charCodeAt(i);
+    }
+    return buf;
+});
+const BASES = {
+    utf8: string,
+    'utf-8': string,
+    hex: bases.base16,
+    latin1: ascii,
+    ascii: ascii,
+    binary: ascii,
+    ...bases
+};
+
+/**
+ * Turns a `Uint8Array` into a string.
+ *
+ * Supports `utf8`, `utf-8` and any encoding supported by the multibase module.
+ *
+ * Also `ascii` which is similar to node's 'binary' encoding.
+ */
+function toString$1(array, encoding = 'utf8') {
+    const base = BASES[encoding];
+    if (base == null) {
+        throw new Error(`Unsupported encoding "${encoding}"`);
+    }
+    if ((encoding === 'utf8' || encoding === 'utf-8') && globalThis.Buffer != null && globalThis.Buffer.from != null) {
+        return globalThis.Buffer.from(array.buffer, array.byteOffset, array.byteLength).toString('utf8');
+    }
+    // strip multibase prefix
+    return base.encoder.encode(array).substring(1);
+}
+
+const isV4 = isIPv4;
+const isV6 = isIPv6;
+// Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L7
+// but with buf/offset args removed because we don't use them
+const toBytes = function (ip) {
+    let offset = 0;
+    ip = ip.toString().trim();
+    if (isV4(ip)) {
+        const bytes = new Uint8Array(offset + 4);
+        ip.split(/\./g).forEach((byte) => {
+            bytes[offset++] = parseInt(byte, 10) & 0xff;
+        });
+        return bytes;
+    }
+    if (isV6(ip)) {
+        const sections = ip.split(':', 8);
+        let i;
+        for (i = 0; i < sections.length; i++) {
+            const isv4 = isV4(sections[i]);
+            let v4Buffer;
+            if (isv4) {
+                v4Buffer = toBytes(sections[i]);
+                sections[i] = toString$1(v4Buffer.slice(0, 2), 'base16');
+            }
+            if (v4Buffer != null && ++i < 8) {
+                sections.splice(i, 0, toString$1(v4Buffer.slice(2, 4), 'base16'));
+            }
+        }
+        if (sections[0] === '') {
+            while (sections.length < 8)
+                sections.unshift('0');
+        }
+        else if (sections[sections.length - 1] === '') {
+            while (sections.length < 8)
+                sections.push('0');
+        }
+        else if (sections.length < 8) {
+            for (i = 0; i < sections.length && sections[i] !== ''; i++)
+                ;
+            const argv = [i, 1];
+            for (i = 9 - sections.length; i > 0; i--) {
+                argv.push('0');
+            }
+            sections.splice.apply(sections, argv);
+        }
+        const bytes = new Uint8Array(offset + 16);
+        for (i = 0; i < sections.length; i++) {
+            const word = parseInt(sections[i], 16);
+            bytes[offset++] = (word >> 8) & 0xff;
+            bytes[offset++] = word & 0xff;
+        }
+        return bytes;
+    }
+    throw new Error('invalid ip address');
+};
+// Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L63
+const toString = function (buf, offset = 0, length) {
+    offset = ~~offset;
+    length = length ?? (buf.length - offset);
+    const view = new DataView(buf.buffer);
+    if (length === 4) {
+        const result = [];
+        // IPv4
+        for (let i = 0; i < length; i++) {
+            result.push(buf[offset + i]);
+        }
+        return result.join('.');
+    }
+    if (length === 16) {
+        const result = [];
+        // IPv6
+        for (let i = 0; i < length; i += 2) {
+            result.push(view.getUint16(offset + i).toString(16));
+        }
+        return result.join(':')
+            .replace(/(^|:)0(:0)*:0(:|$)/, '$1::$3')
+            .replace(/:{3,4}/, '::');
+    }
+    return '';
+};
+
+const V = -1;
+const names = {};
+const codes = {};
+const table = [
+    [4, 32, 'ip4'],
+    [6, 16, 'tcp'],
+    [33, 16, 'dccp'],
+    [41, 128, 'ip6'],
+    [42, V, 'ip6zone'],
+    [53, V, 'dns', true],
+    [54, V, 'dns4', true],
+    [55, V, 'dns6', true],
+    [56, V, 'dnsaddr', true],
+    [132, 16, 'sctp'],
+    [273, 16, 'udp'],
+    [275, 0, 'p2p-webrtc-star'],
+    [276, 0, 'p2p-webrtc-direct'],
+    [277, 0, 'p2p-stardust'],
+    [280, 0, 'webrtc'],
+    [290, 0, 'p2p-circuit'],
+    [301, 0, 'udt'],
+    [302, 0, 'utp'],
+    [400, V, 'unix', false, true],
+    // `ipfs` is added before `p2p` for legacy support.
+    // All text representations will default to `p2p`, but `ipfs` will
+    // still be supported
+    [421, V, 'ipfs'],
+    // `p2p` is the preferred name for 421, and is now the default
+    [421, V, 'p2p'],
+    [443, 0, 'https'],
+    [444, 96, 'onion'],
+    [445, 296, 'onion3'],
+    [446, V, 'garlic64'],
+    [460, 0, 'quic'],
+    [465, 0, 'webtransport'],
+    [466, V, 'certhash'],
+    [477, 0, 'ws'],
+    [478, 0, 'wss'],
+    [479, 0, 'p2p-websocket-star'],
+    [480, 0, 'http'],
+    [777, V, 'memory']
+];
+// populate tables
+table.forEach(row => {
+    const proto = createProtocol(...row);
+    codes[proto.code] = proto;
+    names[proto.name] = proto;
+});
+function createProtocol(code, size, name, resolvable, path) {
+    return {
+        code,
+        size,
+        name,
+        resolvable: Boolean(resolvable),
+        path: Boolean(path)
+    };
+}
+function getProtocol(proto) {
+    if (typeof proto === 'number') {
+        if (codes[proto] != null) {
+            return codes[proto];
+        }
+        throw new Error(`no protocol with code: ${proto}`);
+    }
+    else if (typeof proto === 'string') {
+        if (names[proto] != null) {
+            return names[proto];
+        }
+        throw new Error(`no protocol with name: ${proto}`);
+    }
+    throw new Error(`invalid protocol id type: ${typeof proto}`);
+}
+
+var encode_1 = encode;
+
+var MSB$1 = 0x80
+  , REST$1 = 0x7F
+  , MSBALL = ~REST$1
+  , INT = Math.pow(2, 31);
+
+function encode(num, out, offset) {
+  if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
+    encode.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.bytes = offset - oldOffset + 1;
+  
+  return out
+}
+
+var decode = 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
+  , encodingLength: length
+};
+
+/**
+ * Create a `Uint8Array` from the passed string
+ *
+ * Supports `utf8`, `utf-8`, `hex`, and any encoding supported by the multiformats module.
+ *
+ * Also `ascii` which is similar to node's 'binary' encoding.
+ */
+function fromString$1(string, encoding = 'utf8') {
+    const base = BASES[encoding];
+    if (base == null) {
+        throw new Error(`Unsupported encoding "${encoding}"`);
+    }
+    if ((encoding === 'utf8' || encoding === 'utf-8') && globalThis.Buffer != null && globalThis.Buffer.from != null) {
+        return asUint8Array(globalThis.Buffer.from(string, 'utf-8'));
+    }
+    // add multibase prefix
+    return base.decoder.decode(`${base.prefix}${string}`); // eslint-disable-line @typescript-eslint/restrict-template-expressions
+}
+
+/**
+ * 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);
+}
+
+/**
+ * Convert [code,Uint8Array] to string
+ */
+function convertToString(proto, buf) {
+    const protocol = getProtocol(proto);
+    switch (protocol.code) {
+        case 4: // ipv4
+        case 41: // ipv6
+            return bytes2ip(buf);
+        case 6: // tcp
+        case 273: // udp
+        case 33: // dccp
+        case 132: // sctp
+            return bytes2port(buf).toString();
+        case 53: // dns
+        case 54: // dns4
+        case 55: // dns6
+        case 56: // dnsaddr
+        case 400: // unix
+        case 777: // memory
+            return bytes2str(buf);
+        case 421: // ipfs
+            return bytes2mh(buf);
+        case 444: // onion
+            return bytes2onion(buf);
+        case 445: // onion3
+            return bytes2onion(buf);
+        case 466: // certhash
+            return bytes2mb(buf);
+        default:
+            return toString$1(buf, 'base16'); // no clue. convert to hex
+    }
+}
+function convertToBytes(proto, str) {
+    const protocol = getProtocol(proto);
+    switch (protocol.code) {
+        case 4: // ipv4
+            return ip2bytes(str);
+        case 41: // ipv6
+            return ip2bytes(str);
+        case 6: // tcp
+        case 273: // udp
+        case 33: // dccp
+        case 132: // sctp
+            return port2bytes(parseInt(str, 10));
+        case 53: // dns
+        case 54: // dns4
+        case 55: // dns6
+        case 56: // dnsaddr
+        case 400: // unix
+        case 777: // memory
+            return str2bytes(str);
+        case 421: // ipfs
+            return mh2bytes(str);
+        case 444: // onion
+            return onion2bytes(str);
+        case 445: // onion3
+            return onion32bytes(str);
+        case 466: // certhash
+            return mb2bytes(str);
+        default:
+            return fromString$1(str, 'base16'); // no clue. convert from hex
+    }
+}
+const decoders = Object.values(bases).map((c) => c.decoder);
+const anybaseDecoder = (function () {
+    let acc = decoders[0].or(decoders[1]);
+    decoders.slice(2).forEach((d) => (acc = acc.or(d)));
+    return acc;
+})();
+function ip2bytes(ipString) {
+    if (!isIP(ipString)) {
+        throw new Error('invalid ip address');
+    }
+    return toBytes(ipString);
+}
+function bytes2ip(ipBuff) {
+    const ipString = toString(ipBuff, 0, ipBuff.length);
+    if (ipString == null) {
+        throw new Error('ipBuff is required');
+    }
+    if (!isIP(ipString)) {
+        throw new Error('invalid ip address');
+    }
+    return ipString;
+}
+function port2bytes(port) {
+    const buf = new ArrayBuffer(2);
+    const view = new DataView(buf);
+    view.setUint16(0, port);
+    return new Uint8Array(buf);
+}
+function bytes2port(buf) {
+    const view = new DataView(buf.buffer);
+    return view.getUint16(buf.byteOffset);
+}
+function str2bytes(str) {
+    const buf = fromString$1(str);
+    const size = Uint8Array.from(varint.encode(buf.length));
+    return concat([size, buf], size.length + buf.length);
+}
+function bytes2str(buf) {
+    const size = varint.decode(buf);
+    buf = buf.slice(varint.decode.bytes);
+    if (buf.length !== size) {
+        throw new Error('inconsistent lengths');
+    }
+    return toString$1(buf);
+}
+function mh2bytes(hash) {
+    let mh;
+    if (hash[0] === 'Q' || hash[0] === '1') {
+        mh = decode$1(base58btc.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.encode(mh.length));
+    return concat([size, mh], size.length + mh.length);
+}
+function mb2bytes(mbstr) {
+    const mb = anybaseDecoder.decode(mbstr);
+    const size = Uint8Array.from(varint.encode(mb.length));
+    return concat([size, mb], size.length + mb.length);
+}
+function bytes2mb(buf) {
+    const size = varint.decode(buf);
+    const hash = buf.slice(varint.decode.bytes);
+    if (hash.length !== size) {
+        throw new Error('inconsistent lengths');
+    }
+    return 'u' + toString$1(hash, 'base64url');
+}
+/**
+ * Converts bytes to bas58btc string
+ */
+function bytes2mh(buf) {
+    const size = varint.decode(buf);
+    const address = buf.slice(varint.decode.bytes);
+    if (address.length !== size) {
+        throw new Error('inconsistent lengths');
+    }
+    return toString$1(address, 'base58btc');
+}
+function onion2bytes(str) {
+    const addr = str.split(':');
+    if (addr.length !== 2) {
+        throw new Error(`failed to parse onion addr: ["'${addr.join('", "')}'"]' does not contain a port number`);
+    }
+    if (addr[0].length !== 16) {
+        throw new Error(`failed to parse onion addr: ${addr[0]} not a Tor onion address.`);
+    }
+    // onion addresses do not include the multibase prefix, add it before decoding
+    const buf = base32.decode('b' + addr[0]);
+    // onion port number
+    const port = parseInt(addr[1], 10);
+    if (port < 1 || port > 65536) {
+        throw new Error('Port number is not in range(1, 65536)');
+    }
+    const portBuf = port2bytes(port);
+    return concat([buf, portBuf], buf.length + portBuf.length);
+}
+function onion32bytes(str) {
+    const addr = str.split(':');
+    if (addr.length !== 2) {
+        throw new Error(`failed to parse onion addr: ["'${addr.join('", "')}'"]' does not contain a port number`);
+    }
+    if (addr[0].length !== 56) {
+        throw new Error(`failed to parse onion addr: ${addr[0]} not a Tor onion3 address.`);
+    }
+    // onion addresses do not include the multibase prefix, add it before decoding
+    const buf = base32.decode(`b${addr[0]}`);
+    // onion port number
+    const port = parseInt(addr[1], 10);
+    if (port < 1 || port > 65536) {
+        throw new Error('Port number is not in range(1, 65536)');
+    }
+    const portBuf = port2bytes(port);
+    return concat([buf, portBuf], buf.length + portBuf.length);
+}
+function bytes2onion(buf) {
+    const addrBytes = buf.slice(0, buf.length - 2);
+    const portBytes = buf.slice(buf.length - 2);
+    const addr = toString$1(addrBytes, 'base32');
+    const port = bytes2port(portBytes);
+    return `${addr}:${port}`;
+}
+
+/**
+ * string -> [[str name, str addr]... ]
+ */
+function stringToStringTuples(str) {
+    const tuples = [];
+    const parts = str.split('/').slice(1); // skip first empty elem
+    if (parts.length === 1 && parts[0] === '') {
+        return [];
+    }
+    for (let p = 0; p < parts.length; p++) {
+        const part = parts[p];
+        const proto = getProtocol(part);
+        if (proto.size === 0) {
+            tuples.push([part]);
+            continue;
+        }
+        p++; // advance addr part
+        if (p >= parts.length) {
+            throw ParseError('invalid address: ' + str);
+        }
+        // if it's a path proto, take the rest
+        if (proto.path === true) {
+            tuples.push([
+                part,
+                // TODO: 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('/'))
+            ]);
+            break;
+        }
+        tuples.push([part, parts[p]]);
+    }
+    return tuples;
+}
+/**
+ * [[str name, str addr]... ] -> string
+ */
+function stringTuplesToString(tuples) {
+    const parts = [];
+    tuples.map((tup) => {
+        const proto = protoFromTuple(tup);
+        parts.push(proto.name);
+        if (tup.length > 1 && tup[1] != null) {
+            parts.push(tup[1]);
+        }
+        return null;
+    });
+    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.encode(proto.code));
+        if (tup.length > 1 && tup[1] != null) {
+            buf = concat([buf, tup[1]]); // add address buffer
+        }
+        return buf;
+    })));
+}
+function sizeForAddr(p, addr) {
+    if (p.size > 0) {
+        return p.size / 8;
+    }
+    else if (p.size === 0) {
+        return 0;
+    }
+    else {
+        const size = varint.decode(addr);
+        return size + varint.decode.bytes;
+    }
+}
+function bytesToTuples(buf) {
+    const tuples = [];
+    let i = 0;
+    while (i < buf.length) {
+        const code = varint.decode(buf, i);
+        const n = varint.decode.bytes;
+        const p = getProtocol(code);
+        const size = sizeForAddr(p, buf.slice(i + n));
+        if (size === 0) {
+            tuples.push([code]);
+            i += n;
+            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;
+    }
+}
+function cleanPath(str) {
+    return '/' + str.trim().split('/').filter((a) => a).join('/');
+}
+function ParseError(str) {
+    return new Error('Error parsing address: ' + str);
+}
+function protoFromTuple(tup) {
+    const proto = getProtocol(tup[0]);
+    return proto;
+}
+
+/**
+ * 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;
+}
+
+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, _a;
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+const DNS_CODES = [
+    getProtocol('dns').code,
+    getProtocol('dns4').code,
+    getProtocol('dns6').code,
+    getProtocol('dnsaddr').code
+];
+const P2P_CODES = [
+    getProtocol('p2p').code,
+    getProtocol('ipfs').code
+];
+const resolvers = new Map();
+const symbol = Symbol.for('@multiformats/js-multiaddr/multiaddr');
+/**
+ * Check if object is a CID instance
+ */
+function isMultiaddr(value) {
+    return Boolean(value?.[symbol]);
+}
+/**
+ * Creates a [multiaddr](https://github.com/multiformats/multiaddr) from
+ * a Uint8Array, String or another Multiaddr instance
+ * public key.
+ *
+ */
+class DefaultMultiaddr {
+    /**
+     * @example
+     * ```js
+     * new Multiaddr('/ip4/127.0.0.1/tcp/4001')
+     * // <Multiaddr 047f000001060fa1 - /ip4/127.0.0.1/tcp/4001>
+     * ```
+     *
+     * @param {MultiaddrInput} [addr] - If String or Uint8Array, needs to adhere to the address format of a [multiaddr](https://github.com/multiformats/multiaddr#string-format)
+     */
+    constructor(addr) {
+        _DefaultMultiaddr_string.set(this, void 0);
+        _DefaultMultiaddr_tuples.set(this, void 0);
+        _DefaultMultiaddr_stringTuples.set(this, void 0);
+        this[_a] = true;
+        // default
+        if (addr == null) {
+            addr = '';
+        }
+        if (addr instanceof Uint8Array) {
+            this.bytes = fromBytes(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);
+        }
+        else if (isMultiaddr(addr)) { // Multiaddr
+            this.bytes = fromBytes(addr.bytes); // validate + copy buffer
+        }
+        else {
+            throw new Error('addr must be a string, Buffer, or another Multiaddr');
+        }
+    }
+    toString() {
+        if (__classPrivateFieldGet(this, _DefaultMultiaddr_string, "f") == null) {
+            __classPrivateFieldSet(this, _DefaultMultiaddr_string, bytesToString(this.bytes), "f");
+        }
+        return __classPrivateFieldGet(this, _DefaultMultiaddr_string, "f");
+    }
+    toJSON() {
+        return this.toString();
+    }
+    toOptions() {
+        const codes = this.protoCodes();
+        const parts = this.toString().split('/').slice(1);
+        let transport;
+        let port;
+        if (parts.length > 2) {
+            // default to https when protocol & port are omitted from DNS addrs
+            if (DNS_CODES.includes(codes[0]) && P2P_CODES.includes(codes[1])) {
+                transport = getProtocol('tcp').name;
+                port = 443;
+            }
+            else {
+                transport = getProtocol(parts[2]).name;
+                port = parseInt(parts[3]);
+            }
+        }
+        else if (DNS_CODES.includes(codes[0])) {
+            transport = getProtocol('tcp').name;
+            port = 443;
+        }
+        else {
+            throw new Error('multiaddr must have a valid format: "/{ip4, ip6, dns4, dns6, dnsaddr}/{address}/{tcp, udp}/{port}".');
+        }
+        const opts = {
+            family: (codes[0] === 41 || codes[0] === 55) ? 6 : 4,
+            host: parts[1],
+            transport,
+            port
+        };
+        return opts;
+    }
+    protos() {
+        return this.protoCodes().map(code => Object.assign({}, getProtocol(code)));
+    }
+    protoCodes() {
+        const codes = [];
+        const buf = this.bytes;
+        let i = 0;
+        while (i < buf.length) {
+            const code = varint.decode(buf, i);
+            const n = varint.decode.bytes;
+            const p = getProtocol(code);
+            const size = sizeForAddr(p, buf.slice(i + n));
+            i += (size + n);
+            codes.push(code);
+        }
+        return codes;
+    }
+    protoNames() {
+        return this.protos().map(proto => proto.name);
+    }
+    tuples() {
+        if (__classPrivateFieldGet(this, _DefaultMultiaddr_tuples, "f") == null) {
+            __classPrivateFieldSet(this, _DefaultMultiaddr_tuples, bytesToTuples(this.bytes), "f");
+        }
+        return __classPrivateFieldGet(this, _DefaultMultiaddr_tuples, "f");
+    }
+    stringTuples() {
+        if (__classPrivateFieldGet(this, _DefaultMultiaddr_stringTuples, "f") == null) {
+            __classPrivateFieldSet(this, _DefaultMultiaddr_stringTuples, tuplesToStringTuples(this.tuples()), "f");
+        }
+        return __classPrivateFieldGet(this, _DefaultMultiaddr_stringTuples, "f");
+    }
+    encapsulate(addr) {
+        addr = new DefaultMultiaddr(addr);
+        return new DefaultMultiaddr(this.toString() + addr.toString());
+    }
+    decapsulate(addr) {
+        const addrString = addr.toString();
+        const s = this.toString();
+        const i = s.lastIndexOf(addrString);
+        if (i < 0) {
+            throw new Error(`Address ${this.toString()} does not contain subaddress: ${addr.toString()}`);
+        }
+        return new DefaultMultiaddr(s.slice(0, i));
+    }
+    decapsulateCode(code) {
+        const tuples = this.tuples();
+        for (let i = tuples.length - 1; i >= 0; i--) {
+            if (tuples[i][0] === code) {
+                return new DefaultMultiaddr(tuplesToBytes(tuples.slice(0, i)));
+            }
+        }
+        return this;
+    }
+    getPeerId() {
+        try {
+            const tuples = this.stringTuples().filter((tuple) => {
+                if (tuple[0] === names.ipfs.code) {
+                    return true;
+                }
+                return false;
+            });
+            // Get the last ipfs tuple ['ipfs', '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');
+                }
+                // try to parse peer id as CID
+                return toString$1(CID.parse(peerIdStr).multihash.bytes, 'base58btc');
+            }
+            return null;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    getPath() {
+        let path = null;
+        try {
+            path = this.stringTuples().filter((tuple) => {
+                const proto = getProtocol(tuple[0]);
+                if (proto.path === true) {
+                    return true;
+                }
+                return false;
+            })[0][1];
+            if (path == null) {
+                path = null;
+            }
+        }
+        catch {
+            path = null;
+        }
+        return path;
+    }
+    equals(addr) {
+        return equals(this.bytes, addr.bytes);
+    }
+    async resolve(options) {
+        const resolvableProto = this.protos().find((p) => p.resolvable);
+        // Multiaddr is not resolvable?
+        if (resolvableProto == null) {
+            return [this];
+        }
+        const resolver = resolvers.get(resolvableProto.name);
+        if (resolver == null) {
+            throw errCode(new Error(`no available resolver for ${resolvableProto.name}`), 'ERR_NO_AVAILABLE_RESOLVER');
+        }
+        const addresses = await resolver(this, options);
+        return addresses.map((a) => new DefaultMultiaddr(a));
+    }
+    nodeAddress() {
+        const options = this.toOptions();
+        if (options.transport !== 'tcp' && options.transport !== 'udp') {
+            throw new Error(`multiaddr must have a valid format - no protocol with name: "${options.transport}". Must have a valid transport protocol: "{tcp, udp}"`);
+        }
+        return {
+            family: options.family,
+            address: options.host,
+            port: options.port
+        };
+    }
+    isThinWaistAddress(addr) {
+        const protos = (addr ?? this).protos();
+        if (protos.length !== 2) {
+            return false;
+        }
+        if (protos[0].code !== 4 && protos[0].code !== 41) {
+            return false;
+        }
+        if (protos[1].code !== 6 && protos[1].code !== 273) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Returns Multiaddr as a human-readable string.
+     * For post Node.js v10.0.0.
+     * https://nodejs.org/api/deprecations.html#deprecations_dep0079_custom_inspection_function_on_objects_via_inspect
+     *
+     * @example
+     * ```js
+     * console.log(new Multiaddr('/ip4/127.0.0.1/tcp/4001'))
+     * // '<Multiaddr 047f000001060fa1 - /ip4/127.0.0.1/tcp/4001>'
+     * ```
+     */
+    [(_DefaultMultiaddr_string = new WeakMap(), _DefaultMultiaddr_tuples = new WeakMap(), _DefaultMultiaddr_stringTuples = new WeakMap(), _a = symbol, inspect)]() {
+        return this.inspect();
+    }
+    inspect() {
+        return '<Multiaddr ' +
+            toString$1(this.bytes, 'base16') + ' - ' +
+            bytesToString(this.bytes) + '>';
+    }
+}
+/**
+ * Static factory
+ *
+ * @example
+ * ```js
+ * new Multiaddr('/ip4/127.0.0.1/tcp/4001')
+ * // <Multiaddr 047f000001060fa1 - /ip4/127.0.0.1/tcp/4001>
+ * ```
+ *
+ * @param {MultiaddrInput} [addr] - If String or Uint8Array, needs to adhere to the address format of a [multiaddr](https://github.com/multiformats/multiaddr#string-format)
+ */
+function multiaddr(addr) {
+    return new DefaultMultiaddr(addr);
+}
+
+export { convertToBytes as a, convertToString as c, multiaddr as m };