cairn-p2p 0.3.2 → 0.4.0

package/dist/browser.cjs

@@ -9,14 +9,14 @@ var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
+var __copyProps = (to, from3, except, desc) => {
+  if (from3 && typeof from3 === "object" || typeof from3 === "function") {
+    for (let key of __getOwnPropNames(from3))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from3[key], enumerable: !(desc = __getOwnPropDesc(from3, key)) || desc.enumerable });
   }
   return to;
 };
@@ -126,6 +126,3419 @@ var init_libp2p_node = __esm({
   }
 });
 
+// node_modules/multiformats/dist/src/bytes.js
+function equals(aa, bb) {
+  if (aa === bb) {
+    return true;
+  }
+  if (aa.byteLength !== bb.byteLength) {
+    return false;
+  }
+  for (let ii = 0; ii < aa.byteLength; ii++) {
+    if (aa[ii] !== bb[ii]) {
+      return false;
+    }
+  }
+  return true;
+}
+function coerce(o) {
+  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array") {
+    return o;
+  }
+  if (o instanceof ArrayBuffer) {
+    return new Uint8Array(o);
+  }
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+  }
+  throw new Error("Unknown type, must be binary type");
+}
+function fromString(str) {
+  return new TextEncoder().encode(str);
+}
+function toString(b) {
+  return new TextDecoder().decode(b);
+}
+var empty;
+var init_bytes = __esm({
+  "node_modules/multiformats/dist/src/bytes.js"() {
+    "use strict";
+    empty = new Uint8Array(0);
+  }
+});
+
+// node_modules/multiformats/dist/src/vendor/base-x.js
+function base(ALPHABET, name2) {
+  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);
+  var iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode7(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 "";
+    }
+    var zeroes = 0;
+    var length2 = 0;
+    var pbegin = 0;
+    var pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    var b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      var carry = source[pbegin];
+      var i2 = 0;
+      for (var it1 = size - 1; (carry !== 0 || i2 < length2) && it1 !== -1; it1--, i2++) {
+        carry += 256 * b58[it1] >>> 0;
+        b58[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length2 = i2;
+      pbegin++;
+    }
+    var it2 = size - length2;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    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;
+    if (source[psz] === " ") {
+      return;
+    }
+    var zeroes = 0;
+    var length2 = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    var size = (source.length - psz) * FACTOR + 1 >>> 0;
+    var b256 = new Uint8Array(size);
+    while (source[psz]) {
+      var carry = BASE_MAP[source.charCodeAt(psz)];
+      if (carry === 255) {
+        return;
+      }
+      var i2 = 0;
+      for (var it3 = size - 1; (carry !== 0 || i2 < length2) && it3 !== -1; it3--, i2++) {
+        carry += BASE * b256[it3] >>> 0;
+        b256[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length2 = i2;
+      psz++;
+    }
+    if (source[psz] === " ") {
+      return;
+    }
+    var it4 = size - length2;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    var vch = new Uint8Array(zeroes + (size - it4));
+    var j2 = zeroes;
+    while (it4 !== size) {
+      vch[j2++] = b256[it4++];
+    }
+    return vch;
+  }
+  function decode9(string2) {
+    var buffer = decodeUnsafe(string2);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error(`Non-${name2} character`);
+  }
+  return {
+    encode: encode7,
+    decodeUnsafe,
+    decode: decode9
+  };
+}
+var src, _brrp__multiformats_scope_baseX, base_x_default;
+var init_base_x = __esm({
+  "node_modules/multiformats/dist/src/vendor/base-x.js"() {
+    "use strict";
+    src = base;
+    _brrp__multiformats_scope_baseX = src;
+    base_x_default = _brrp__multiformats_scope_baseX;
+  }
+});
+
+// node_modules/multiformats/dist/src/bases/base.js
+function or(left, right) {
+  return new ComposedDecoder({
+    ...left.decoders ?? { [left.prefix]: left },
+    ...right.decoders ?? { [right.prefix]: right }
+  });
+}
+function from({ name: name2, prefix, encode: encode7, decode: decode9 }) {
+  return new Codec(name2, prefix, encode7, decode9);
+}
+function baseX({ name: name2, prefix, alphabet: alphabet2 }) {
+  const { encode: encode7, decode: decode9 } = base_x_default(alphabet2, name2);
+  return from({
+    prefix,
+    name: name2,
+    encode: encode7,
+    decode: (text) => coerce(decode9(text))
+  });
+}
+function decode3(string2, alphabetIdx, bitsPerChar, name2) {
+  let end = string2.length;
+  while (string2[end - 1] === "=") {
+    --end;
+  }
+  const out = new Uint8Array(end * bitsPerChar / 8 | 0);
+  let bits = 0;
+  let buffer = 0;
+  let written = 0;
+  for (let i = 0; i < end; ++i) {
+    const value = alphabetIdx[string2[i]];
+    if (value === void 0) {
+      throw new SyntaxError(`Non-${name2} character`);
+    }
+    buffer = buffer << bitsPerChar | value;
+    bits += bitsPerChar;
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 255 & buffer >> bits;
+    }
+  }
+  if (bits >= bitsPerChar || (255 & buffer << 8 - bits) !== 0) {
+    throw new SyntaxError("Unexpected end of data");
+  }
+  return out;
+}
+function encode3(data, alphabet2, bitsPerChar) {
+  const pad = alphabet2[alphabet2.length - 1] === "=";
+  const mask = (1 << bitsPerChar) - 1;
+  let out = "";
+  let bits = 0;
+  let buffer = 0;
+  for (let i = 0; i < data.length; ++i) {
+    buffer = buffer << 8 | data[i];
+    bits += 8;
+    while (bits > bitsPerChar) {
+      bits -= bitsPerChar;
+      out += alphabet2[mask & buffer >> bits];
+    }
+  }
+  if (bits !== 0) {
+    out += alphabet2[mask & buffer << bitsPerChar - bits];
+  }
+  if (pad) {
+    while ((out.length * bitsPerChar & 7) !== 0) {
+      out += "=";
+    }
+  }
+  return out;
+}
+function createAlphabetIdx(alphabet2) {
+  const alphabetIdx = {};
+  for (let i = 0; i < alphabet2.length; ++i) {
+    alphabetIdx[alphabet2[i]] = i;
+  }
+  return alphabetIdx;
+}
+function rfc4648({ name: name2, prefix, bitsPerChar, alphabet: alphabet2 }) {
+  const alphabetIdx = createAlphabetIdx(alphabet2);
+  return from({
+    prefix,
+    name: name2,
+    encode(input) {
+      return encode3(input, alphabet2, bitsPerChar);
+    },
+    decode(input) {
+      return decode3(input, alphabetIdx, bitsPerChar, name2);
+    }
+  });
+}
+var Encoder, Decoder, ComposedDecoder, Codec;
+var init_base = __esm({
+  "node_modules/multiformats/dist/src/bases/base.js"() {
+    "use strict";
+    init_bytes();
+    init_base_x();
+    Encoder = class {
+      name;
+      prefix;
+      baseEncode;
+      constructor(name2, prefix, baseEncode) {
+        this.name = name2;
+        this.prefix = prefix;
+        this.baseEncode = baseEncode;
+      }
+      encode(bytes) {
+        if (bytes instanceof Uint8Array) {
+          return `${this.prefix}${this.baseEncode(bytes)}`;
+        } else {
+          throw Error("Unknown type, must be binary type");
+        }
+      }
+    };
+    Decoder = class {
+      name;
+      prefix;
+      baseDecode;
+      prefixCodePoint;
+      constructor(name2, prefix, baseDecode) {
+        this.name = name2;
+        this.prefix = prefix;
+        const prefixCodePoint = prefix.codePointAt(0);
+        if (prefixCodePoint === void 0) {
+          throw new Error("Invalid prefix character");
+        }
+        this.prefixCodePoint = prefixCodePoint;
+        this.baseDecode = baseDecode;
+      }
+      decode(text) {
+        if (typeof text === "string") {
+          if (text.codePointAt(0) !== this.prefixCodePoint) {
+            throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+          }
+          return this.baseDecode(text.slice(this.prefix.length));
+        } else {
+          throw Error("Can only multibase decode strings");
+        }
+      }
+      or(decoder) {
+        return or(this, decoder);
+      }
+    };
+    ComposedDecoder = class {
+      decoders;
+      constructor(decoders2) {
+        this.decoders = decoders2;
+      }
+      or(decoder) {
+        return or(this, decoder);
+      }
+      decode(input) {
+        const prefix = input[0];
+        const decoder = this.decoders[prefix];
+        if (decoder != null) {
+          return decoder.decode(input);
+        } else {
+          throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+        }
+      }
+    };
+    Codec = class {
+      name;
+      prefix;
+      baseEncode;
+      baseDecode;
+      encoder;
+      decoder;
+      constructor(name2, prefix, baseEncode, baseDecode) {
+        this.name = name2;
+        this.prefix = prefix;
+        this.baseEncode = baseEncode;
+        this.baseDecode = baseDecode;
+        this.encoder = new Encoder(name2, prefix, baseEncode);
+        this.decoder = new Decoder(name2, prefix, baseDecode);
+      }
+      encode(input) {
+        return this.encoder.encode(input);
+      }
+      decode(input) {
+        return this.decoder.decode(input);
+      }
+    };
+  }
+});
+
+// node_modules/multiformats/dist/src/bases/base10.js
+var base10_exports = {};
+__export(base10_exports, {
+  base10: () => base10
+});
+var base10;
+var init_base10 = __esm({
+  "node_modules/multiformats/dist/src/bases/base10.js"() {
+    "use strict";
+    init_base();
+    base10 = baseX({
+      prefix: "9",
+      name: "base10",
+      alphabet: "0123456789"
+    });
+  }
+});
+
+// node_modules/multiformats/dist/src/bases/base16.js
+var base16_exports = {};
+__export(base16_exports, {
+  base16: () => base16,
+  base16upper: () => base16upper
+});
+var base16, base16upper;
+var init_base16 = __esm({
+  "node_modules/multiformats/dist/src/bases/base16.js"() {
+    "use strict";
+    init_base();
+    base16 = rfc4648({
+      prefix: "f",
+      name: "base16",
+      alphabet: "0123456789abcdef",
+      bitsPerChar: 4
+    });
+    base16upper = rfc4648({
+      prefix: "F",
+      name: "base16upper",
+      alphabet: "0123456789ABCDEF",
+      bitsPerChar: 4
+    });
+  }
+});
+
+// node_modules/multiformats/dist/src/bases/base2.js
+var base2_exports = {};
+__export(base2_exports, {
+  base2: () => base2
+});
+var base2;
+var init_base2 = __esm({
+  "node_modules/multiformats/dist/src/bases/base2.js"() {
+    "use strict";
+    init_base();
+    base2 = rfc4648({
+      prefix: "0",
+      name: "base2",
+      alphabet: "01",
+      bitsPerChar: 1
+    });
+  }
+});
+
+// node_modules/multiformats/dist/src/bases/base256emoji.js
+var base256emoji_exports = {};
+__export(base256emoji_exports, {
+  base256emoji: () => base256emoji
+});
+function encode4(data) {
+  return data.reduce((p, c) => {
+    p += alphabetBytesToChars[c];
+    return p;
+  }, "");
+}
+function decode4(str) {
+  const byts = [];
+  for (const char of str) {
+    const codePoint = char.codePointAt(0);
+    if (codePoint == null) {
+      throw new Error(`Invalid character: ${char}`);
+    }
+    const byt = alphabetCharsToBytes[codePoint];
+    if (byt == null) {
+      throw new Error(`Non-base256emoji character: ${char}`);
+    }
+    byts.push(byt);
+  }
+  return new Uint8Array(byts);
+}
+var alphabet, alphabetBytesToChars, alphabetCharsToBytes, base256emoji;
+var init_base256emoji = __esm({
+  "node_modules/multiformats/dist/src/bases/base256emoji.js"() {
+    "use strict";
+    init_base();
+    alphabet = Array.from("\u{1F680}\u{1FA90}\u2604\u{1F6F0}\u{1F30C}\u{1F311}\u{1F312}\u{1F313}\u{1F314}\u{1F315}\u{1F316}\u{1F317}\u{1F318}\u{1F30D}\u{1F30F}\u{1F30E}\u{1F409}\u2600\u{1F4BB}\u{1F5A5}\u{1F4BE}\u{1F4BF}\u{1F602}\u2764\u{1F60D}\u{1F923}\u{1F60A}\u{1F64F}\u{1F495}\u{1F62D}\u{1F618}\u{1F44D}\u{1F605}\u{1F44F}\u{1F601}\u{1F525}\u{1F970}\u{1F494}\u{1F496}\u{1F499}\u{1F622}\u{1F914}\u{1F606}\u{1F644}\u{1F4AA}\u{1F609}\u263A\u{1F44C}\u{1F917}\u{1F49C}\u{1F614}\u{1F60E}\u{1F607}\u{1F339}\u{1F926}\u{1F389}\u{1F49E}\u270C\u2728\u{1F937}\u{1F631}\u{1F60C}\u{1F338}\u{1F64C}\u{1F60B}\u{1F497}\u{1F49A}\u{1F60F}\u{1F49B}\u{1F642}\u{1F493}\u{1F929}\u{1F604}\u{1F600}\u{1F5A4}\u{1F603}\u{1F4AF}\u{1F648}\u{1F447}\u{1F3B6}\u{1F612}\u{1F92D}\u2763\u{1F61C}\u{1F48B}\u{1F440}\u{1F62A}\u{1F611}\u{1F4A5}\u{1F64B}\u{1F61E}\u{1F629}\u{1F621}\u{1F92A}\u{1F44A}\u{1F973}\u{1F625}\u{1F924}\u{1F449}\u{1F483}\u{1F633}\u270B\u{1F61A}\u{1F61D}\u{1F634}\u{1F31F}\u{1F62C}\u{1F643}\u{1F340}\u{1F337}\u{1F63B}\u{1F613}\u2B50\u2705\u{1F97A}\u{1F308}\u{1F608}\u{1F918}\u{1F4A6}\u2714\u{1F623}\u{1F3C3}\u{1F490}\u2639\u{1F38A}\u{1F498}\u{1F620}\u261D\u{1F615}\u{1F33A}\u{1F382}\u{1F33B}\u{1F610}\u{1F595}\u{1F49D}\u{1F64A}\u{1F639}\u{1F5E3}\u{1F4AB}\u{1F480}\u{1F451}\u{1F3B5}\u{1F91E}\u{1F61B}\u{1F534}\u{1F624}\u{1F33C}\u{1F62B}\u26BD\u{1F919}\u2615\u{1F3C6}\u{1F92B}\u{1F448}\u{1F62E}\u{1F646}\u{1F37B}\u{1F343}\u{1F436}\u{1F481}\u{1F632}\u{1F33F}\u{1F9E1}\u{1F381}\u26A1\u{1F31E}\u{1F388}\u274C\u270A\u{1F44B}\u{1F630}\u{1F928}\u{1F636}\u{1F91D}\u{1F6B6}\u{1F4B0}\u{1F353}\u{1F4A2}\u{1F91F}\u{1F641}\u{1F6A8}\u{1F4A8}\u{1F92C}\u2708\u{1F380}\u{1F37A}\u{1F913}\u{1F619}\u{1F49F}\u{1F331}\u{1F616}\u{1F476}\u{1F974}\u25B6\u27A1\u2753\u{1F48E}\u{1F4B8}\u2B07\u{1F628}\u{1F31A}\u{1F98B}\u{1F637}\u{1F57A}\u26A0\u{1F645}\u{1F61F}\u{1F635}\u{1F44E}\u{1F932}\u{1F920}\u{1F927}\u{1F4CC}\u{1F535}\u{1F485}\u{1F9D0}\u{1F43E}\u{1F352}\u{1F617}\u{1F911}\u{1F30A}\u{1F92F}\u{1F437}\u260E\u{1F4A7}\u{1F62F}\u{1F486}\u{1F446}\u{1F3A4}\u{1F647}\u{1F351}\u2744\u{1F334}\u{1F4A3}\u{1F438}\u{1F48C}\u{1F4CD}\u{1F940}\u{1F922}\u{1F445}\u{1F4A1}\u{1F4A9}\u{1F450}\u{1F4F8}\u{1F47B}\u{1F910}\u{1F92E}\u{1F3BC}\u{1F975}\u{1F6A9}\u{1F34E}\u{1F34A}\u{1F47C}\u{1F48D}\u{1F4E3}\u{1F942}");
+    alphabetBytesToChars = alphabet.reduce((p, c, i) => {
+      p[i] = c;
+      return p;
+    }, []);
+    alphabetCharsToBytes = alphabet.reduce((p, c, i) => {
+      const codePoint = c.codePointAt(0);
+      if (codePoint == null) {
+        throw new Error(`Invalid character: ${c}`);
+      }
+      p[codePoint] = i;
+      return p;
+    }, []);
+    base256emoji = from({
+      prefix: "\u{1F680}",
+      name: "base256emoji",
+      encode: encode4,
+      decode: decode4
+    });
+  }
+});
+
+// node_modules/multiformats/dist/src/bases/base32.js
+var base32_exports = {};
+__export(base32_exports, {
+  base32: () => base32,
+  base32hex: () => base32hex,
+  base32hexpad: () => base32hexpad,
+  base32hexpadupper: () => base32hexpadupper,
+  base32hexupper: () => base32hexupper,
+  base32pad: () => base32pad,
+  base32padupper: () => base32padupper,
+  base32upper: () => base32upper,
+  base32z: () => base32z
+});
+var base32, base32upper, base32pad, base32padupper, base32hex, base32hexupper, base32hexpad, base32hexpadupper, base32z;
+var init_base32 = __esm({
+  "node_modules/multiformats/dist/src/bases/base32.js"() {
+    "use strict";
+    init_base();
+    base32 = rfc4648({
+      prefix: "b",
+      name: "base32",
+      alphabet: "abcdefghijklmnopqrstuvwxyz234567",
+      bitsPerChar: 5
+    });
+    base32upper = rfc4648({
+      prefix: "B",
+      name: "base32upper",
+      alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+      bitsPerChar: 5
+    });
+    base32pad = rfc4648({
+      prefix: "c",
+      name: "base32pad",
+      alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
+      bitsPerChar: 5
+    });
+    base32padupper = rfc4648({
+      prefix: "C",
+      name: "base32padupper",
+      alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
+      bitsPerChar: 5
+    });
+    base32hex = rfc4648({
+      prefix: "v",
+      name: "base32hex",
+      alphabet: "0123456789abcdefghijklmnopqrstuv",
+      bitsPerChar: 5
+    });
+    base32hexupper = rfc4648({
+      prefix: "V",
+      name: "base32hexupper",
+      alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
+      bitsPerChar: 5
+    });
+    base32hexpad = rfc4648({
+      prefix: "t",
+      name: "base32hexpad",
+      alphabet: "0123456789abcdefghijklmnopqrstuv=",
+      bitsPerChar: 5
+    });
+    base32hexpadupper = rfc4648({
+      prefix: "T",
+      name: "base32hexpadupper",
+      alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
+      bitsPerChar: 5
+    });
+    base32z = rfc4648({
+      prefix: "h",
+      name: "base32z",
+      alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
+      bitsPerChar: 5
+    });
+  }
+});
+
+// node_modules/multiformats/dist/src/bases/base36.js
+var base36_exports = {};
+__export(base36_exports, {
+  base36: () => base36,
+  base36upper: () => base36upper
+});
+var base36, base36upper;
+var init_base36 = __esm({
+  "node_modules/multiformats/dist/src/bases/base36.js"() {
+    "use strict";
+    init_base();
+    base36 = baseX({
+      prefix: "k",
+      name: "base36",
+      alphabet: "0123456789abcdefghijklmnopqrstuvwxyz"
+    });
+    base36upper = baseX({
+      prefix: "K",
+      name: "base36upper",
+      alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    });
+  }
+});
+
+// node_modules/multiformats/dist/src/bases/base58.js
+var base58_exports = {};
+__export(base58_exports, {
+  base58btc: () => base58btc,
+  base58flickr: () => base58flickr
+});
+var base58btc, base58flickr;
+var init_base58 = __esm({
+  "node_modules/multiformats/dist/src/bases/base58.js"() {
+    "use strict";
+    init_base();
+    base58btc = baseX({
+      name: "base58btc",
+      prefix: "z",
+      alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+    });
+    base58flickr = baseX({
+      name: "base58flickr",
+      prefix: "Z",
+      alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+    });
+  }
+});
+
+// node_modules/multiformats/dist/src/bases/base64.js
+var base64_exports = {};
+__export(base64_exports, {
+  base64: () => base64,
+  base64pad: () => base64pad,
+  base64url: () => base64url,
+  base64urlpad: () => base64urlpad
+});
+var base64, base64pad, base64url, base64urlpad;
+var init_base64 = __esm({
+  "node_modules/multiformats/dist/src/bases/base64.js"() {
+    "use strict";
+    init_base();
+    base64 = rfc4648({
+      prefix: "m",
+      name: "base64",
+      alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+      bitsPerChar: 6
+    });
+    base64pad = rfc4648({
+      prefix: "M",
+      name: "base64pad",
+      alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+      bitsPerChar: 6
+    });
+    base64url = rfc4648({
+      prefix: "u",
+      name: "base64url",
+      alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
+      bitsPerChar: 6
+    });
+    base64urlpad = rfc4648({
+      prefix: "U",
+      name: "base64urlpad",
+      alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=",
+      bitsPerChar: 6
+    });
+  }
+});
+
+// node_modules/multiformats/dist/src/bases/base8.js
+var base8_exports = {};
+__export(base8_exports, {
+  base8: () => base8
+});
+var base8;
+var init_base8 = __esm({
+  "node_modules/multiformats/dist/src/bases/base8.js"() {
+    "use strict";
+    init_base();
+    base8 = rfc4648({
+      prefix: "7",
+      name: "base8",
+      alphabet: "01234567",
+      bitsPerChar: 3
+    });
+  }
+});
+
+// node_modules/multiformats/dist/src/bases/identity.js
+var identity_exports = {};
+__export(identity_exports, {
+  identity: () => identity
+});
+var identity;
+var init_identity = __esm({
+  "node_modules/multiformats/dist/src/bases/identity.js"() {
+    "use strict";
+    init_bytes();
+    init_base();
+    identity = from({
+      prefix: "\0",
+      name: "identity",
+      encode: (buf) => toString(buf),
+      decode: (str) => fromString(str)
+    });
+  }
+});
+
+// node_modules/multiformats/dist/src/codecs/json.js
+var textEncoder, textDecoder;
+var init_json = __esm({
+  "node_modules/multiformats/dist/src/codecs/json.js"() {
+    "use strict";
+    textEncoder = new TextEncoder();
+    textDecoder = new TextDecoder();
+  }
+});
+
+// node_modules/multiformats/dist/src/codecs/raw.js
+var init_raw = __esm({
+  "node_modules/multiformats/dist/src/codecs/raw.js"() {
+    "use strict";
+    init_bytes();
+  }
+});
+
+// node_modules/multiformats/dist/src/vendor/varint.js
+function encode5(num, out, offset) {
+  out = out || [];
+  offset = offset || 0;
+  var oldOffset = offset;
+  while (num >= INT) {
+    out[offset++] = num & 255 | MSB;
+    num /= 128;
+  }
+  while (num & MSBALL) {
+    out[offset++] = num & 255 | MSB;
+    num >>>= 7;
+  }
+  out[offset] = num | 0;
+  encode5.bytes = offset - oldOffset + 1;
+  return out;
+}
+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 encode_1, MSB, REST, MSBALL, INT, decode5, MSB$1, REST$1, N1, N2, N3, N4, N5, N6, N7, N8, N9, length, varint, _brrp_varint, varint_default;
+var init_varint = __esm({
+  "node_modules/multiformats/dist/src/vendor/varint.js"() {
+    "use strict";
+    encode_1 = encode5;
+    MSB = 128;
+    REST = 127;
+    MSBALL = ~REST;
+    INT = Math.pow(2, 31);
+    decode5 = read;
+    MSB$1 = 128;
+    REST$1 = 127;
+    N1 = Math.pow(2, 7);
+    N2 = Math.pow(2, 14);
+    N3 = Math.pow(2, 21);
+    N4 = Math.pow(2, 28);
+    N5 = Math.pow(2, 35);
+    N6 = Math.pow(2, 42);
+    N7 = Math.pow(2, 49);
+    N8 = Math.pow(2, 56);
+    N9 = Math.pow(2, 63);
+    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;
+    };
+    varint = {
+      encode: encode_1,
+      decode: decode5,
+      encodingLength: length
+    };
+    _brrp_varint = varint;
+    varint_default = _brrp_varint;
+  }
+});
+
+// node_modules/multiformats/dist/src/varint.js
+function decode6(data, offset = 0) {
+  const code2 = varint_default.decode(data, offset);
+  return [code2, varint_default.decode.bytes];
+}
+function encodeTo(int, target, offset = 0) {
+  varint_default.encode(int, target, offset);
+  return target;
+}
+function encodingLength(int) {
+  return varint_default.encodingLength(int);
+}
+var init_varint2 = __esm({
+  "node_modules/multiformats/dist/src/varint.js"() {
+    "use strict";
+    init_varint();
+  }
+});
+
+// node_modules/multiformats/dist/src/hashes/digest.js
+function create(code2, digest2) {
+  const size = digest2.byteLength;
+  const sizeOffset = encodingLength(code2);
+  const digestOffset = sizeOffset + encodingLength(size);
+  const bytes = new Uint8Array(digestOffset + size);
+  encodeTo(code2, bytes, 0);
+  encodeTo(size, bytes, sizeOffset);
+  bytes.set(digest2, digestOffset);
+  return new Digest(code2, size, digest2, bytes);
+}
+function decode7(multihash) {
+  const bytes = coerce(multihash);
+  const [code2, sizeOffset] = decode6(bytes);
+  const [size, digestOffset] = decode6(bytes.subarray(sizeOffset));
+  const digest2 = bytes.subarray(sizeOffset + digestOffset);
+  if (digest2.byteLength !== size) {
+    throw new Error("Incorrect length");
+  }
+  return new Digest(code2, size, digest2, bytes);
+}
+function equals2(a, b) {
+  if (a === b) {
+    return true;
+  } else {
+    const data = b;
+    return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals(a.bytes, data.bytes);
+  }
+}
+var Digest;
+var init_digest = __esm({
+  "node_modules/multiformats/dist/src/hashes/digest.js"() {
+    "use strict";
+    init_bytes();
+    init_varint2();
+    Digest = class {
+      code;
+      size;
+      digest;
+      bytes;
+      /**
+       * Creates a multihash digest.
+       */
+      constructor(code2, size, digest2, bytes) {
+        this.code = code2;
+        this.size = size;
+        this.digest = digest2;
+        this.bytes = bytes;
+      }
+    };
+  }
+});
+
+// node_modules/multiformats/dist/src/hashes/identity.js
+var identity_exports2 = {};
+__export(identity_exports2, {
+  identity: () => identity2
+});
+function digest(input, options) {
+  if (options?.truncate != null && options.truncate !== input.byteLength) {
+    if (options.truncate < 0 || options.truncate > input.byteLength) {
+      throw new Error(`Invalid truncate option, must be less than or equal to ${input.byteLength}`);
+    }
+    input = input.subarray(0, options.truncate);
+  }
+  return create(code, encode6(input));
+}
+var code, name, encode6, identity2;
+var init_identity2 = __esm({
+  "node_modules/multiformats/dist/src/hashes/identity.js"() {
+    "use strict";
+    init_bytes();
+    init_digest();
+    code = 0;
+    name = "identity";
+    encode6 = coerce;
+    identity2 = { code, name, encode: encode6, digest };
+  }
+});
+
+// node_modules/multiformats/dist/src/hashes/hasher.js
+function from2({ name: name2, code: code2, encode: encode7, minDigestLength, maxDigestLength }) {
+  return new Hasher(name2, code2, encode7, minDigestLength, maxDigestLength);
+}
+function createDigest(digest2, code2, truncate) {
+  if (truncate != null && truncate !== digest2.byteLength) {
+    if (truncate > digest2.byteLength) {
+      throw new Error(`Invalid truncate option, must be less than or equal to ${digest2.byteLength}`);
+    }
+    digest2 = digest2.subarray(0, truncate);
+  }
+  return create(code2, digest2);
+}
+var DEFAULT_MIN_DIGEST_LENGTH, Hasher;
+var init_hasher = __esm({
+  "node_modules/multiformats/dist/src/hashes/hasher.js"() {
+    "use strict";
+    init_digest();
+    DEFAULT_MIN_DIGEST_LENGTH = 20;
+    Hasher = class {
+      name;
+      code;
+      encode;
+      minDigestLength;
+      maxDigestLength;
+      constructor(name2, code2, encode7, minDigestLength, maxDigestLength) {
+        this.name = name2;
+        this.code = code2;
+        this.encode = encode7;
+        this.minDigestLength = minDigestLength ?? DEFAULT_MIN_DIGEST_LENGTH;
+        this.maxDigestLength = maxDigestLength;
+      }
+      digest(input, options) {
+        if (options?.truncate != null) {
+          if (options.truncate < this.minDigestLength) {
+            throw new Error(`Invalid truncate option, must be greater than or equal to ${this.minDigestLength}`);
+          }
+          if (this.maxDigestLength != null && options.truncate > this.maxDigestLength) {
+            throw new Error(`Invalid truncate option, must be less than or equal to ${this.maxDigestLength}`);
+          }
+        }
+        if (input instanceof Uint8Array) {
+          const result = this.encode(input);
+          if (result instanceof Uint8Array) {
+            return createDigest(result, this.code, options?.truncate);
+          }
+          return result.then((digest2) => createDigest(digest2, this.code, options?.truncate));
+        } else {
+          throw Error("Unknown type, must be binary type");
+        }
+      }
+    };
+  }
+});
+
+// node_modules/multiformats/dist/src/hashes/sha2.js
+var sha2_exports = {};
+__export(sha2_exports, {
+  sha256: () => sha2565,
+  sha512: () => sha512
+});
+var import_crypto, sha2565, sha512;
+var init_sha2 = __esm({
+  "node_modules/multiformats/dist/src/hashes/sha2.js"() {
+    "use strict";
+    import_crypto = __toESM(require("crypto"), 1);
+    init_bytes();
+    init_hasher();
+    sha2565 = from2({
+      name: "sha2-256",
+      code: 18,
+      encode: (input) => coerce(import_crypto.default.createHash("sha256").update(input).digest())
+    });
+    sha512 = from2({
+      name: "sha2-512",
+      code: 19,
+      encode: (input) => coerce(import_crypto.default.createHash("sha512").update(input).digest())
+    });
+  }
+});
+
+// node_modules/multiformats/dist/src/link/interface.js
+var init_interface = __esm({
+  "node_modules/multiformats/dist/src/link/interface.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/multiformats/dist/src/cid.js
+function format(link, base3) {
+  const { bytes, version } = link;
+  switch (version) {
+    case 0:
+      return toStringV0(bytes, baseCache(link), base3 ?? base58btc.encoder);
+    default:
+      return toStringV1(bytes, baseCache(link), base3 ?? base32.encoder);
+  }
+}
+function baseCache(cid) {
+  const baseCache2 = cache.get(cid);
+  if (baseCache2 == null) {
+    const baseCache3 = /* @__PURE__ */ new Map();
+    cache.set(cid, baseCache3);
+    return baseCache3;
+  }
+  return baseCache2;
+}
+function parseCIDtoBytes(source, base3) {
+  switch (source[0]) {
+    // CIDv0 is parsed differently
+    case "Q": {
+      const decoder = base3 ?? base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(`${base58btc.prefix}${source}`)
+      ];
+    }
+    case base58btc.prefix: {
+      const decoder = base3 ?? base58btc;
+      return [base58btc.prefix, decoder.decode(source)];
+    }
+    case base32.prefix: {
+      const decoder = base3 ?? base32;
+      return [base32.prefix, decoder.decode(source)];
+    }
+    case base36.prefix: {
+      const decoder = base3 ?? base36;
+      return [base36.prefix, decoder.decode(source)];
+    }
+    default: {
+      if (base3 == null) {
+        throw Error("To parse non base32, base36 or base58btc encoded CID multibase decoder must be provided");
+      }
+      return [source[0], base3.decode(source)];
+    }
+  }
+}
+function toStringV0(bytes, cache2, base3) {
+  const { prefix } = base3;
+  if (prefix !== base58btc.prefix) {
+    throw Error(`Cannot string encode V0 in ${base3.name} encoding`);
+  }
+  const cid = cache2.get(prefix);
+  if (cid == null) {
+    const cid2 = base3.encode(bytes).slice(1);
+    cache2.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+}
+function toStringV1(bytes, cache2, base3) {
+  const { prefix } = base3;
+  const cid = cache2.get(prefix);
+  if (cid == null) {
+    const cid2 = base3.encode(bytes);
+    cache2.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+}
+function encodeCID(version, code2, multihash) {
+  const codeOffset = encodingLength(version);
+  const hashOffset = codeOffset + encodingLength(code2);
+  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+  encodeTo(version, bytes, 0);
+  encodeTo(code2, bytes, codeOffset);
+  bytes.set(multihash, hashOffset);
+  return bytes;
+}
+var cache, CID, DAG_PB_CODE, SHA_256_CODE, cidSymbol;
+var init_cid = __esm({
+  "node_modules/multiformats/dist/src/cid.js"() {
+    "use strict";
+    init_base32();
+    init_base36();
+    init_base58();
+    init_bytes();
+    init_digest();
+    init_varint2();
+    init_interface();
+    cache = /* @__PURE__ */ new WeakMap();
+    CID = class _CID {
+      code;
+      version;
+      multihash;
+      bytes;
+      "/";
+      /**
+       * @param version - Version of the CID
+       * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+       * @param multihash - (Multi)hash of the of the content.
+       */
+      constructor(version, code2, multihash, bytes) {
+        this.code = code2;
+        this.version = version;
+        this.multihash = multihash;
+        this.bytes = bytes;
+        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;
+      }
+      toV0() {
+        switch (this.version) {
+          case 0: {
+            return this;
+          }
+          case 1: {
+            const { code: code2, multihash } = this;
+            if (code2 !== DAG_PB_CODE) {
+              throw new Error("Cannot convert a non dag-pb CID to CIDv0");
+            }
+            if (multihash.code !== SHA_256_CODE) {
+              throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
+            }
+            return _CID.createV0(multihash);
+          }
+          default: {
+            throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
+          }
+        }
+      }
+      toV1() {
+        switch (this.version) {
+          case 0: {
+            const { code: code2, digest: digest2 } = this.multihash;
+            const multihash = create(code2, digest2);
+            return _CID.createV1(this.code, multihash);
+          }
+          case 1: {
+            return this;
+          }
+          default: {
+            throw Error(`Can not convert CID version ${this.version} to version 1. This is a bug please report`);
+          }
+        }
+      }
+      equals(other) {
+        return _CID.equals(this, other);
+      }
+      static equals(self, other) {
+        const unknown = other;
+        return unknown != null && self.code === unknown.code && self.version === unknown.version && equals2(self.multihash, unknown.multihash);
+      }
+      toString(base3) {
+        return format(this, base3);
+      }
+      toJSON() {
+        return { "/": format(this) };
+      }
+      link() {
+        return this;
+      }
+      [Symbol.toStringTag] = "CID";
+      // Legacy
+      [/* @__PURE__ */ 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 returns null.
+       *
+       * This allows two different incompatible versions of CID library to
+       * co-exist and interop as long as binary interface is compatible.
+       */
+      static asCID(input) {
+        if (input == null) {
+          return null;
+        }
+        const value = input;
+        if (value instanceof _CID) {
+          return value;
+        } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
+          const { version, code: code2, multihash, bytes } = value;
+          return new _CID(version, code2, multihash, bytes ?? encodeCID(version, code2, multihash.bytes));
+        } else if (value[cidSymbol] === true) {
+          const { version, multihash, code: code2 } = value;
+          const digest2 = decode7(multihash);
+          return _CID.create(version, code2, digest2);
+        } else {
+          return null;
+        }
+      }
+      /**
+       * @param version - Version of the CID
+       * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+       * @param digest - (Multi)hash of the of the content.
+       */
+      static create(version, code2, digest2) {
+        if (typeof code2 !== "number") {
+          throw new Error("String codecs are no longer supported");
+        }
+        if (!(digest2.bytes instanceof Uint8Array)) {
+          throw new Error("Invalid digest");
+        }
+        switch (version) {
+          case 0: {
+            if (code2 !== DAG_PB_CODE) {
+              throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`);
+            } else {
+              return new _CID(version, code2, digest2, digest2.bytes);
+            }
+          }
+          case 1: {
+            const bytes = encodeCID(version, code2, digest2.bytes);
+            return new _CID(version, code2, digest2, bytes);
+          }
+          default: {
+            throw new Error("Invalid version");
+          }
+        }
+      }
+      /**
+       * Simplified version of `create` for CIDv0.
+       */
+      static createV0(digest2) {
+        return _CID.create(0, DAG_PB_CODE, digest2);
+      }
+      /**
+       * Simplified version of `create` for CIDv1.
+       *
+       * @param code - Content encoding format code.
+       * @param digest - Multihash of the content.
+       */
+      static createV1(code2, digest2) {
+        return _CID.create(1, code2, digest2);
+      }
+      /**
+       * 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.
+       */
+      static decode(bytes) {
+        const [cid, remainder] = _CID.decodeFirst(bytes);
+        if (remainder.length !== 0) {
+          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.
+       */
+      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 digest2 = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
+        const cid = specs.version === 0 ? _CID.createV0(digest2) : _CID.createV1(specs.codec, digest2);
+        return [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.
+       */
+      static inspectBytes(initialBytes) {
+        let offset = 0;
+        const next = () => {
+          const [i, length2] = decode6(initialBytes.subarray(offset));
+          offset += length2;
+          return i;
+        };
+        let version = next();
+        let codec = DAG_PB_CODE;
+        if (version === 18) {
+          version = 0;
+          offset = 0;
+        } else {
+          codec = next();
+        }
+        if (version !== 0 && version !== 1) {
+          throw new RangeError(`Invalid CID version ${version}`);
+        }
+        const prefixSize = offset;
+        const multihashCode = next();
+        const digestSize = next();
+        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).
+       */
+      static parse(source, base3) {
+        const [prefix, bytes] = parseCIDtoBytes(source, base3);
+        const cid = _CID.decode(bytes);
+        if (cid.version === 0 && source[0] !== "Q") {
+          throw Error("Version 0 CID string must not include multibase prefix");
+        }
+        baseCache(cid).set(prefix, source);
+        return cid;
+      }
+    };
+    DAG_PB_CODE = 112;
+    SHA_256_CODE = 18;
+    cidSymbol = /* @__PURE__ */ Symbol.for("@ipld/js-cid/CID");
+  }
+});
+
+// node_modules/multiformats/dist/src/bases/interface.js
+var init_interface2 = __esm({
+  "node_modules/multiformats/dist/src/bases/interface.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/multiformats/dist/src/hashes/interface.js
+var init_interface3 = __esm({
+  "node_modules/multiformats/dist/src/hashes/interface.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/multiformats/dist/src/codecs/interface.js
+var init_interface4 = __esm({
+  "node_modules/multiformats/dist/src/codecs/interface.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/multiformats/dist/src/block/interface.js
+var init_interface5 = __esm({
+  "node_modules/multiformats/dist/src/block/interface.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/multiformats/dist/src/interface.js
+var init_interface6 = __esm({
+  "node_modules/multiformats/dist/src/interface.js"() {
+    "use strict";
+    init_interface2();
+    init_interface3();
+    init_interface4();
+    init_interface();
+    init_interface5();
+  }
+});
+
+// node_modules/multiformats/dist/src/index.js
+var init_src = __esm({
+  "node_modules/multiformats/dist/src/index.js"() {
+    "use strict";
+    init_bytes();
+    init_cid();
+    init_digest();
+    init_hasher();
+    init_varint2();
+    init_interface6();
+  }
+});
+
+// node_modules/multiformats/dist/src/basics.js
+var bases, hashes;
+var init_basics = __esm({
+  "node_modules/multiformats/dist/src/basics.js"() {
+    "use strict";
+    init_base10();
+    init_base16();
+    init_base2();
+    init_base256emoji();
+    init_base32();
+    init_base36();
+    init_base58();
+    init_base64();
+    init_base8();
+    init_identity();
+    init_json();
+    init_raw();
+    init_identity2();
+    init_sha2();
+    init_src();
+    bases = { ...identity_exports, ...base2_exports, ...base8_exports, ...base10_exports, ...base16_exports, ...base32_exports, ...base36_exports, ...base58_exports, ...base64_exports, ...base256emoji_exports };
+    hashes = { ...sha2_exports, ...identity_exports2 };
+  }
+});
+
+// node_modules/uint8arrays/dist/src/util/as-uint8array.node.js
+function asUint8Array(buf) {
+  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+var init_as_uint8array_node = __esm({
+  "node_modules/uint8arrays/dist/src/util/as-uint8array.node.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/uint8arrays/dist/src/alloc.node.js
+function allocUnsafe(size = 0) {
+  return asUint8Array(import_node_buffer.Buffer.allocUnsafe(size));
+}
+var import_node_buffer;
+var init_alloc_node = __esm({
+  "node_modules/uint8arrays/dist/src/alloc.node.js"() {
+    "use strict";
+    import_node_buffer = require("buffer");
+    init_as_uint8array_node();
+  }
+});
+
+// node_modules/uint8arrays/dist/src/util/bases.js
+function createCodec(name2, prefix, encode7, decode9) {
+  return {
+    name: name2,
+    prefix,
+    encoder: {
+      name: name2,
+      prefix,
+      encode: encode7
+    },
+    decoder: {
+      decode: decode9
+    }
+  };
+}
+var string, ascii, BASES, bases_default;
+var init_bases = __esm({
+  "node_modules/uint8arrays/dist/src/util/bases.js"() {
+    "use strict";
+    init_basics();
+    init_alloc_node();
+    string = createCodec("utf8", "u", (buf) => {
+      const decoder = new TextDecoder("utf8");
+      return "u" + decoder.decode(buf);
+    }, (str) => {
+      const encoder2 = new TextEncoder();
+      return encoder2.encode(str.substring(1));
+    });
+    ascii = createCodec("ascii", "a", (buf) => {
+      let string2 = "a";
+      for (let i = 0; i < buf.length; i++) {
+        string2 += String.fromCharCode(buf[i]);
+      }
+      return string2;
+    }, (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;
+    });
+    BASES = {
+      utf8: string,
+      "utf-8": string,
+      hex: bases.base16,
+      latin1: ascii,
+      ascii,
+      binary: ascii,
+      ...bases
+    };
+    bases_default = BASES;
+  }
+});
+
+// node_modules/uint8arrays/dist/src/to-string.node.js
+function toString2(array, encoding = "utf8") {
+  const base3 = bases_default[encoding];
+  if (base3 == null) {
+    throw new Error(`Unsupported encoding "${encoding}"`);
+  }
+  if (encoding === "utf8" || encoding === "utf-8") {
+    return import_node_buffer2.Buffer.from(array.buffer, array.byteOffset, array.byteLength).toString("utf8");
+  }
+  return base3.encoder.encode(array).substring(1);
+}
+var import_node_buffer2;
+var init_to_string_node = __esm({
+  "node_modules/uint8arrays/dist/src/to-string.node.js"() {
+    "use strict";
+    import_node_buffer2 = require("buffer");
+    init_bases();
+  }
+});
+
+// node_modules/@multiformats/multiaddr/dist/src/errors.js
+var InvalidMultiaddrError, ValidationError, InvalidParametersError, UnknownProtocolError;
+var init_errors = __esm({
+  "node_modules/@multiformats/multiaddr/dist/src/errors.js"() {
+    "use strict";
+    InvalidMultiaddrError = class extends Error {
+      static name = "InvalidMultiaddrError";
+      name = "InvalidMultiaddrError";
+    };
+    ValidationError = class extends Error {
+      static name = "ValidationError";
+      name = "ValidationError";
+    };
+    InvalidParametersError = class extends Error {
+      static name = "InvalidParametersError";
+      name = "InvalidParametersError";
+    };
+    UnknownProtocolError = class extends Error {
+      static name = "UnknownProtocolError";
+      name = "UnknownProtocolError";
+    };
+  }
+});
+
+// node_modules/uint8arrays/dist/src/equals.js
+function equals3(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 init_equals = __esm({
+  "node_modules/uint8arrays/dist/src/equals.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/uint8arrays/dist/src/from-string.node.js
+function fromString2(string2, encoding = "utf8") {
+  const base3 = bases_default[encoding];
+  if (base3 == null) {
+    throw new Error(`Unsupported encoding "${encoding}"`);
+  }
+  if (encoding === "utf8" || encoding === "utf-8") {
+    return asUint8Array(import_node_buffer3.Buffer.from(string2, "utf-8"));
+  }
+  return base3.decoder.decode(`${base3.prefix}${string2}`);
+}
+var import_node_buffer3;
+var init_from_string_node = __esm({
+  "node_modules/uint8arrays/dist/src/from-string.node.js"() {
+    "use strict";
+    import_node_buffer3 = require("buffer");
+    init_bases();
+    init_as_uint8array_node();
+  }
+});
+
+// node_modules/uint8-varint/dist/src/index.js
+function encodingLength2(value) {
+  if (value < N12) {
+    return 1;
+  }
+  if (value < N22) {
+    return 2;
+  }
+  if (value < N32) {
+    return 3;
+  }
+  if (value < N42) {
+    return 4;
+  }
+  if (value < N52) {
+    return 5;
+  }
+  if (value < N62) {
+    return 6;
+  }
+  if (value < N72) {
+    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 (encodingLength2(value)) {
+    case 8: {
+      buf[offset++] = value & 255 | MSB2;
+      value /= 128;
+    }
+    case 7: {
+      buf[offset++] = value & 255 | MSB2;
+      value /= 128;
+    }
+    case 6: {
+      buf[offset++] = value & 255 | MSB2;
+      value /= 128;
+    }
+    case 5: {
+      buf[offset++] = value & 255 | MSB2;
+      value /= 128;
+    }
+    case 4: {
+      buf[offset++] = value & 255 | MSB2;
+      value >>>= 7;
+    }
+    case 3: {
+      buf[offset++] = value & 255 | MSB2;
+      value >>>= 7;
+    }
+    case 2: {
+      buf[offset++] = value & 255 | MSB2;
+      value >>>= 7;
+    }
+    case 1: {
+      buf[offset++] = value & 255;
+      value >>>= 7;
+      break;
+    }
+    default:
+      throw new Error("unreachable");
+  }
+  return buf;
+}
+function decodeUint8Array(buf, offset) {
+  let b = buf[offset];
+  let res = 0;
+  res += b & REST2;
+  if (b < MSB2) {
+    return res;
+  }
+  b = buf[offset + 1];
+  res += (b & REST2) << 7;
+  if (b < MSB2) {
+    return res;
+  }
+  b = buf[offset + 2];
+  res += (b & REST2) << 14;
+  if (b < MSB2) {
+    return res;
+  }
+  b = buf[offset + 3];
+  res += (b & REST2) << 21;
+  if (b < MSB2) {
+    return res;
+  }
+  b = buf[offset + 4];
+  res += (b & REST2) * N42;
+  if (b < MSB2) {
+    return res;
+  }
+  b = buf[offset + 5];
+  res += (b & REST2) * N52;
+  if (b < MSB2) {
+    return res;
+  }
+  b = buf[offset + 6];
+  res += (b & REST2) * N62;
+  if (b < MSB2) {
+    return res;
+  }
+  b = buf[offset + 7];
+  res += (b & REST2) * N72;
+  if (b < MSB2) {
+    return res;
+  }
+  throw new RangeError("Could not decode varint");
+}
+function decodeUint8ArrayList(buf, offset) {
+  let b = buf.get(offset);
+  let res = 0;
+  res += b & REST2;
+  if (b < MSB2) {
+    return res;
+  }
+  b = buf.get(offset + 1);
+  res += (b & REST2) << 7;
+  if (b < MSB2) {
+    return res;
+  }
+  b = buf.get(offset + 2);
+  res += (b & REST2) << 14;
+  if (b < MSB2) {
+    return res;
+  }
+  b = buf.get(offset + 3);
+  res += (b & REST2) << 21;
+  if (b < MSB2) {
+    return res;
+  }
+  b = buf.get(offset + 4);
+  res += (b & REST2) * N42;
+  if (b < MSB2) {
+    return res;
+  }
+  b = buf.get(offset + 5);
+  res += (b & REST2) * N52;
+  if (b < MSB2) {
+    return res;
+  }
+  b = buf.get(offset + 6);
+  res += (b & REST2) * N62;
+  if (b < MSB2) {
+    return res;
+  }
+  b = buf.get(offset + 7);
+  res += (b & REST2) * N72;
+  if (b < MSB2) {
+    return res;
+  }
+  throw new RangeError("Could not decode varint");
+}
+function decode8(buf, offset = 0) {
+  if (buf instanceof Uint8Array) {
+    return decodeUint8Array(buf, offset);
+  } else {
+    return decodeUint8ArrayList(buf, offset);
+  }
+}
+var N12, N22, N32, N42, N52, N62, N72, MSB2, REST2;
+var init_src2 = __esm({
+  "node_modules/uint8-varint/dist/src/index.js"() {
+    "use strict";
+    init_alloc_node();
+    N12 = Math.pow(2, 7);
+    N22 = Math.pow(2, 14);
+    N32 = Math.pow(2, 21);
+    N42 = Math.pow(2, 28);
+    N52 = Math.pow(2, 35);
+    N62 = Math.pow(2, 42);
+    N72 = Math.pow(2, 49);
+    MSB2 = 128;
+    REST2 = 127;
+  }
+});
+
+// node_modules/uint8arrays/dist/src/concat.node.js
+function concat(arrays, length2) {
+  return asUint8Array(import_node_buffer4.Buffer.concat(arrays, length2));
+}
+var import_node_buffer4;
+var init_concat_node = __esm({
+  "node_modules/uint8arrays/dist/src/concat.node.js"() {
+    "use strict";
+    import_node_buffer4 = require("buffer");
+    init_as_uint8array_node();
+  }
+});
+
+// node_modules/@chainsafe/is-ip/lib/is-ip.node.js
+var import_node_net;
+var init_is_ip_node = __esm({
+  "node_modules/@chainsafe/is-ip/lib/is-ip.node.js"() {
+    "use strict";
+    import_node_net = require("net");
+  }
+});
+
+// node_modules/@multiformats/multiaddr/dist/src/constants.js
+var CODE_IP4, CODE_TCP, CODE_UDP, CODE_DCCP, CODE_IP6, CODE_IP6ZONE, CODE_IPCIDR, CODE_DNS, CODE_DNS4, CODE_DNS6, CODE_DNSADDR, CODE_SCTP, CODE_UDT, CODE_UTP, CODE_UNIX, CODE_P2P, CODE_ONION, CODE_ONION3, CODE_GARLIC64, CODE_GARLIC32, CODE_TLS, CODE_SNI, CODE_NOISE, CODE_QUIC, CODE_QUIC_V1, CODE_WEBTRANSPORT, CODE_CERTHASH, CODE_HTTP, CODE_HTTP_PATH, CODE_HTTPS, CODE_WS, CODE_WSS, CODE_P2P_WEBSOCKET_STAR, CODE_P2P_STARDUST, CODE_P2P_WEBRTC_STAR, CODE_P2P_WEBRTC_DIRECT, CODE_WEBRTC_DIRECT, CODE_WEBRTC, CODE_P2P_CIRCUIT, CODE_MEMORY;
+var init_constants = __esm({
+  "node_modules/@multiformats/multiaddr/dist/src/constants.js"() {
+    "use strict";
+    CODE_IP4 = 4;
+    CODE_TCP = 6;
+    CODE_UDP = 273;
+    CODE_DCCP = 33;
+    CODE_IP6 = 41;
+    CODE_IP6ZONE = 42;
+    CODE_IPCIDR = 43;
+    CODE_DNS = 53;
+    CODE_DNS4 = 54;
+    CODE_DNS6 = 55;
+    CODE_DNSADDR = 56;
+    CODE_SCTP = 132;
+    CODE_UDT = 301;
+    CODE_UTP = 302;
+    CODE_UNIX = 400;
+    CODE_P2P = 421;
+    CODE_ONION = 444;
+    CODE_ONION3 = 445;
+    CODE_GARLIC64 = 446;
+    CODE_GARLIC32 = 447;
+    CODE_TLS = 448;
+    CODE_SNI = 449;
+    CODE_NOISE = 454;
+    CODE_QUIC = 460;
+    CODE_QUIC_V1 = 461;
+    CODE_WEBTRANSPORT = 465;
+    CODE_CERTHASH = 466;
+    CODE_HTTP = 480;
+    CODE_HTTP_PATH = 481;
+    CODE_HTTPS = 443;
+    CODE_WS = 477;
+    CODE_WSS = 478;
+    CODE_P2P_WEBSOCKET_STAR = 479;
+    CODE_P2P_STARDUST = 277;
+    CODE_P2P_WEBRTC_STAR = 275;
+    CODE_P2P_WEBRTC_DIRECT = 276;
+    CODE_WEBRTC_DIRECT = 280;
+    CODE_WEBRTC = 281;
+    CODE_P2P_CIRCUIT = 290;
+    CODE_MEMORY = 777;
+  }
+});
+
+// node_modules/@multiformats/multiaddr/dist/src/utils.js
+function bytesToString(base3) {
+  return (buf) => {
+    return toString2(buf, base3);
+  };
+}
+function stringToBytes(base3) {
+  return (buf) => {
+    return fromString2(buf, base3);
+  };
+}
+function bytes2port(buf) {
+  const view = new DataView(buf.buffer);
+  return view.getUint16(buf.byteOffset).toString();
+}
+function port2bytes(port) {
+  const buf = new ArrayBuffer(2);
+  const view = new DataView(buf);
+  view.setUint16(0, typeof port === "string" ? parseInt(port) : port);
+  return new Uint8Array(buf);
+}
+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.`);
+  }
+  const buf = fromString2(addr[0], "base32");
+  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.`);
+  }
+  const buf = base32.decode(`b${addr[0]}`);
+  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.subarray(0, buf.length - 2);
+  const portBytes = buf.subarray(buf.length - 2);
+  const addr = toString2(addrBytes, "base32");
+  const port = bytes2port(portBytes);
+  return `${addr}:${port}`;
+}
+function ip6StringToValue(str) {
+  try {
+    const url = new URL(`http://[${str}]`);
+    return url.hostname.substring(1, url.hostname.length - 1);
+  } catch {
+    throw new InvalidMultiaddrError(`Invalid IPv6 address "${str}"`);
+  }
+}
+function mb2bytes(mbstr) {
+  return anybaseDecoder.decode(mbstr);
+}
+function bytes2mb(base3) {
+  return (buf) => {
+    return base3.encoder.encode(buf);
+  };
+}
+var ip4ToBytes, ip6ToBytes, ip4ToString, ip6ToString, decoders, anybaseDecoder;
+var init_utils = __esm({
+  "node_modules/@multiformats/multiaddr/dist/src/utils.js"() {
+    "use strict";
+    init_is_ip_node();
+    init_base32();
+    init_basics();
+    init_concat_node();
+    init_from_string_node();
+    init_to_string_node();
+    init_errors();
+    ip4ToBytes = function(ip) {
+      ip = ip.toString().trim();
+      const bytes = new Uint8Array(4);
+      ip.split(/\./g).forEach((byte, index) => {
+        const value = parseInt(byte, 10);
+        if (isNaN(value) || value < 0 || value > 255) {
+          throw new InvalidMultiaddrError("Invalid byte value in IP address");
+        }
+        bytes[index] = value;
+      });
+      return bytes;
+    };
+    ip6ToBytes = function(ip) {
+      let offset = 0;
+      ip = ip.toString().trim();
+      const sections = ip.split(":", 8);
+      let i;
+      for (i = 0; i < sections.length; i++) {
+        const isv4 = (0, import_node_net.isIPv4)(sections[i]);
+        let v4Buffer;
+        if (isv4) {
+          v4Buffer = ip4ToBytes(sections[i]);
+          sections[i] = toString2(v4Buffer.subarray(0, 2), "base16");
+        }
+        if (v4Buffer != null && ++i < 8) {
+          sections.splice(i, 0, toString2(v4Buffer.subarray(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++) {
+        if (sections[i] === "") {
+          sections[i] = "0";
+        }
+        const word = parseInt(sections[i], 16);
+        if (isNaN(word) || word < 0 || word > 65535) {
+          throw new InvalidMultiaddrError("Invalid byte value in IP address");
+        }
+        bytes[offset++] = word >> 8 & 255;
+        bytes[offset++] = word & 255;
+      }
+      return bytes;
+    };
+    ip4ToString = function(buf) {
+      if (buf.byteLength !== 4) {
+        throw new InvalidMultiaddrError("IPv4 address was incorrect length");
+      }
+      const result = [];
+      for (let i = 0; i < buf.byteLength; i++) {
+        result.push(buf[i]);
+      }
+      return result.join(".");
+    };
+    ip6ToString = function(buf) {
+      if (buf.byteLength !== 16) {
+        throw new InvalidMultiaddrError("IPv6 address was incorrect length");
+      }
+      const result = [];
+      for (let i = 0; i < buf.byteLength; i += 2) {
+        const byte1 = buf[i];
+        const byte2 = buf[i + 1];
+        const tuple = `${byte1.toString(16).padStart(2, "0")}${byte2.toString(16).padStart(2, "0")}`;
+        result.push(tuple);
+      }
+      const ip = result.join(":");
+      try {
+        const url = new URL(`http://[${ip}]`);
+        return url.hostname.substring(1, url.hostname.length - 1);
+      } catch {
+        throw new InvalidMultiaddrError(`Invalid IPv6 address "${ip}"`);
+      }
+    };
+    decoders = Object.values(bases).map((c) => c.decoder);
+    anybaseDecoder = (function() {
+      let acc = decoders[0].or(decoders[1]);
+      decoders.slice(2).forEach((d) => acc = acc.or(d));
+      return acc;
+    })();
+  }
+});
+
+// node_modules/@multiformats/multiaddr/dist/src/validation.js
+function integer(value) {
+  const int = parseInt(value);
+  if (int.toString() !== value) {
+    throw new ValidationError("Value must be an integer");
+  }
+}
+function positive(value) {
+  if (value < 0) {
+    throw new ValidationError("Value must be a positive integer, or zero");
+  }
+}
+function maxValue(max) {
+  return (value) => {
+    if (value > max) {
+      throw new ValidationError(`Value must be smaller than or equal to ${max}`);
+    }
+  };
+}
+function validate(...funcs) {
+  return (value) => {
+    for (const fn of funcs) {
+      fn(value);
+    }
+  };
+}
+var validatePort;
+var init_validation = __esm({
+  "node_modules/@multiformats/multiaddr/dist/src/validation.js"() {
+    "use strict";
+    init_errors();
+    validatePort = validate(integer, positive, maxValue(65535));
+  }
+});
+
+// node_modules/@multiformats/multiaddr/dist/src/registry.js
+var V, Registry, registry, codecs;
+var init_registry = __esm({
+  "node_modules/@multiformats/multiaddr/dist/src/registry.js"() {
+    "use strict";
+    init_is_ip_node();
+    init_src();
+    init_base64();
+    init_constants();
+    init_errors();
+    init_utils();
+    init_validation();
+    V = -1;
+    Registry = class {
+      protocolsByCode = /* @__PURE__ */ new Map();
+      protocolsByName = /* @__PURE__ */ new Map();
+      getProtocol(key) {
+        let codec;
+        if (typeof key === "string") {
+          codec = this.protocolsByName.get(key);
+        } else {
+          codec = this.protocolsByCode.get(key);
+        }
+        if (codec == null) {
+          throw new UnknownProtocolError(`Protocol ${key} was unknown`);
+        }
+        return codec;
+      }
+      addProtocol(codec) {
+        this.protocolsByCode.set(codec.code, codec);
+        this.protocolsByName.set(codec.name, codec);
+        codec.aliases?.forEach((alias) => {
+          this.protocolsByName.set(alias, codec);
+        });
+      }
+      removeProtocol(code2) {
+        const codec = this.protocolsByCode.get(code2);
+        if (codec == null) {
+          return;
+        }
+        this.protocolsByCode.delete(codec.code);
+        this.protocolsByName.delete(codec.name);
+        codec.aliases?.forEach((alias) => {
+          this.protocolsByName.delete(alias);
+        });
+      }
+    };
+    registry = new Registry();
+    codecs = [{
+      code: CODE_IP4,
+      name: "ip4",
+      size: 32,
+      valueToBytes: ip4ToBytes,
+      bytesToValue: ip4ToString,
+      validate: (value) => {
+        if (!(0, import_node_net.isIPv4)(value)) {
+          throw new ValidationError(`Invalid IPv4 address "${value}"`);
+        }
+      }
+    }, {
+      code: CODE_TCP,
+      name: "tcp",
+      size: 16,
+      valueToBytes: port2bytes,
+      bytesToValue: bytes2port,
+      validate: validatePort
+    }, {
+      code: CODE_UDP,
+      name: "udp",
+      size: 16,
+      valueToBytes: port2bytes,
+      bytesToValue: bytes2port,
+      validate: validatePort
+    }, {
+      code: CODE_DCCP,
+      name: "dccp",
+      size: 16,
+      valueToBytes: port2bytes,
+      bytesToValue: bytes2port,
+      validate: validatePort
+    }, {
+      code: CODE_IP6,
+      name: "ip6",
+      size: 128,
+      valueToBytes: ip6ToBytes,
+      bytesToValue: ip6ToString,
+      stringToValue: ip6StringToValue,
+      validate: (value) => {
+        if (!(0, import_node_net.isIPv6)(value)) {
+          throw new ValidationError(`Invalid IPv6 address "${value}"`);
+        }
+      }
+    }, {
+      code: CODE_IP6ZONE,
+      name: "ip6zone",
+      size: V
+    }, {
+      code: CODE_IPCIDR,
+      name: "ipcidr",
+      size: 8,
+      bytesToValue: bytesToString("base10"),
+      valueToBytes: stringToBytes("base10")
+    }, {
+      code: CODE_DNS,
+      name: "dns",
+      size: V,
+      resolvable: true
+    }, {
+      code: CODE_DNS4,
+      name: "dns4",
+      size: V,
+      resolvable: true
+    }, {
+      code: CODE_DNS6,
+      name: "dns6",
+      size: V,
+      resolvable: true
+    }, {
+      code: CODE_DNSADDR,
+      name: "dnsaddr",
+      size: V,
+      resolvable: true
+    }, {
+      code: CODE_SCTP,
+      name: "sctp",
+      size: 16,
+      valueToBytes: port2bytes,
+      bytesToValue: bytes2port,
+      validate: validatePort
+    }, {
+      code: CODE_UDT,
+      name: "udt"
+    }, {
+      code: CODE_UTP,
+      name: "utp"
+    }, {
+      code: CODE_UNIX,
+      name: "unix",
+      size: V,
+      path: true,
+      stringToValue: (str) => decodeURIComponent(str),
+      valueToString: (val) => encodeURIComponent(val)
+    }, {
+      code: CODE_P2P,
+      name: "p2p",
+      aliases: ["ipfs"],
+      size: V,
+      bytesToValue: bytesToString("base58btc"),
+      valueToBytes: (val) => {
+        if (val.startsWith("Q") || val.startsWith("1")) {
+          return stringToBytes("base58btc")(val);
+        }
+        return CID.parse(val).multihash.bytes;
+      }
+    }, {
+      code: CODE_ONION,
+      name: "onion",
+      size: 96,
+      bytesToValue: bytes2onion,
+      valueToBytes: onion2bytes
+    }, {
+      code: CODE_ONION3,
+      name: "onion3",
+      size: 296,
+      bytesToValue: bytes2onion,
+      valueToBytes: onion32bytes
+    }, {
+      code: CODE_GARLIC64,
+      name: "garlic64",
+      size: V
+    }, {
+      code: CODE_GARLIC32,
+      name: "garlic32",
+      size: V
+    }, {
+      code: CODE_TLS,
+      name: "tls"
+    }, {
+      code: CODE_SNI,
+      name: "sni",
+      size: V
+    }, {
+      code: CODE_NOISE,
+      name: "noise"
+    }, {
+      code: CODE_QUIC,
+      name: "quic"
+    }, {
+      code: CODE_QUIC_V1,
+      name: "quic-v1"
+    }, {
+      code: CODE_WEBTRANSPORT,
+      name: "webtransport"
+    }, {
+      code: CODE_CERTHASH,
+      name: "certhash",
+      size: V,
+      bytesToValue: bytes2mb(base64url),
+      valueToBytes: mb2bytes
+    }, {
+      code: CODE_HTTP,
+      name: "http"
+    }, {
+      code: CODE_HTTP_PATH,
+      name: "http-path",
+      size: V,
+      stringToValue: (str) => `/${decodeURIComponent(str)}`,
+      valueToString: (val) => encodeURIComponent(val.substring(1))
+    }, {
+      code: CODE_HTTPS,
+      name: "https"
+    }, {
+      code: CODE_WS,
+      name: "ws"
+    }, {
+      code: CODE_WSS,
+      name: "wss"
+    }, {
+      code: CODE_P2P_WEBSOCKET_STAR,
+      name: "p2p-websocket-star"
+    }, {
+      code: CODE_P2P_STARDUST,
+      name: "p2p-stardust"
+    }, {
+      code: CODE_P2P_WEBRTC_STAR,
+      name: "p2p-webrtc-star"
+    }, {
+      code: CODE_P2P_WEBRTC_DIRECT,
+      name: "p2p-webrtc-direct"
+    }, {
+      code: CODE_WEBRTC_DIRECT,
+      name: "webrtc-direct"
+    }, {
+      code: CODE_WEBRTC,
+      name: "webrtc"
+    }, {
+      code: CODE_P2P_CIRCUIT,
+      name: "p2p-circuit"
+    }, {
+      code: CODE_MEMORY,
+      name: "memory",
+      size: V
+    }];
+    codecs.forEach((codec) => {
+      registry.addProtocol(codec);
+    });
+  }
+});
+
+// node_modules/@multiformats/multiaddr/dist/src/components.js
+function bytesToComponents(bytes) {
+  const components = [];
+  let i = 0;
+  while (i < bytes.length) {
+    const code2 = decode8(bytes, i);
+    const codec = registry.getProtocol(code2);
+    const codeLength = encodingLength2(code2);
+    const size = sizeForAddr(codec, bytes, i + codeLength);
+    let sizeLength = 0;
+    if (size > 0 && codec.size === V) {
+      sizeLength = encodingLength2(size);
+    }
+    const componentLength = codeLength + sizeLength + size;
+    const component = {
+      code: code2,
+      name: codec.name,
+      bytes: bytes.subarray(i, i + componentLength)
+    };
+    if (size > 0) {
+      const valueOffset = i + codeLength + sizeLength;
+      const valueBytes = bytes.subarray(valueOffset, valueOffset + size);
+      component.value = codec.bytesToValue?.(valueBytes) ?? toString2(valueBytes);
+    }
+    components.push(component);
+    i += componentLength;
+  }
+  return components;
+}
+function componentsToBytes(components) {
+  let length2 = 0;
+  const bytes = [];
+  for (const component of components) {
+    if (component.bytes == null) {
+      const codec = registry.getProtocol(component.code);
+      const codecLength = encodingLength2(component.code);
+      let valueBytes;
+      let valueLength = 0;
+      let valueLengthLength = 0;
+      if (component.value != null) {
+        valueBytes = codec.valueToBytes?.(component.value) ?? fromString2(component.value);
+        valueLength = valueBytes.byteLength;
+        if (codec.size === V) {
+          valueLengthLength = encodingLength2(valueLength);
+        }
+      }
+      const bytes2 = new Uint8Array(codecLength + valueLengthLength + valueLength);
+      let offset = 0;
+      encodeUint8Array(component.code, bytes2, offset);
+      offset += codecLength;
+      if (valueBytes != null) {
+        if (codec.size === V) {
+          encodeUint8Array(valueLength, bytes2, offset);
+          offset += valueLengthLength;
+        }
+        bytes2.set(valueBytes, offset);
+      }
+      component.bytes = bytes2;
+    }
+    bytes.push(component.bytes);
+    length2 += component.bytes.byteLength;
+  }
+  return concat(bytes, length2);
+}
+function stringToComponents(string2) {
+  if (string2.charAt(0) !== "/") {
+    throw new InvalidMultiaddrError('String multiaddr must start with "/"');
+  }
+  const components = [];
+  let collecting = "protocol";
+  let value = "";
+  let protocol = "";
+  for (let i = 1; i < string2.length; i++) {
+    const char = string2.charAt(i);
+    if (char !== "/") {
+      if (collecting === "protocol") {
+        protocol += string2.charAt(i);
+      } else {
+        value += string2.charAt(i);
+      }
+    }
+    const ended = i === string2.length - 1;
+    if (char === "/" || ended) {
+      const codec = registry.getProtocol(protocol);
+      if (collecting === "protocol") {
+        if (codec.size == null || codec.size === 0) {
+          components.push({
+            code: codec.code,
+            name: codec.name
+          });
+          value = "";
+          protocol = "";
+          collecting = "protocol";
+          continue;
+        } else if (ended) {
+          throw new InvalidMultiaddrError(`Component ${protocol} was missing value`);
+        }
+        collecting = "value";
+      } else if (collecting === "value") {
+        const component = {
+          code: codec.code,
+          name: codec.name
+        };
+        if (codec.size != null && codec.size !== 0) {
+          if (value === "") {
+            throw new InvalidMultiaddrError(`Component ${protocol} was missing value`);
+          }
+          component.value = codec.stringToValue?.(value) ?? value;
+        }
+        components.push(component);
+        value = "";
+        protocol = "";
+        collecting = "protocol";
+      }
+    }
+  }
+  if (protocol !== "" && value !== "") {
+    throw new InvalidMultiaddrError("Incomplete multiaddr");
+  }
+  return components;
+}
+function componentsToString(components) {
+  return `/${components.flatMap((component) => {
+    if (component.value == null) {
+      return component.name;
+    }
+    const codec = registry.getProtocol(component.code);
+    if (codec == null) {
+      throw new InvalidMultiaddrError(`Unknown protocol code ${component.code}`);
+    }
+    return [
+      component.name,
+      codec.valueToString?.(component.value) ?? component.value
+    ];
+  }).join("/")}`;
+}
+function sizeForAddr(codec, bytes, offset) {
+  if (codec.size == null || codec.size === 0) {
+    return 0;
+  }
+  if (codec.size > 0) {
+    return codec.size / 8;
+  }
+  return decode8(bytes, offset);
+}
+var init_components = __esm({
+  "node_modules/@multiformats/multiaddr/dist/src/components.js"() {
+    "use strict";
+    init_src2();
+    init_concat_node();
+    init_from_string_node();
+    init_to_string_node();
+    init_errors();
+    init_registry();
+  }
+});
+
+// node_modules/@multiformats/multiaddr/dist/src/multiaddr.js
+function toComponents(addr) {
+  if (addr == null) {
+    addr = "/";
+  }
+  if (isMultiaddr(addr)) {
+    return addr.getComponents();
+  }
+  if (addr instanceof Uint8Array) {
+    return bytesToComponents(addr);
+  }
+  if (typeof addr === "string") {
+    addr = addr.replace(/\/(\/)+/, "/").replace(/(\/)+$/, "");
+    if (addr === "") {
+      addr = "/";
+    }
+    return stringToComponents(addr);
+  }
+  if (Array.isArray(addr)) {
+    return addr;
+  }
+  throw new InvalidMultiaddrError("Must be a string, Uint8Array, Component[], or another Multiaddr");
+}
+function validate2(addr) {
+  addr.getComponents().forEach((component) => {
+    const codec = registry.getProtocol(component.code);
+    if (component.value == null) {
+      return;
+    }
+    codec.validate?.(component.value);
+  });
+}
+var inspect, symbol, DNS_CODES, NoAvailableResolverError, Multiaddr;
+var init_multiaddr = __esm({
+  "node_modules/@multiformats/multiaddr/dist/src/multiaddr.js"() {
+    "use strict";
+    init_base58();
+    init_cid();
+    init_equals();
+    init_from_string_node();
+    init_to_string_node();
+    init_components();
+    init_constants();
+    init_errors();
+    init_registry();
+    init_src4();
+    inspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+    symbol = /* @__PURE__ */ Symbol.for("@multiformats/multiaddr");
+    DNS_CODES = [
+      CODE_DNS,
+      CODE_DNS4,
+      CODE_DNS6,
+      CODE_DNSADDR
+    ];
+    NoAvailableResolverError = class extends Error {
+      constructor(message = "No available resolver") {
+        super(message);
+        this.name = "NoAvailableResolverError";
+      }
+    };
+    Multiaddr = class _Multiaddr {
+      [symbol] = true;
+      #components;
+      // cache string representation
+      #string;
+      // cache byte representation
+      #bytes;
+      constructor(addr = "/", options = {}) {
+        this.#components = toComponents(addr);
+        if (options.validate !== false) {
+          validate2(this);
+        }
+      }
+      get bytes() {
+        if (this.#bytes == null) {
+          this.#bytes = componentsToBytes(this.#components);
+        }
+        return this.#bytes;
+      }
+      toString() {
+        if (this.#string == null) {
+          this.#string = componentsToString(this.#components);
+        }
+        return this.#string;
+      }
+      toJSON() {
+        return this.toString();
+      }
+      toOptions() {
+        let family;
+        let transport;
+        let host;
+        let port;
+        let zone = "";
+        for (const { code: code2, name: name2, value } of this.#components) {
+          if (code2 === CODE_IP6ZONE) {
+            zone = `%${value ?? ""}`;
+          }
+          if (DNS_CODES.includes(code2)) {
+            transport = "tcp";
+            port = 443;
+            host = `${value ?? ""}${zone}`;
+            family = code2 === CODE_DNS6 ? 6 : 4;
+          }
+          if (code2 === CODE_TCP || code2 === CODE_UDP) {
+            transport = name2 === "tcp" ? "tcp" : "udp";
+            port = parseInt(value ?? "");
+          }
+          if (code2 === CODE_IP4 || code2 === CODE_IP6) {
+            transport = "tcp";
+            host = `${value ?? ""}${zone}`;
+            family = code2 === CODE_IP6 ? 6 : 4;
+          }
+        }
+        if (family == null || transport == null || host == null || port == null) {
+          throw new Error('multiaddr must have a valid format: "/{ip4, ip6, dns4, dns6, dnsaddr}/{address}/{tcp, udp}/{port}".');
+        }
+        const opts = {
+          family,
+          host,
+          transport,
+          port
+        };
+        return opts;
+      }
+      getComponents() {
+        return [
+          ...this.#components
+        ];
+      }
+      protos() {
+        return this.#components.map(({ code: code2, value }) => {
+          const codec = registry.getProtocol(code2);
+          return {
+            code: code2,
+            size: codec.size ?? 0,
+            name: codec.name,
+            resolvable: Boolean(codec.resolvable),
+            path: Boolean(codec.path)
+          };
+        });
+      }
+      protoCodes() {
+        return this.#components.map(({ code: code2 }) => code2);
+      }
+      protoNames() {
+        return this.#components.map(({ name: name2 }) => name2);
+      }
+      tuples() {
+        return this.#components.map(({ code: code2, value }) => {
+          if (value == null) {
+            return [code2];
+          }
+          const codec = registry.getProtocol(code2);
+          const output = [code2];
+          if (value != null) {
+            output.push(codec.valueToBytes?.(value) ?? fromString2(value));
+          }
+          return output;
+        });
+      }
+      stringTuples() {
+        return this.#components.map(({ code: code2, value }) => {
+          if (value == null) {
+            return [code2];
+          }
+          return [code2, value];
+        });
+      }
+      encapsulate(addr) {
+        const ma = new _Multiaddr(addr);
+        return new _Multiaddr([
+          ...this.#components,
+          ...ma.getComponents()
+        ], {
+          validate: false
+        });
+      }
+      decapsulate(addr) {
+        const addrString = addr.toString();
+        const s = this.toString();
+        const i = s.lastIndexOf(addrString);
+        if (i < 0) {
+          throw new InvalidParametersError(`Address ${this.toString()} does not contain subaddress: ${addr.toString()}`);
+        }
+        return new _Multiaddr(s.slice(0, i), {
+          validate: false
+        });
+      }
+      decapsulateCode(code2) {
+        let index;
+        for (let i = this.#components.length - 1; i > -1; i--) {
+          if (this.#components[i].code === code2) {
+            index = i;
+            break;
+          }
+        }
+        return new _Multiaddr(this.#components.slice(0, index), {
+          validate: false
+        });
+      }
+      getPeerId() {
+        try {
+          let tuples = [];
+          this.#components.forEach(({ code: code2, value }) => {
+            if (code2 === CODE_P2P) {
+              tuples.push([code2, value]);
+            }
+            if (code2 === CODE_P2P_CIRCUIT) {
+              tuples = [];
+            }
+          });
+          const tuple = tuples.pop();
+          if (tuple?.[1] != null) {
+            const peerIdStr = tuple[1];
+            if (peerIdStr[0] === "Q" || peerIdStr[0] === "1") {
+              return toString2(base58btc.decode(`z${peerIdStr}`), "base58btc");
+            }
+            return toString2(CID.parse(peerIdStr).multihash.bytes, "base58btc");
+          }
+          return null;
+        } catch (e) {
+          return null;
+        }
+      }
+      getPath() {
+        for (const component of this.#components) {
+          const codec = registry.getProtocol(component.code);
+          if (!codec.path) {
+            continue;
+          }
+          return component.value ?? null;
+        }
+        return null;
+      }
+      equals(addr) {
+        return equals3(this.bytes, addr.bytes);
+      }
+      async resolve(options) {
+        const resolvableProto = this.protos().find((p) => p.resolvable);
+        if (resolvableProto == null) {
+          return [this];
+        }
+        const resolver = resolvers.get(resolvableProto.name);
+        if (resolver == null) {
+          throw new NoAvailableResolverError(`no available resolver for ${resolvableProto.name}`);
+        }
+        const result = await resolver(this, options);
+        return result.map((str) => multiaddr(str));
+      }
+      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() {
+        if (this.#components.length !== 2) {
+          return false;
+        }
+        if (this.#components[0].code !== CODE_IP4 && this.#components[0].code !== CODE_IP6) {
+          return false;
+        }
+        if (this.#components[1].code !== CODE_TCP && this.#components[1].code !== CODE_UDP) {
+          return false;
+        }
+        return true;
+      }
+      /**
+       * Returns Multiaddr as a human-readable string
+       * https://nodejs.org/api/util.html#utilinspectcustom
+       *
+       * @example
+       * ```js
+       * import { multiaddr } from '@multiformats/multiaddr'
+       *
+       * console.info(multiaddr('/ip4/127.0.0.1/tcp/4001'))
+       * // 'Multiaddr(/ip4/127.0.0.1/tcp/4001)'
+       * ```
+       */
+      [inspect]() {
+        return `Multiaddr(${this.toString()})`;
+      }
+    };
+  }
+});
+
+// node_modules/@chainsafe/is-ip/lib/parser.js
+var Parser;
+var init_parser = __esm({
+  "node_modules/@chainsafe/is-ip/lib/parser.js"() {
+    "use strict";
+    Parser = class {
+      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;
+        const result = fn();
+        if (result === void 0) {
+          this.index = index;
+        }
+        return result;
+      }
+      /** 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) {
+          return void 0;
+        }
+        return result;
+      }
+      /** Peek the next character from the input */
+      peekChar() {
+        if (this.index >= this.input.length) {
+          return void 0;
+        }
+        return this.input[this.index];
+      }
+      /** Read the next character from the input */
+      readChar() {
+        if (this.index >= this.input.length) {
+          return void 0;
+        }
+        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) {
+            return void 0;
+          }
+          return char;
+        });
+      }
+      /**
+       * 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) {
+            if (this.readGivenChar(sep) === void 0) {
+              return void 0;
+            }
+          }
+          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 leadingChar = this.peekChar();
+          if (leadingChar === void 0) {
+            return void 0;
+          }
+          const hasLeadingZero = leadingChar === "0";
+          const maxValue2 = 2 ** (8 * maxBytes) - 1;
+          while (true) {
+            const digit = this.readAtomically(() => {
+              const char = this.readChar();
+              if (char === void 0) {
+                return void 0;
+              }
+              const num = Number.parseInt(char, radix);
+              if (Number.isNaN(num)) {
+                return void 0;
+              }
+              return num;
+            });
+            if (digit === void 0) {
+              break;
+            }
+            result *= radix;
+            result += digit;
+            if (result > maxValue2) {
+              return void 0;
+            }
+            digitCount += 1;
+            if (maxDigits !== void 0) {
+              if (digitCount > maxDigits) {
+                return void 0;
+              }
+            }
+          }
+          if (digitCount === 0) {
+            return void 0;
+          } else if (!allowZeroPrefix && hasLeadingZero && digitCount > 1) {
+            return void 0;
+          } else {
+            return result;
+          }
+        });
+      }
+      /** Read an IPv4 address. */
+      readIPv4Addr() {
+        return this.readAtomically(() => {
+          const out = new Uint8Array(4);
+          for (let i = 0; i < out.length; i++) {
+            const ix = this.readSeparator(".", i, () => this.readNumber(10, 3, false, 1));
+            if (ix === void 0) {
+              return void 0;
+            }
+            out[i] = ix;
+          }
+          return out;
+        });
+      }
+      /** Read an IPv6 Address. */
+      readIPv6Addr() {
+        const readGroups = (groups) => {
+          for (let i = 0; i < groups.length / 2; i++) {
+            const ix = i * 2;
+            if (i < groups.length - 3) {
+              const ipv4 = this.readSeparator(":", i, () => this.readIPv4Addr());
+              if (ipv4 !== void 0) {
+                groups[ix] = ipv4[0];
+                groups[ix + 1] = ipv4[1];
+                groups[ix + 2] = ipv4[2];
+                groups[ix + 3] = ipv4[3];
+                return [ix + 4, true];
+              }
+            }
+            const group = this.readSeparator(":", i, () => this.readNumber(16, 4, true, 2));
+            if (group === void 0) {
+              return [ix, false];
+            }
+            groups[ix] = group >> 8;
+            groups[ix + 1] = group & 255;
+          }
+          return [groups.length, false];
+        };
+        return this.readAtomically(() => {
+          const head = new Uint8Array(16);
+          const [headSize, headIp4] = readGroups(head);
+          if (headSize === 16) {
+            return head;
+          }
+          if (headIp4) {
+            return void 0;
+          }
+          if (this.readGivenChar(":") === void 0) {
+            return void 0;
+          }
+          if (this.readGivenChar(":") === void 0) {
+            return void 0;
+          }
+          const tail = new Uint8Array(14);
+          const limit = 16 - (headSize + 2);
+          const [tailSize] = readGroups(tail.subarray(0, limit));
+          head.set(tail.subarray(0, tailSize), 16 - tailSize);
+          return head;
+        });
+      }
+      /** Read an IP Address, either IPv4 or IPv6. */
+      readIPAddr() {
+        return this.readIPv4Addr() ?? this.readIPv6Addr();
+      }
+    };
+  }
+});
+
+// node_modules/@chainsafe/is-ip/lib/parse.js
+function parseIPv4(input) {
+  if (input.length > MAX_IPV4_LENGTH) {
+    return void 0;
+  }
+  return parser.new(input).parseWith(() => parser.readIPv4Addr());
+}
+function parseIPv6(input) {
+  if (input.includes("%")) {
+    input = input.split("%")[0];
+  }
+  if (input.length > MAX_IPV6_LENGTH) {
+    return void 0;
+  }
+  return parser.new(input).parseWith(() => parser.readIPv6Addr());
+}
+function parseIP(input, mapIPv4ToIPv6 = false) {
+  if (input.includes("%")) {
+    input = input.split("%")[0];
+  }
+  if (input.length > MAX_IPV6_LENGTH) {
+    return void 0;
+  }
+  const addr = parser.new(input).parseWith(() => parser.readIPAddr());
+  if (!addr) {
+    return void 0;
+  }
+  if (mapIPv4ToIPv6 && addr.length === 4) {
+    return Uint8Array.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, addr[0], addr[1], addr[2], addr[3]]);
+  }
+  return addr;
+}
+var MAX_IPV6_LENGTH, MAX_IPV4_LENGTH, parser;
+var init_parse = __esm({
+  "node_modules/@chainsafe/is-ip/lib/parse.js"() {
+    "use strict";
+    init_parser();
+    MAX_IPV6_LENGTH = 45;
+    MAX_IPV4_LENGTH = 15;
+    parser = new Parser();
+  }
+});
+
+// node_modules/@chainsafe/netmask/dist/src/util.js
+function allFF(a, from3, to) {
+  let i = 0;
+  for (const e of a) {
+    if (i < from3)
+      continue;
+    if (i > to)
+      break;
+    if (e !== 255)
+      return false;
+    i++;
+  }
+  return true;
+}
+function deepEqual(a, b, from3, to) {
+  let i = 0;
+  for (const e of a) {
+    if (i < from3)
+      continue;
+    if (i > to)
+      break;
+    if (e !== b[i])
+      return false;
+    i++;
+  }
+  return true;
+}
+function ipToString(ip) {
+  switch (ip.length) {
+    case IPv4Len: {
+      return ip.join(".");
+    }
+    case IPv6Len: {
+      const result = [];
+      for (let i = 0; i < ip.length; i++) {
+        if (i % 2 === 0) {
+          result.push(ip[i].toString(16).padStart(2, "0") + ip[i + 1].toString(16).padStart(2, "0"));
+        }
+      }
+      return result.join(":");
+    }
+    default: {
+      throw new Error("Invalid ip length");
+    }
+  }
+}
+function simpleMaskLength(mask) {
+  let ones = 0;
+  for (let [index, byte] of mask.entries()) {
+    if (byte === 255) {
+      ones += 8;
+      continue;
+    }
+    while ((byte & 128) != 0) {
+      ones++;
+      byte = byte << 1;
+    }
+    if ((byte & 128) != 0) {
+      return -1;
+    }
+    for (let i = index + 1; i < mask.length; i++) {
+      if (mask[i] != 0) {
+        return -1;
+      }
+    }
+    break;
+  }
+  return ones;
+}
+function maskToHex(mask) {
+  let hex = "0x";
+  for (const byte of mask) {
+    hex += (byte >> 4).toString(16) + (byte & 15).toString(16);
+  }
+  return hex;
+}
+var init_util = __esm({
+  "node_modules/@chainsafe/netmask/dist/src/util.js"() {
+    "use strict";
+    init_ip();
+  }
+});
+
+// node_modules/@chainsafe/netmask/dist/src/ip.js
+function maskIp(ip, mask) {
+  if (mask.length === IPv6Len && ip.length === IPv4Len && allFF(mask, 0, 11)) {
+    mask = mask.slice(12);
+  }
+  if (mask.length === IPv4Len && ip.length === IPv6Len && deepEqual(ip, ipv4Prefix, 0, 11)) {
+    ip = ip.slice(12);
+  }
+  const n = ip.length;
+  if (n != mask.length) {
+    throw new Error("Failed to mask ip");
+  }
+  const out = new Uint8Array(n);
+  for (let i = 0; i < n; i++) {
+    out[i] = ip[i] & mask[i];
+  }
+  return out;
+}
+function containsIp(net, ip) {
+  if (typeof ip === "string") {
+    ip = parseIP(ip);
+  }
+  if (ip == null)
+    throw new Error("Invalid ip");
+  if (ip.length !== net.network.length) {
+    return false;
+  }
+  for (let i = 0; i < ip.length; i++) {
+    if ((net.network[i] & net.mask[i]) !== (ip[i] & net.mask[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+var IPv4Len, IPv6Len, maxIPv6Octet, ipv4Prefix;
+var init_ip = __esm({
+  "node_modules/@chainsafe/netmask/dist/src/ip.js"() {
+    "use strict";
+    init_parse();
+    init_util();
+    IPv4Len = 4;
+    IPv6Len = 16;
+    maxIPv6Octet = parseInt("0xFFFF", 16);
+    ipv4Prefix = new Uint8Array([
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      255,
+      255
+    ]);
+  }
+});
+
+// node_modules/@chainsafe/netmask/dist/src/cidr.js
+function parseCidr(s) {
+  const [address, maskString] = s.split("/");
+  if (!address || !maskString)
+    throw new Error("Failed to parse given CIDR: " + s);
+  let ipLength = IPv4Len;
+  let ip = parseIPv4(address);
+  if (ip == null) {
+    ipLength = IPv6Len;
+    ip = parseIPv6(address);
+    if (ip == null)
+      throw new Error("Failed to parse given CIDR: " + s);
+  }
+  const m = parseInt(maskString, 10);
+  if (Number.isNaN(m) || String(m).length !== maskString.length || m < 0 || m > ipLength * 8) {
+    throw new Error("Failed to parse given CIDR: " + s);
+  }
+  const mask = cidrMask(m, 8 * ipLength);
+  return {
+    network: maskIp(ip, mask),
+    mask
+  };
+}
+function cidrMask(ones, bits) {
+  if (bits !== 8 * IPv4Len && bits !== 8 * IPv6Len)
+    throw new Error("Invalid CIDR mask");
+  if (ones < 0 || ones > bits)
+    throw new Error("Invalid CIDR mask");
+  const l = bits / 8;
+  const m = new Uint8Array(l);
+  for (let i = 0; i < l; i++) {
+    if (ones >= 8) {
+      m[i] = 255;
+      ones -= 8;
+      continue;
+    }
+    m[i] = 255 - (255 >> ones);
+    ones = 0;
+  }
+  return m;
+}
+var init_cidr = __esm({
+  "node_modules/@chainsafe/netmask/dist/src/cidr.js"() {
+    "use strict";
+    init_parse();
+    init_ip();
+  }
+});
+
+// node_modules/@chainsafe/netmask/dist/src/ipnet.js
+var IpNet;
+var init_ipnet = __esm({
+  "node_modules/@chainsafe/netmask/dist/src/ipnet.js"() {
+    "use strict";
+    init_parse();
+    init_cidr();
+    init_ip();
+    init_util();
+    IpNet = class {
+      /**
+       *
+       * @param ipOrCidr either network ip or full cidr address
+       * @param mask in case ipOrCidr is network this can be either mask in decimal format or as ip address
+       */
+      constructor(ipOrCidr, mask) {
+        if (mask == null) {
+          ({ network: this.network, mask: this.mask } = parseCidr(ipOrCidr));
+        } else {
+          const ipResult = parseIP(ipOrCidr);
+          if (ipResult == null) {
+            throw new Error("Failed to parse network");
+          }
+          mask = String(mask);
+          const m = parseInt(mask, 10);
+          if (Number.isNaN(m) || String(m).length !== mask.length || m < 0 || m > ipResult.length * 8) {
+            const maskResult = parseIP(mask);
+            if (maskResult == null) {
+              throw new Error("Failed to parse mask");
+            }
+            this.mask = maskResult;
+          } else {
+            this.mask = cidrMask(m, 8 * ipResult.length);
+          }
+          this.network = maskIp(ipResult, this.mask);
+        }
+      }
+      /**
+       * Checks if netmask contains ip address
+       * @param ip
+       * @returns
+       */
+      contains(ip) {
+        return containsIp({ network: this.network, mask: this.mask }, ip);
+      }
+      /**Serializes back to string format */
+      toString() {
+        const l = simpleMaskLength(this.mask);
+        const mask = l !== -1 ? String(l) : maskToHex(this.mask);
+        return ipToString(this.network) + "/" + mask;
+      }
+    };
+  }
+});
+
+// node_modules/@chainsafe/netmask/dist/src/index.js
+var init_src3 = __esm({
+  "node_modules/@chainsafe/netmask/dist/src/index.js"() {
+    "use strict";
+    init_ipnet();
+    init_util();
+    init_ip();
+    init_ipnet();
+    init_cidr();
+  }
+});
+
+// node_modules/@multiformats/multiaddr/dist/src/convert.js
+function convertToIpNet(multiaddr2) {
+  let mask;
+  let addr;
+  multiaddr2.getComponents().forEach((component) => {
+    if (component.name === "ip4" || component.name === "ip6") {
+      addr = component.value;
+    }
+    if (component.name === "ipcidr") {
+      mask = component.value;
+    }
+  });
+  if (mask == null || addr == null) {
+    throw new Error("Invalid multiaddr");
+  }
+  return new IpNet(addr, mask);
+}
+var init_convert = __esm({
+  "node_modules/@multiformats/multiaddr/dist/src/convert.js"() {
+    "use strict";
+    init_src3();
+    init_from_string_node();
+    init_to_string_node();
+    init_registry();
+  }
+});
+
+// node_modules/@multiformats/multiaddr/dist/src/filter/multiaddr-filter.js
+var MultiaddrFilter;
+var init_multiaddr_filter = __esm({
+  "node_modules/@multiformats/multiaddr/dist/src/filter/multiaddr-filter.js"() {
+    "use strict";
+    init_convert();
+    init_src4();
+    MultiaddrFilter = class {
+      multiaddr;
+      netmask;
+      constructor(input) {
+        this.multiaddr = multiaddr(input);
+        this.netmask = convertToIpNet(this.multiaddr);
+      }
+      contains(input) {
+        if (input == null) {
+          return false;
+        }
+        const m = multiaddr(input);
+        let ip;
+        for (const [code2, value] of m.stringTuples()) {
+          if (code2 === 4 || code2 === 41) {
+            ip = value;
+            break;
+          }
+        }
+        if (ip === void 0) {
+          return false;
+        }
+        return this.netmask.contains(ip);
+      }
+    };
+  }
+});
+
+// node_modules/@multiformats/multiaddr/dist/src/index.js
+var src_exports2 = {};
+__export(src_exports2, {
+  CODE_CERTHASH: () => CODE_CERTHASH,
+  CODE_DCCP: () => CODE_DCCP,
+  CODE_DNS: () => CODE_DNS,
+  CODE_DNS4: () => CODE_DNS4,
+  CODE_DNS6: () => CODE_DNS6,
+  CODE_DNSADDR: () => CODE_DNSADDR,
+  CODE_GARLIC32: () => CODE_GARLIC32,
+  CODE_GARLIC64: () => CODE_GARLIC64,
+  CODE_HTTP: () => CODE_HTTP,
+  CODE_HTTPS: () => CODE_HTTPS,
+  CODE_HTTP_PATH: () => CODE_HTTP_PATH,
+  CODE_IP4: () => CODE_IP4,
+  CODE_IP6: () => CODE_IP6,
+  CODE_IP6ZONE: () => CODE_IP6ZONE,
+  CODE_IPCIDR: () => CODE_IPCIDR,
+  CODE_MEMORY: () => CODE_MEMORY,
+  CODE_NOISE: () => CODE_NOISE,
+  CODE_ONION: () => CODE_ONION,
+  CODE_ONION3: () => CODE_ONION3,
+  CODE_P2P: () => CODE_P2P,
+  CODE_P2P_CIRCUIT: () => CODE_P2P_CIRCUIT,
+  CODE_P2P_STARDUST: () => CODE_P2P_STARDUST,
+  CODE_P2P_WEBRTC_DIRECT: () => CODE_P2P_WEBRTC_DIRECT,
+  CODE_P2P_WEBRTC_STAR: () => CODE_P2P_WEBRTC_STAR,
+  CODE_P2P_WEBSOCKET_STAR: () => CODE_P2P_WEBSOCKET_STAR,
+  CODE_QUIC: () => CODE_QUIC,
+  CODE_QUIC_V1: () => CODE_QUIC_V1,
+  CODE_SCTP: () => CODE_SCTP,
+  CODE_SNI: () => CODE_SNI,
+  CODE_TCP: () => CODE_TCP,
+  CODE_TLS: () => CODE_TLS,
+  CODE_UDP: () => CODE_UDP,
+  CODE_UDT: () => CODE_UDT,
+  CODE_UNIX: () => CODE_UNIX,
+  CODE_UTP: () => CODE_UTP,
+  CODE_WEBRTC: () => CODE_WEBRTC,
+  CODE_WEBRTC_DIRECT: () => CODE_WEBRTC_DIRECT,
+  CODE_WEBTRANSPORT: () => CODE_WEBTRANSPORT,
+  CODE_WS: () => CODE_WS,
+  CODE_WSS: () => CODE_WSS,
+  MultiaddrFilter: () => MultiaddrFilter,
+  V: () => V,
+  fromNodeAddress: () => fromNodeAddress,
+  fromStringTuples: () => fromStringTuples,
+  fromTuples: () => fromTuples,
+  isMultiaddr: () => isMultiaddr,
+  isName: () => isName,
+  multiaddr: () => multiaddr,
+  protocols: () => protocols,
+  registry: () => registry,
+  resolvers: () => resolvers
+});
+function fromNodeAddress(addr, transport) {
+  if (addr == null) {
+    throw new InvalidParametersError("requires node address object");
+  }
+  if (transport == null) {
+    throw new InvalidParametersError("requires transport protocol");
+  }
+  let ip;
+  let host = addr.address;
+  switch (addr.family) {
+    case 4:
+      ip = "ip4";
+      break;
+    case 6:
+      ip = "ip6";
+      if (host.includes("%")) {
+        const parts = host.split("%");
+        if (parts.length !== 2) {
+          throw Error("Multiple ip6 zones in multiaddr");
+        }
+        host = parts[0];
+        const zone = parts[1];
+        ip = `ip6zone/${zone}/ip6`;
+      }
+      break;
+    default:
+      throw Error("Invalid addr family, should be 4 or 6.");
+  }
+  return new Multiaddr("/" + [ip, host, transport, addr.port].join("/"));
+}
+function fromTuples(tuples) {
+  return multiaddr(tuples.map(([code2, value]) => {
+    const codec = registry.getProtocol(code2);
+    const component = {
+      code: code2,
+      name: codec.name
+    };
+    if (value != null) {
+      component.value = codec.bytesToValue?.(value) ?? toString2(value);
+    }
+    return component;
+  }));
+}
+function fromStringTuples(tuples) {
+  return multiaddr(tuples.map(([code2, value]) => {
+    const codec = registry.getProtocol(code2);
+    const component = {
+      code: code2,
+      name: codec.name
+    };
+    if (value != null) {
+      component.value = value;
+    }
+    return component;
+  }));
+}
+function isName(addr) {
+  if (!isMultiaddr(addr)) {
+    return false;
+  }
+  return addr.protos().some((proto) => proto.resolvable);
+}
+function isMultiaddr(value) {
+  return Boolean(value?.[symbol]);
+}
+function multiaddr(addr) {
+  return new Multiaddr(addr);
+}
+function protocols(proto) {
+  const codec = registry.getProtocol(proto);
+  return {
+    code: codec.code,
+    size: codec.size ?? 0,
+    name: codec.name,
+    resolvable: Boolean(codec.resolvable),
+    path: Boolean(codec.path)
+  };
+}
+var resolvers;
+var init_src4 = __esm({
+  "node_modules/@multiformats/multiaddr/dist/src/index.js"() {
+    "use strict";
+    init_to_string_node();
+    init_errors();
+    init_multiaddr();
+    init_registry();
+    init_multiaddr_filter();
+    init_constants();
+    resolvers = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/browser.ts
 var browser_exports = {};
 __export(browser_exports, {
@@ -198,10 +3611,10 @@ var ErrorBehavior = /* @__PURE__ */ ((ErrorBehavior2) => {
 var CairnError = class extends Error {
   code;
   details;
-  constructor(code, message, details) {
+  constructor(code2, message, details) {
     super(message);
     this.name = "CairnError";
-    this.code = code;
+    this.code = code2;
     this.details = details;
   }
   errorBehavior() {
@@ -369,9 +3782,9 @@ var HKDF_INFO_RENDEZVOUS = encoder.encode("cairn-rendezvous-id-v1");
 var HKDF_INFO_SAS = encoder.encode("cairn-sas-derivation-v1");
 var HKDF_INFO_CHAIN_KEY = encoder.encode("cairn-chain-key-v1");
 var HKDF_INFO_MESSAGE_KEY = encoder.encode("cairn-message-key-v1");
-function hkdfSha256(ikm, salt, info, length) {
+function hkdfSha256(ikm, salt, info, length2) {
   try {
-    return (0, import_hkdf.hkdf)(import_sha2562.sha256, ikm, salt, info, length);
+    return (0, import_hkdf.hkdf)(import_sha2562.sha256, ikm, salt, info, length2);
   } catch (e) {
     throw new CairnError("CRYPTO", `HKDF-SHA256 error: ${e}`);
   }
@@ -445,8 +3858,8 @@ var NoiseXXHandshake = class {
   currentKey;
   pakeSecret;
   cachedResult;
-  constructor(role, identity, pakeSecret) {
-    this.localStaticX25519Secret = import_ed25519.ed25519.utils.toMontgomerySecret(identity.secretBytes());
+  constructor(role, identity3, pakeSecret) {
+    this.localStaticX25519Secret = import_ed25519.ed25519.utils.toMontgomerySecret(identity3.secretBytes());
     if (PROTOCOL_NAME.length <= 32) {
       this.handshakeHash = new Uint8Array(32);
       this.handshakeHash.set(PROTOCOL_NAME);
@@ -454,7 +3867,7 @@ var NoiseXXHandshake = class {
       this.handshakeHash = (0, import_sha2563.sha256)(PROTOCOL_NAME);
     }
     this.chainingKey = new Uint8Array(this.handshakeHash);
-    this.localIdentity = identity;
+    this.localIdentity = identity3;
     this.state = role === "initiator" ? "initiator_start" : "responder_wait_msg1";
     if (pakeSecret) {
       if (pakeSecret.length !== 32) {
@@ -1422,8 +4835,8 @@ var MessageQueue = class {
 var APP_MSG_TYPE_MIN = 61440;
 var APP_MSG_TYPE_MAX = 65535;
 var NodeChannel = class {
-  constructor(name) {
-    this.name = name;
+  constructor(name2) {
+    this.name = name2;
   }
   _open = true;
   get isOpen() {
@@ -1466,15 +4879,15 @@ var NodeSession = class {
     this._ratchet = ratchet;
   }
   /** Open a named channel. */
-  openChannel(name) {
-    if (!name) {
+  openChannel(name2) {
+    if (!name2) {
       throw new CairnError("PROTOCOL", "channel name cannot be empty");
     }
-    if (name.startsWith("__cairn_")) {
+    if (name2.startsWith("__cairn_")) {
       throw new CairnError("PROTOCOL", "reserved channel name prefix");
     }
-    const channel = new NodeChannel(name);
-    this._channels.set(name, channel);
+    const channel = new NodeChannel(name2);
+    this._channels.set(name2, channel);
     for (const listener of this._channelListeners) {
       listener(channel);
     }
@@ -1629,6 +5042,8 @@ var Node = class _Node {
   _libp2pNode = null;
   /** Listen addresses reported by the libp2p node. */
   _listenAddresses = [];
+  /** Connection hints from pairing, keyed by peer ID hex string. */
+  _peerHints = /* @__PURE__ */ new Map();
   constructor(config) {
     this._config = config;
   }
@@ -1803,6 +5218,9 @@ var Node = class _Node {
     const payload = consumeQrPayload(data);
     this._runPairingExchange(payload.pakeCredential);
     const remotePeerId = bytesToHex3(payload.peerId);
+    if (payload.hints && payload.hints.length > 0) {
+      this._peerHints.set(remotePeerId, payload.hints);
+    }
     this._completePairing(remotePeerId);
     return remotePeerId;
   }
@@ -1838,8 +5256,28 @@ var Node = class _Node {
     return remotePeerId;
   }
   // --- Connection methods ---
-  /** Connect to a paired peer. Performs Noise XX handshake and Double Ratchet init. */
+  /** Connect to a paired peer. Dials via libp2p if transport is started, falls back to in-memory handshake. */
   async connect(peerId, _options) {
+    if (this._libp2pNode && this._peerHints.has(peerId)) {
+      const hints = this._peerHints.get(peerId);
+      const { multiaddr: multiaddr2 } = await Promise.resolve().then(() => (init_src4(), src_exports2));
+      const wsHints = hints.filter((h) => h.hintType === "multiaddr" && h.value.includes("/ws"));
+      const tcpHints = hints.filter((h) => h.hintType === "multiaddr" && h.value.includes("/tcp/") && !h.value.includes("/ws"));
+      const allHints = [...wsHints, ...tcpHints];
+      let connected = false;
+      for (const hint of allHints) {
+        try {
+          const ma = multiaddr2(hint.value);
+          await this._libp2pNode.dial(ma);
+          connected = true;
+          break;
+        } catch {
+        }
+      }
+      if (!connected && allHints.length > 0) {
+        throw new CairnError("TRANSPORT", `failed to connect to peer ${peerId} via any address`);
+      }
+    }
     const handshakeResult = await this._performNoiseHandshake();
     const bobDh = X25519Keypair.generate();
     const ratchet = DoubleRatchet.initSender(handshakeResult.sessionKey, bobDh.publicKeyBytes());
@@ -1921,8 +5359,8 @@ var VALID_TRANSITIONS = [
   ["suspended", "failed"],
   ["reconnected", "connected"]
 ];
-function isValidTransition(from, to) {
-  return VALID_TRANSITIONS.some(([f, t]) => f === from && t === to);
+function isValidTransition(from3, to) {
+  return VALID_TRANSITIONS.some(([f, t]) => f === from3 && t === to);
 }
 var SessionStateMachine = class {
   _sessionId;
@@ -1957,11 +5395,11 @@ var SessionStateMachine = class {
         `invalid session state transition: ${this._state} -> ${to}`
       );
     }
-    const from = this._state;
+    const from3 = this._state;
     this._state = to;
     const event = {
       sessionId: this._sessionId,
-      fromState: from,
+      fromState: from3,
       toState: to,
       timestamp: Date.now(),
       reason