@fireproof/core 0.10.0-dev → 0.10.1-dev

package/dist/crdt-helpers.browser.js

@@ -1,4961 +0,0 @@
-"use strict";
-(() => {
-  var __defProp = Object.defineProperty;
-  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __propIsEnum = Object.prototype.propertyIsEnumerable;
-  var __knownSymbol = (name2, symbol) => {
-    if (symbol = Symbol[name2])
-      return symbol;
-    throw Error("Symbol." + name2 + " is not defined");
-  };
-  var __pow = Math.pow;
-  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues = (a, b) => {
-    for (var prop in b || (b = {}))
-      if (__hasOwnProp.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    if (__getOwnPropSymbols)
-      for (var prop of __getOwnPropSymbols(b)) {
-        if (__propIsEnum.call(b, prop))
-          __defNormalProp(a, prop, b[prop]);
-      }
-    return a;
-  };
-  var __export = (target, all) => {
-    for (var name2 in all)
-      __defProp(target, name2, { get: all[name2], enumerable: true });
-  };
-  var __accessCheck = (obj, member, msg) => {
-    if (!member.has(obj))
-      throw TypeError("Cannot " + msg);
-  };
-  var __privateGet = (obj, member, getter) => {
-    __accessCheck(obj, member, "read from private field");
-    return getter ? getter.call(obj) : member.get(obj);
-  };
-  var __privateAdd = (obj, member, value) => {
-    if (member.has(obj))
-      throw TypeError("Cannot add the same private member more than once");
-    member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-  };
-  var __privateSet = (obj, member, value, setter) => {
-    __accessCheck(obj, member, "write to private field");
-    setter ? setter.call(obj, value) : member.set(obj, value);
-    return value;
-  };
-  var __async = (__this, __arguments, generator) => {
-    return new Promise((resolve, reject) => {
-      var fulfilled = (value) => {
-        try {
-          step(generator.next(value));
-        } catch (e) {
-          reject(e);
-        }
-      };
-      var rejected = (value) => {
-        try {
-          step(generator.throw(value));
-        } catch (e) {
-          reject(e);
-        }
-      };
-      var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-      step((generator = generator.apply(__this, __arguments)).next());
-    });
-  };
-  var __await = function(promise, isYieldStar) {
-    this[0] = promise;
-    this[1] = isYieldStar;
-  };
-  var __yieldStar = (value) => {
-    var obj = value[__knownSymbol("asyncIterator")];
-    var isAwait = false;
-    var method;
-    var it = {};
-    if (obj == null) {
-      obj = value[__knownSymbol("iterator")]();
-      method = (k) => it[k] = (x) => obj[k](x);
-    } else {
-      obj = obj.call(value);
-      method = (k) => it[k] = (v) => {
-        if (isAwait) {
-          isAwait = false;
-          if (k === "throw")
-            throw v;
-          return v;
-        }
-        isAwait = true;
-        return {
-          done: false,
-          value: new __await(new Promise((resolve) => {
-            var x = obj[k](v);
-            if (!(x instanceof Object))
-              throw TypeError("Object expected");
-            resolve(x);
-          }), 1)
-        };
-      };
-    }
-    return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
-      throw x;
-    }, "return" in obj && method("return"), it;
-  };
-
-  // node_modules/multiformats/vendor/varint.js
-  var encode_1 = encode;
-  var MSB = 128;
-  var REST = 127;
-  var MSBALL = ~REST;
-  var INT = Math.pow(2, 31);
-  function encode(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;
-    encode.bytes = offset - oldOffset + 1;
-    return out;
-  }
-  var decode = read;
-  var MSB$1 = 128;
-  var REST$1 = 127;
-  function read(buf2, offset) {
-    var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf2.length;
-    do {
-      if (counter >= l) {
-        read.bytes = 0;
-        throw new RangeError("Could not decode varint");
-      }
-      b = buf2[counter++];
-      res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
-      shift += 7;
-    } while (b >= MSB$1);
-    read.bytes = counter - offset;
-    return res;
-  }
-  var N1 = Math.pow(2, 7);
-  var N2 = Math.pow(2, 14);
-  var N3 = Math.pow(2, 21);
-  var N4 = Math.pow(2, 28);
-  var N5 = Math.pow(2, 35);
-  var N6 = Math.pow(2, 42);
-  var N7 = Math.pow(2, 49);
-  var N8 = Math.pow(2, 56);
-  var N9 = Math.pow(2, 63);
-  var length = function(value) {
-    return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
-  };
-  var varint = {
-    encode: encode_1,
-    decode,
-    encodingLength: length
-  };
-  var _brrp_varint = varint;
-  var varint_default = _brrp_varint;
-
-  // node_modules/multiformats/src/varint.js
-  var decode2 = (data, offset = 0) => {
-    const code2 = varint_default.decode(data, offset);
-    return [code2, varint_default.decode.bytes];
-  };
-  var encodeTo = (int, target, offset = 0) => {
-    varint_default.encode(int, target, offset);
-    return target;
-  };
-  var encodingLength = (int) => {
-    return varint_default.encodingLength(int);
-  };
-
-  // node_modules/multiformats/src/bytes.js
-  var bytes_exports = {};
-  __export(bytes_exports, {
-    coerce: () => coerce,
-    empty: () => empty,
-    equals: () => equals,
-    fromHex: () => fromHex,
-    fromString: () => fromString,
-    isBinary: () => isBinary,
-    toHex: () => toHex,
-    toString: () => toString
-  });
-  var empty = new Uint8Array(0);
-  var toHex = (d) => d.reduce((hex, byte) => hex + byte.toString(16).padStart(2, "0"), "");
-  var fromHex = (hex) => {
-    const hexes = hex.match(/../g);
-    return hexes ? new Uint8Array(hexes.map((b) => parseInt(b, 16))) : empty;
-  };
-  var 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;
-  };
-  var 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");
-  };
-  var isBinary = (o) => o instanceof ArrayBuffer || ArrayBuffer.isView(o);
-  var fromString = (str) => new TextEncoder().encode(str);
-  var toString = (b) => new TextDecoder().decode(b);
-
-  // node_modules/multiformats/src/hashes/digest.js
-  var create = (code2, digest) => {
-    const size = digest.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(digest, digestOffset);
-    return new Digest(code2, size, digest, bytes);
-  };
-  var decode3 = (multihash) => {
-    const bytes = coerce(multihash);
-    const [code2, sizeOffset] = decode2(bytes);
-    const [size, digestOffset] = decode2(bytes.subarray(sizeOffset));
-    const digest = bytes.subarray(sizeOffset + digestOffset);
-    if (digest.byteLength !== size) {
-      throw new Error("Incorrect length");
-    }
-    return new Digest(code2, size, digest, bytes);
-  };
-  var equals2 = (a, b) => {
-    if (a === b) {
-      return true;
-    } else {
-      const data = (
-        /** @type {{code?:unknown, size?:unknown, bytes?:unknown}} */
-        b
-      );
-      return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals(a.bytes, data.bytes);
-    }
-  };
-  var Digest = class {
-    /**
-     * Creates a multihash digest.
-     *
-     * @param {Code} code
-     * @param {Size} size
-     * @param {Uint8Array} digest
-     * @param {Uint8Array} bytes
-     */
-    constructor(code2, size, digest, bytes) {
-      this.code = code2;
-      this.size = size;
-      this.digest = digest;
-      this.bytes = bytes;
-    }
-  };
-
-  // node_modules/multiformats/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 encode9(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 length3 = 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 < length3) && 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");
-        }
-        length3 = i2;
-        pbegin++;
-      }
-      var it2 = size - length3;
-      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 length3 = 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 < length3) && 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");
-        }
-        length3 = i2;
-        psz++;
-      }
-      if (source[psz] === " ") {
-        return;
-      }
-      var it4 = size - length3;
-      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 decode13(string) {
-      var buffer2 = decodeUnsafe(string);
-      if (buffer2) {
-        return buffer2;
-      }
-      throw new Error(`Non-${name2} character`);
-    }
-    return {
-      encode: encode9,
-      decodeUnsafe,
-      decode: decode13
-    };
-  }
-  var src = base;
-  var _brrp__multiformats_scope_baseX = src;
-  var base_x_default = _brrp__multiformats_scope_baseX;
-
-  // node_modules/multiformats/src/bases/base.js
-  var Encoder = class {
-    /**
-     * @param {Base} name
-     * @param {Prefix} prefix
-     * @param {(bytes:Uint8Array) => string} baseEncode
-     */
-    constructor(name2, prefix, baseEncode) {
-      this.name = name2;
-      this.prefix = prefix;
-      this.baseEncode = baseEncode;
-    }
-    /**
-     * @param {Uint8Array} bytes
-     * @returns {API.Multibase<Prefix>}
-     */
-    encode(bytes) {
-      if (bytes instanceof Uint8Array) {
-        return `${this.prefix}${this.baseEncode(bytes)}`;
-      } else {
-        throw Error("Unknown type, must be binary type");
-      }
-    }
-  };
-  var Decoder = class {
-    /**
-     * @param {Base} name
-     * @param {Prefix} prefix
-     * @param {(text:string) => Uint8Array} baseDecode
-     */
-    constructor(name2, prefix, baseDecode) {
-      this.name = name2;
-      this.prefix = prefix;
-      if (prefix.codePointAt(0) === void 0) {
-        throw new Error("Invalid prefix character");
-      }
-      this.prefixCodePoint = /** @type {number} */
-      prefix.codePointAt(0);
-      this.baseDecode = baseDecode;
-    }
-    /**
-     * @param {string} text
-     */
-    decode(text) {
-      if (typeof text === "string") {
-        if (text.codePointAt(0) !== this.prefixCodePoint) {
-          throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
-        }
-        return this.baseDecode(text.slice(this.prefix.length));
-      } else {
-        throw Error("Can only multibase decode strings");
-      }
-    }
-    /**
-     * @template {string} OtherPrefix
-     * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
-     * @returns {ComposedDecoder<Prefix|OtherPrefix>}
-     */
-    or(decoder) {
-      return or(this, decoder);
-    }
-  };
-  var ComposedDecoder = class {
-    /**
-     * @param {Decoders<Prefix>} decoders
-     */
-    constructor(decoders) {
-      this.decoders = decoders;
-    }
-    /**
-     * @template {string} OtherPrefix
-     * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
-     * @returns {ComposedDecoder<Prefix|OtherPrefix>}
-     */
-    or(decoder) {
-      return or(this, decoder);
-    }
-    /**
-     * @param {string} input
-     * @returns {Uint8Array}
-     */
-    decode(input) {
-      const prefix = (
-        /** @type {Prefix} */
-        input[0]
-      );
-      const decoder = this.decoders[prefix];
-      if (decoder) {
-        return decoder.decode(input);
-      } else {
-        throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
-      }
-    }
-  };
-  var or = (left, right) => new ComposedDecoder(
-    /** @type {Decoders<L|R>} */
-    __spreadValues(__spreadValues({}, left.decoders || { [
-      /** @type API.UnibaseDecoder<L> */
-      left.prefix
-    ]: left }), right.decoders || { [
-      /** @type API.UnibaseDecoder<R> */
-      right.prefix
-    ]: right })
-  );
-  var Codec = class {
-    /**
-     * @param {Base} name
-     * @param {Prefix} prefix
-     * @param {(bytes:Uint8Array) => string} baseEncode
-     * @param {(text:string) => Uint8Array} baseDecode
-     */
-    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);
-    }
-    /**
-     * @param {Uint8Array} input
-     */
-    encode(input) {
-      return this.encoder.encode(input);
-    }
-    /**
-     * @param {string} input
-     */
-    decode(input) {
-      return this.decoder.decode(input);
-    }
-  };
-  var from = ({ name: name2, prefix, encode: encode9, decode: decode13 }) => new Codec(name2, prefix, encode9, decode13);
-  var baseX = ({ prefix, name: name2, alphabet }) => {
-    const { encode: encode9, decode: decode13 } = base_x_default(alphabet, name2);
-    return from({
-      prefix,
-      name: name2,
-      encode: encode9,
-      /**
-       * @param {string} text
-       */
-      decode: (text) => coerce(decode13(text))
-    });
-  };
-  var decode4 = (string, alphabet, bitsPerChar, name2) => {
-    const codes = {};
-    for (let i = 0; i < alphabet.length; ++i) {
-      codes[alphabet[i]] = i;
-    }
-    let end = string.length;
-    while (string[end - 1] === "=") {
-      --end;
-    }
-    const out = new Uint8Array(end * bitsPerChar / 8 | 0);
-    let bits = 0;
-    let buffer2 = 0;
-    let written = 0;
-    for (let i = 0; i < end; ++i) {
-      const value = codes[string[i]];
-      if (value === void 0) {
-        throw new SyntaxError(`Non-${name2} character`);
-      }
-      buffer2 = buffer2 << bitsPerChar | value;
-      bits += bitsPerChar;
-      if (bits >= 8) {
-        bits -= 8;
-        out[written++] = 255 & buffer2 >> bits;
-      }
-    }
-    if (bits >= bitsPerChar || 255 & buffer2 << 8 - bits) {
-      throw new SyntaxError("Unexpected end of data");
-    }
-    return out;
-  };
-  var encode2 = (data, alphabet, bitsPerChar) => {
-    const pad = alphabet[alphabet.length - 1] === "=";
-    const mask = (1 << bitsPerChar) - 1;
-    let out = "";
-    let bits = 0;
-    let buffer2 = 0;
-    for (let i = 0; i < data.length; ++i) {
-      buffer2 = buffer2 << 8 | data[i];
-      bits += 8;
-      while (bits > bitsPerChar) {
-        bits -= bitsPerChar;
-        out += alphabet[mask & buffer2 >> bits];
-      }
-    }
-    if (bits) {
-      out += alphabet[mask & buffer2 << bitsPerChar - bits];
-    }
-    if (pad) {
-      while (out.length * bitsPerChar & 7) {
-        out += "=";
-      }
-    }
-    return out;
-  };
-  var rfc4648 = ({ name: name2, prefix, bitsPerChar, alphabet }) => {
-    return from({
-      prefix,
-      name: name2,
-      encode(input) {
-        return encode2(input, alphabet, bitsPerChar);
-      },
-      decode(input) {
-        return decode4(input, alphabet, bitsPerChar, name2);
-      }
-    });
-  };
-
-  // node_modules/multiformats/src/bases/base58.js
-  var base58btc = baseX({
-    name: "base58btc",
-    prefix: "z",
-    alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-  });
-  var base58flickr = baseX({
-    name: "base58flickr",
-    prefix: "Z",
-    alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
-  });
-
-  // node_modules/multiformats/src/bases/base32.js
-  var base32 = rfc4648({
-    prefix: "b",
-    name: "base32",
-    alphabet: "abcdefghijklmnopqrstuvwxyz234567",
-    bitsPerChar: 5
-  });
-  var base32upper = rfc4648({
-    prefix: "B",
-    name: "base32upper",
-    alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
-    bitsPerChar: 5
-  });
-  var base32pad = rfc4648({
-    prefix: "c",
-    name: "base32pad",
-    alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
-    bitsPerChar: 5
-  });
-  var base32padupper = rfc4648({
-    prefix: "C",
-    name: "base32padupper",
-    alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
-    bitsPerChar: 5
-  });
-  var base32hex = rfc4648({
-    prefix: "v",
-    name: "base32hex",
-    alphabet: "0123456789abcdefghijklmnopqrstuv",
-    bitsPerChar: 5
-  });
-  var base32hexupper = rfc4648({
-    prefix: "V",
-    name: "base32hexupper",
-    alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
-    bitsPerChar: 5
-  });
-  var base32hexpad = rfc4648({
-    prefix: "t",
-    name: "base32hexpad",
-    alphabet: "0123456789abcdefghijklmnopqrstuv=",
-    bitsPerChar: 5
-  });
-  var base32hexpadupper = rfc4648({
-    prefix: "T",
-    name: "base32hexpadupper",
-    alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
-    bitsPerChar: 5
-  });
-  var base32z = rfc4648({
-    prefix: "h",
-    name: "base32z",
-    alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
-    bitsPerChar: 5
-  });
-
-  // node_modules/multiformats/src/cid.js
-  var format = (link, base3) => {
-    const { bytes, version } = link;
-    switch (version) {
-      case 0:
-        return toStringV0(
-          bytes,
-          baseCache(link),
-          /** @type {API.MultibaseEncoder<"z">} */
-          base3 || base58btc.encoder
-        );
-      default:
-        return toStringV1(
-          bytes,
-          baseCache(link),
-          /** @type {API.MultibaseEncoder<Prefix>} */
-          base3 || base32.encoder
-        );
-    }
-  };
-  var cache = /* @__PURE__ */ new WeakMap();
-  var baseCache = (cid) => {
-    const baseCache3 = cache.get(cid);
-    if (baseCache3 == null) {
-      const baseCache4 = /* @__PURE__ */ new Map();
-      cache.set(cid, baseCache4);
-      return baseCache4;
-    }
-    return baseCache3;
-  };
-  var CID = class _CID {
-    /**
-     * @param {Version} version - Version of the CID
-     * @param {Format} code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
-     * @param {API.MultihashDigest<Alg>} multihash - (Multi)hash of the of the content.
-     * @param {Uint8Array} bytes
-     *
-     */
-    constructor(version, 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;
-    }
-    /**
-     * @returns {CID<Data, API.DAG_PB, API.SHA_256, 0>}
-     */
-    toV0() {
-      switch (this.version) {
-        case 0: {
-          return (
-            /** @type {CID<Data, API.DAG_PB, API.SHA_256, 0>} */
-            this
-          );
-        }
-        case 1: {
-          const { code: 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 (
-            /** @type {CID<Data, API.DAG_PB, API.SHA_256, 0>} */
-            _CID.createV0(
-              /** @type {API.MultihashDigest<API.SHA_256>} */
-              multihash
-            )
-          );
-        }
-        default: {
-          throw Error(
-            `Can not convert CID version ${this.version} to version 0. This is a bug please report`
-          );
-        }
-      }
-    }
-    /**
-     * @returns {CID<Data, Format, Alg, 1>}
-     */
-    toV1() {
-      switch (this.version) {
-        case 0: {
-          const { code: code2, digest } = this.multihash;
-          const multihash = create(code2, digest);
-          return (
-            /** @type {CID<Data, Format, Alg, 1>} */
-            _CID.createV1(this.code, multihash)
-          );
-        }
-        case 1: {
-          return (
-            /** @type {CID<Data, Format, Alg, 1>} */
-            this
-          );
-        }
-        default: {
-          throw Error(
-            `Can not convert CID version ${this.version} to version 1. This is a bug please report`
-          );
-        }
-      }
-    }
-    /**
-     * @param {unknown} other
-     * @returns {other is CID<Data, Format, Alg, Version>}
-     */
-    equals(other) {
-      return _CID.equals(this, other);
-    }
-    /**
-     * @template {unknown} Data
-     * @template {number} Format
-     * @template {number} Alg
-     * @template {API.Version} Version
-     * @param {API.Link<Data, Format, Alg, Version>} self
-     * @param {unknown} other
-     * @returns {other is CID}
-     */
-    static equals(self, other) {
-      const unknown = (
-        /** @type {{code?:unknown, version?:unknown, multihash?:unknown}} */
-        other
-      );
-      return unknown && self.code === unknown.code && self.version === unknown.version && equals2(self.multihash, unknown.multihash);
-    }
-    /**
-     * @param {API.MultibaseEncoder<string>} [base]
-     * @returns {string}
-     */
-    toString(base3) {
-      return format(this, base3);
-    }
-    toJSON() {
-      return { "/": format(this) };
-    }
-    link() {
-      return this;
-    }
-    get [Symbol.toStringTag]() {
-      return "CID";
-    }
-    // Legacy
-    [Symbol.for("nodejs.util.inspect.custom")]() {
-      return `CID(${this.toString()})`;
-    }
-    /**
-     * Takes any input `value` and returns a `CID` instance if it was
-     * a `CID` otherwise returns `null`. If `value` is instanceof `CID`
-     * it will return value back. If `value` is not instance of this CID
-     * class, but is compatible CID it will return new instance of this
-     * `CID` class. Otherwise returns null.
-     *
-     * This allows two different incompatible versions of CID library to
-     * co-exist and interop as long as binary interface is compatible.
-     *
-     * @template {unknown} Data
-     * @template {number} Format
-     * @template {number} Alg
-     * @template {API.Version} Version
-     * @template {unknown} U
-     * @param {API.Link<Data, Format, Alg, Version>|U} input
-     * @returns {CID<Data, Format, Alg, Version>|null}
-     */
-    static asCID(input) {
-      if (input == null) {
-        return null;
-      }
-      const value = (
-        /** @type {any} */
-        input
-      );
-      if (value instanceof _CID) {
-        return value;
-      } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
-        const { version, code: code2, multihash, bytes } = value;
-        return new _CID(
-          version,
-          code2,
-          /** @type {API.MultihashDigest<Alg>} */
-          multihash,
-          bytes || encodeCID(version, code2, multihash.bytes)
-        );
-      } else if (value[cidSymbol] === true) {
-        const { version, multihash, code: code2 } = value;
-        const digest = (
-          /** @type {API.MultihashDigest<Alg>} */
-          decode3(multihash)
-        );
-        return _CID.create(version, code2, digest);
-      } else {
-        return null;
-      }
-    }
-    /**
-     *
-     * @template {unknown} Data
-     * @template {number} Format
-     * @template {number} Alg
-     * @template {API.Version} Version
-     * @param {Version} version - Version of the CID
-     * @param {Format} code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
-     * @param {API.MultihashDigest<Alg>} digest - (Multi)hash of the of the content.
-     * @returns {CID<Data, Format, Alg, Version>}
-     */
-    static create(version, code2, digest) {
-      if (typeof code2 !== "number") {
-        throw new Error("String codecs are no longer supported");
-      }
-      if (!(digest.bytes instanceof Uint8Array)) {
-        throw new Error("Invalid digest");
-      }
-      switch (version) {
-        case 0: {
-          if (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, digest, digest.bytes);
-          }
-        }
-        case 1: {
-          const bytes = encodeCID(version, code2, digest.bytes);
-          return new _CID(version, code2, digest, bytes);
-        }
-        default: {
-          throw new Error("Invalid version");
-        }
-      }
-    }
-    /**
-     * Simplified version of `create` for CIDv0.
-     *
-     * @template {unknown} [T=unknown]
-     * @param {API.MultihashDigest<typeof SHA_256_CODE>} digest - Multihash.
-     * @returns {CID<T, typeof DAG_PB_CODE, typeof SHA_256_CODE, 0>}
-     */
-    static createV0(digest) {
-      return _CID.create(0, DAG_PB_CODE, digest);
-    }
-    /**
-     * Simplified version of `create` for CIDv1.
-     *
-     * @template {unknown} Data
-     * @template {number} Code
-     * @template {number} Alg
-     * @param {Code} code - Content encoding format code.
-     * @param {API.MultihashDigest<Alg>} digest - Miltihash of the content.
-     * @returns {CID<Data, Code, Alg, 1>}
-     */
-    static createV1(code2, digest) {
-      return _CID.create(1, code2, digest);
-    }
-    /**
-     * Decoded a CID from its binary representation. The byte array must contain
-     * only the CID with no additional bytes.
-     *
-     * An error will be thrown if the bytes provided do not contain a valid
-     * binary representation of a CID.
-     *
-     * @template {unknown} Data
-     * @template {number} Code
-     * @template {number} Alg
-     * @template {API.Version} Ver
-     * @param {API.ByteView<API.Link<Data, Code, Alg, Ver>>} bytes
-     * @returns {CID<Data, Code, Alg, Ver>}
-     */
-    static decode(bytes) {
-      const [cid, remainder] = _CID.decodeFirst(bytes);
-      if (remainder.length) {
-        throw new Error("Incorrect length");
-      }
-      return cid;
-    }
-    /**
-     * Decoded a CID from its binary representation at the beginning of a byte
-     * array.
-     *
-     * Returns an array with the first element containing the CID and the second
-     * element containing the remainder of the original byte array. The remainder
-     * will be a zero-length byte array if the provided bytes only contained a
-     * binary CID representation.
-     *
-     * @template {unknown} T
-     * @template {number} C
-     * @template {number} A
-     * @template {API.Version} V
-     * @param {API.ByteView<API.Link<T, C, A, V>>} bytes
-     * @returns {[CID<T, C, A, V>, Uint8Array]}
-     */
-    static decodeFirst(bytes) {
-      const specs = _CID.inspectBytes(bytes);
-      const prefixSize = specs.size - specs.multihashSize;
-      const multihashBytes = coerce(
-        bytes.subarray(prefixSize, prefixSize + specs.multihashSize)
-      );
-      if (multihashBytes.byteLength !== specs.multihashSize) {
-        throw new Error("Incorrect length");
-      }
-      const digestBytes = multihashBytes.subarray(
-        specs.multihashSize - specs.digestSize
-      );
-      const digest = new Digest(
-        specs.multihashCode,
-        specs.digestSize,
-        digestBytes,
-        multihashBytes
-      );
-      const cid = specs.version === 0 ? _CID.createV0(
-        /** @type {API.MultihashDigest<API.SHA_256>} */
-        digest
-      ) : _CID.createV1(specs.codec, digest);
-      return [
-        /** @type {CID<T, C, A, V>} */
-        cid,
-        bytes.subarray(specs.size)
-      ];
-    }
-    /**
-     * Inspect the initial bytes of a CID to determine its properties.
-     *
-     * Involves decoding up to 4 varints. Typically this will require only 4 to 6
-     * bytes but for larger multicodec code values and larger multihash digest
-     * lengths these varints can be quite large. It is recommended that at least
-     * 10 bytes be made available in the `initialBytes` argument for a complete
-     * inspection.
-     *
-     * @template {unknown} T
-     * @template {number} C
-     * @template {number} A
-     * @template {API.Version} V
-     * @param {API.ByteView<API.Link<T, C, A, V>>} initialBytes
-     * @returns {{ version:V, codec:C, multihashCode:A, digestSize:number, multihashSize:number, size:number }}
-     */
-    static inspectBytes(initialBytes) {
-      let offset = 0;
-      const next = () => {
-        const [i, length3] = decode2(initialBytes.subarray(offset));
-        offset += length3;
-        return i;
-      };
-      let version = (
-        /** @type {V} */
-        next()
-      );
-      let codec = (
-        /** @type {C} */
-        DAG_PB_CODE
-      );
-      if (
-        /** @type {number} */
-        version === 18
-      ) {
-        version = /** @type {V} */
-        0;
-        offset = 0;
-      } else {
-        codec = /** @type {C} */
-        next();
-      }
-      if (version !== 0 && version !== 1) {
-        throw new RangeError(`Invalid CID version ${version}`);
-      }
-      const prefixSize = offset;
-      const multihashCode = (
-        /** @type {A} */
-        next()
-      );
-      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).
-     *
-     * @template {string} Prefix
-     * @template {unknown} Data
-     * @template {number} Code
-     * @template {number} Alg
-     * @template {API.Version} Ver
-     * @param {API.ToString<API.Link<Data, Code, Alg, Ver>, Prefix>} source
-     * @param {API.MultibaseDecoder<Prefix>} [base]
-     * @returns {CID<Data, Code, Alg, Ver>}
-     */
-    static parse(source, 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;
-    }
-  };
-  var parseCIDtoBytes = (source, base3) => {
-    switch (source[0]) {
-      case "Q": {
-        const decoder = base3 || base58btc;
-        return [
-          /** @type {Prefix} */
-          base58btc.prefix,
-          decoder.decode(`${base58btc.prefix}${source}`)
-        ];
-      }
-      case base58btc.prefix: {
-        const decoder = base3 || base58btc;
-        return [
-          /** @type {Prefix} */
-          base58btc.prefix,
-          decoder.decode(source)
-        ];
-      }
-      case base32.prefix: {
-        const decoder = base3 || base32;
-        return [
-          /** @type {Prefix} */
-          base32.prefix,
-          decoder.decode(source)
-        ];
-      }
-      default: {
-        if (base3 == null) {
-          throw Error(
-            "To parse non base32 or base58btc encoded CID multibase decoder must be provided"
-          );
-        }
-        return [
-          /** @type {Prefix} */
-          source[0],
-          base3.decode(source)
-        ];
-      }
-    }
-  };
-  var toStringV0 = (bytes, cache3, base3) => {
-    const { prefix } = base3;
-    if (prefix !== base58btc.prefix) {
-      throw Error(`Cannot string encode V0 in ${base3.name} encoding`);
-    }
-    const cid = cache3.get(prefix);
-    if (cid == null) {
-      const cid2 = base3.encode(bytes).slice(1);
-      cache3.set(prefix, cid2);
-      return cid2;
-    } else {
-      return cid;
-    }
-  };
-  var toStringV1 = (bytes, cache3, base3) => {
-    const { prefix } = base3;
-    const cid = cache3.get(prefix);
-    if (cid == null) {
-      const cid2 = base3.encode(bytes);
-      cache3.set(prefix, cid2);
-      return cid2;
-    } else {
-      return cid;
-    }
-  };
-  var DAG_PB_CODE = 112;
-  var SHA_256_CODE = 18;
-  var 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 cidSymbol = Symbol.for("@ipld/js-cid/CID");
-
-  // node_modules/multiformats/src/hashes/hasher.js
-  var from2 = ({ name: name2, code: code2, encode: encode9 }) => new Hasher(name2, code2, encode9);
-  var Hasher = class {
-    /**
-     *
-     * @param {Name} name
-     * @param {Code} code
-     * @param {(input: Uint8Array) => Await<Uint8Array>} encode
-     */
-    constructor(name2, code2, encode9) {
-      this.name = name2;
-      this.code = code2;
-      this.encode = encode9;
-    }
-    /**
-     * @param {Uint8Array} input
-     * @returns {Await<Digest.Digest<Code, number>>}
-     */
-    digest(input) {
-      if (input instanceof Uint8Array) {
-        const result = this.encode(input);
-        return result instanceof Uint8Array ? create(this.code, result) : result.then((digest) => create(this.code, digest));
-      } else {
-        throw Error("Unknown type, must be binary type");
-      }
-    }
-  };
-
-  // node_modules/multiformats/src/block.js
-  function readonly({ enumerable = true, configurable = false } = {}) {
-    return { enumerable, configurable, writable: false };
-  }
-  function* linksWithin(path, value) {
-    if (value != null && typeof value === "object") {
-      if (Array.isArray(value)) {
-        for (const [index, element] of value.entries()) {
-          const elementPath = [...path, index];
-          const cid = CID.asCID(element);
-          if (cid) {
-            yield [elementPath.join("/"), cid];
-          } else if (typeof element === "object") {
-            yield* __yieldStar(links(element, elementPath));
-          }
-        }
-      } else {
-        const cid = CID.asCID(value);
-        if (cid) {
-          yield [path.join("/"), cid];
-        } else {
-          yield* __yieldStar(links(value, path));
-        }
-      }
-    }
-  }
-  function* links(source, base3) {
-    if (source == null || source instanceof Uint8Array) {
-      return;
-    }
-    const cid = CID.asCID(source);
-    if (cid) {
-      yield [base3.join("/"), cid];
-    }
-    for (const [key, value] of Object.entries(source)) {
-      const path = (
-        /** @type {[string|number, string]} */
-        [...base3, key]
-      );
-      yield* __yieldStar(linksWithin(path, value));
-    }
-  }
-  function* treeWithin(path, value) {
-    if (Array.isArray(value)) {
-      for (const [index, element] of value.entries()) {
-        const elementPath = [...path, index];
-        yield elementPath.join("/");
-        if (typeof element === "object" && !CID.asCID(element)) {
-          yield* __yieldStar(tree(element, elementPath));
-        }
-      }
-    } else {
-      yield* __yieldStar(tree(value, path));
-    }
-  }
-  function* tree(source, base3) {
-    if (source == null || typeof source !== "object") {
-      return;
-    }
-    for (const [key, value] of Object.entries(source)) {
-      const path = (
-        /** @type {[string|number, string]} */
-        [...base3, key]
-      );
-      yield path.join("/");
-      if (value != null && !(value instanceof Uint8Array) && typeof value === "object" && !CID.asCID(value)) {
-        yield* __yieldStar(treeWithin(path, value));
-      }
-    }
-  }
-  function get(source, path) {
-    let node = (
-      /** @type {Record<string, any>} */
-      source
-    );
-    for (const [index, key] of path.entries()) {
-      node = node[key];
-      if (node == null) {
-        throw new Error(`Object has no property at ${path.slice(0, index + 1).map((part) => `[${JSON.stringify(part)}]`).join("")}`);
-      }
-      const cid = CID.asCID(node);
-      if (cid) {
-        return { value: cid, remaining: path.slice(index + 1).join("/") };
-      }
-    }
-    return { value: node };
-  }
-  var Block = class {
-    /**
-     * @param {object} options
-     * @param {CID<T, C, A, V>} options.cid
-     * @param {API.ByteView<T>} options.bytes
-     * @param {T} options.value
-     */
-    constructor({ cid, bytes, value }) {
-      if (!cid || !bytes || typeof value === "undefined") {
-        throw new Error("Missing required argument");
-      }
-      this.cid = cid;
-      this.bytes = bytes;
-      this.value = value;
-      this.asBlock = this;
-      Object.defineProperties(this, {
-        cid: readonly(),
-        bytes: readonly(),
-        value: readonly(),
-        asBlock: readonly()
-      });
-    }
-    links() {
-      return links(this.value, []);
-    }
-    tree() {
-      return tree(this.value, []);
-    }
-    /**
-     *
-     * @param {string} [path]
-     * @returns {API.BlockCursorView<unknown>}
-     */
-    get(path = "/") {
-      return get(this.value, path.split("/").filter(Boolean));
-    }
-  };
-  function encode3(_0) {
-    return __async(this, arguments, function* ({ value, codec, hasher }) {
-      if (typeof value === "undefined")
-        throw new Error('Missing required argument "value"');
-      if (!codec || !hasher)
-        throw new Error("Missing required argument: codec or hasher");
-      const bytes = codec.encode(value);
-      const hash = yield hasher.digest(bytes);
-      const cid = CID.create(
-        1,
-        codec.code,
-        hash
-      );
-      return new Block({ value, bytes, cid });
-    });
-  }
-  function decode5(_0) {
-    return __async(this, arguments, function* ({ bytes, codec, hasher }) {
-      if (!bytes)
-        throw new Error('Missing required argument "bytes"');
-      if (!codec || !hasher)
-        throw new Error("Missing required argument: codec or hasher");
-      const value = codec.decode(bytes);
-      const hash = yield hasher.digest(bytes);
-      const cid = CID.create(1, codec.code, hash);
-      return new Block({ value, bytes, cid });
-    });
-  }
-  function createUnsafe({ bytes, cid, value: maybeValue, codec }) {
-    const value = maybeValue !== void 0 ? maybeValue : codec && codec.decode(bytes);
-    if (value === void 0)
-      throw new Error('Missing required argument, must either provide "value" or "codec"');
-    return new Block({
-      // eslint-disable-next-line object-shorthand
-      cid: (
-        /** @type {CID<T, Code, Alg, V>} */
-        cid
-      ),
-      bytes,
-      value
-    });
-  }
-  function create2(_0) {
-    return __async(this, arguments, function* ({ bytes, cid, hasher, codec }) {
-      if (!bytes)
-        throw new Error('Missing required argument "bytes"');
-      if (!hasher)
-        throw new Error('Missing required argument "hasher"');
-      const value = codec.decode(bytes);
-      const hash = yield hasher.digest(bytes);
-      if (!bytes_exports.equals(cid.multihash.bytes, hash.bytes)) {
-        throw new Error("CID hash does not match bytes");
-      }
-      return createUnsafe({
-        bytes,
-        cid,
-        value,
-        codec
-      });
-    });
-  }
-
-  // node_modules/multiformats/src/hashes/sha2-browser.js
-  var sha = (name2) => (
-    /**
-     * @param {Uint8Array} data
-     */
-    (data) => __async(void 0, null, function* () {
-      return new Uint8Array(yield crypto.subtle.digest(name2, data));
-    })
-  );
-  var sha256 = from2({
-    name: "sha2-256",
-    code: 18,
-    encode: sha("SHA-256")
-  });
-  var sha512 = from2({
-    name: "sha2-512",
-    code: 19,
-    encode: sha("SHA-512")
-  });
-
-  // node_modules/@ipld/dag-cbor/src/index.js
-  var src_exports = {};
-  __export(src_exports, {
-    code: () => code,
-    decode: () => decode7,
-    encode: () => encode5,
-    name: () => name
-  });
-
-  // node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/is.js
-  var typeofs = [
-    "string",
-    "number",
-    "bigint",
-    "symbol"
-  ];
-  var objectTypeNames = [
-    "Function",
-    "Generator",
-    "AsyncGenerator",
-    "GeneratorFunction",
-    "AsyncGeneratorFunction",
-    "AsyncFunction",
-    "Observable",
-    "Array",
-    "Buffer",
-    "Object",
-    "RegExp",
-    "Date",
-    "Error",
-    "Map",
-    "Set",
-    "WeakMap",
-    "WeakSet",
-    "ArrayBuffer",
-    "SharedArrayBuffer",
-    "DataView",
-    "Promise",
-    "URL",
-    "HTMLElement",
-    "Int8Array",
-    "Uint8Array",
-    "Uint8ClampedArray",
-    "Int16Array",
-    "Uint16Array",
-    "Int32Array",
-    "Uint32Array",
-    "Float32Array",
-    "Float64Array",
-    "BigInt64Array",
-    "BigUint64Array"
-  ];
-  function is(value) {
-    if (value === null) {
-      return "null";
-    }
-    if (value === void 0) {
-      return "undefined";
-    }
-    if (value === true || value === false) {
-      return "boolean";
-    }
-    const typeOf = typeof value;
-    if (typeofs.includes(typeOf)) {
-      return typeOf;
-    }
-    if (typeOf === "function") {
-      return "Function";
-    }
-    if (Array.isArray(value)) {
-      return "Array";
-    }
-    if (isBuffer(value)) {
-      return "Buffer";
-    }
-    const objectType = getObjectType(value);
-    if (objectType) {
-      return objectType;
-    }
-    return "Object";
-  }
-  function isBuffer(value) {
-    return value && value.constructor && value.constructor.isBuffer && value.constructor.isBuffer.call(null, value);
-  }
-  function getObjectType(value) {
-    const objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
-    if (objectTypeNames.includes(objectTypeName)) {
-      return objectTypeName;
-    }
-    return void 0;
-  }
-
-  // node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/token.js
-  var Type = class {
-    constructor(major, name2, terminal) {
-      this.major = major;
-      this.majorEncoded = major << 5;
-      this.name = name2;
-      this.terminal = terminal;
-    }
-    toString() {
-      return `Type[${this.major}].${this.name}`;
-    }
-    compare(typ) {
-      return this.major < typ.major ? -1 : this.major > typ.major ? 1 : 0;
-    }
-  };
-  Type.uint = new Type(0, "uint", true);
-  Type.negint = new Type(1, "negint", true);
-  Type.bytes = new Type(2, "bytes", true);
-  Type.string = new Type(3, "string", true);
-  Type.array = new Type(4, "array", false);
-  Type.map = new Type(5, "map", false);
-  Type.tag = new Type(6, "tag", false);
-  Type.float = new Type(7, "float", true);
-  Type.false = new Type(7, "false", true);
-  Type.true = new Type(7, "true", true);
-  Type.null = new Type(7, "null", true);
-  Type.undefined = new Type(7, "undefined", true);
-  Type.break = new Type(7, "break", true);
-  var Token = class {
-    constructor(type, value, encodedLength) {
-      this.type = type;
-      this.value = value;
-      this.encodedLength = encodedLength;
-      this.encodedBytes = void 0;
-      this.byteValue = void 0;
-    }
-    toString() {
-      return `Token[${this.type}].${this.value}`;
-    }
-  };
-
-  // node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/byte-utils.js
-  var useBuffer = globalThis.process && !globalThis.process.browser && globalThis.Buffer && typeof globalThis.Buffer.isBuffer === "function";
-  var textDecoder = new TextDecoder();
-  var textEncoder = new TextEncoder();
-  function isBuffer2(buf2) {
-    return useBuffer && globalThis.Buffer.isBuffer(buf2);
-  }
-  function asU8A(buf2) {
-    if (!(buf2 instanceof Uint8Array)) {
-      return Uint8Array.from(buf2);
-    }
-    return isBuffer2(buf2) ? new Uint8Array(buf2.buffer, buf2.byteOffset, buf2.byteLength) : buf2;
-  }
-  var toString2 = useBuffer ? (bytes, start, end) => {
-    return end - start > 64 ? globalThis.Buffer.from(bytes.subarray(start, end)).toString("utf8") : utf8Slice(bytes, start, end);
-  } : (bytes, start, end) => {
-    return end - start > 64 ? textDecoder.decode(bytes.subarray(start, end)) : utf8Slice(bytes, start, end);
-  };
-  var fromString2 = useBuffer ? (string) => {
-    return string.length > 64 ? globalThis.Buffer.from(string) : utf8ToBytes(string);
-  } : (string) => {
-    return string.length > 64 ? textEncoder.encode(string) : utf8ToBytes(string);
-  };
-  var fromArray = (arr) => {
-    return Uint8Array.from(arr);
-  };
-  var slice = useBuffer ? (bytes, start, end) => {
-    if (isBuffer2(bytes)) {
-      return new Uint8Array(bytes.subarray(start, end));
-    }
-    return bytes.slice(start, end);
-  } : (bytes, start, end) => {
-    return bytes.slice(start, end);
-  };
-  var concat = useBuffer ? (chunks, length3) => {
-    chunks = chunks.map((c) => c instanceof Uint8Array ? c : globalThis.Buffer.from(c));
-    return asU8A(globalThis.Buffer.concat(chunks, length3));
-  } : (chunks, length3) => {
-    const out = new Uint8Array(length3);
-    let off = 0;
-    for (let b of chunks) {
-      if (off + b.length > out.length) {
-        b = b.subarray(0, out.length - off);
-      }
-      out.set(b, off);
-      off += b.length;
-    }
-    return out;
-  };
-  var alloc = useBuffer ? (size) => {
-    return globalThis.Buffer.allocUnsafe(size);
-  } : (size) => {
-    return new Uint8Array(size);
-  };
-  function compare(b1, b2) {
-    if (isBuffer2(b1) && isBuffer2(b2)) {
-      return b1.compare(b2);
-    }
-    for (let i = 0; i < b1.length; i++) {
-      if (b1[i] === b2[i]) {
-        continue;
-      }
-      return b1[i] < b2[i] ? -1 : 1;
-    }
-    return 0;
-  }
-  function utf8ToBytes(string, units = Infinity) {
-    let codePoint;
-    const length3 = string.length;
-    let leadSurrogate = null;
-    const bytes = [];
-    for (let i = 0; i < length3; ++i) {
-      codePoint = string.charCodeAt(i);
-      if (codePoint > 55295 && codePoint < 57344) {
-        if (!leadSurrogate) {
-          if (codePoint > 56319) {
-            if ((units -= 3) > -1)
-              bytes.push(239, 191, 189);
-            continue;
-          } else if (i + 1 === length3) {
-            if ((units -= 3) > -1)
-              bytes.push(239, 191, 189);
-            continue;
-          }
-          leadSurrogate = codePoint;
-          continue;
-        }
-        if (codePoint < 56320) {
-          if ((units -= 3) > -1)
-            bytes.push(239, 191, 189);
-          leadSurrogate = codePoint;
-          continue;
-        }
-        codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
-      } else if (leadSurrogate) {
-        if ((units -= 3) > -1)
-          bytes.push(239, 191, 189);
-      }
-      leadSurrogate = null;
-      if (codePoint < 128) {
-        if ((units -= 1) < 0)
-          break;
-        bytes.push(codePoint);
-      } else if (codePoint < 2048) {
-        if ((units -= 2) < 0)
-          break;
-        bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128);
-      } else if (codePoint < 65536) {
-        if ((units -= 3) < 0)
-          break;
-        bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
-      } else if (codePoint < 1114112) {
-        if ((units -= 4) < 0)
-          break;
-        bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
-      } else {
-        throw new Error("Invalid code point");
-      }
-    }
-    return bytes;
-  }
-  function utf8Slice(buf2, offset, end) {
-    const res = [];
-    while (offset < end) {
-      const firstByte = buf2[offset];
-      let codePoint = null;
-      let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
-      if (offset + bytesPerSequence <= end) {
-        let secondByte, thirdByte, fourthByte, tempCodePoint;
-        switch (bytesPerSequence) {
-          case 1:
-            if (firstByte < 128) {
-              codePoint = firstByte;
-            }
-            break;
-          case 2:
-            secondByte = buf2[offset + 1];
-            if ((secondByte & 192) === 128) {
-              tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
-              if (tempCodePoint > 127) {
-                codePoint = tempCodePoint;
-              }
-            }
-            break;
-          case 3:
-            secondByte = buf2[offset + 1];
-            thirdByte = buf2[offset + 2];
-            if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
-              tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
-              if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
-                codePoint = tempCodePoint;
-              }
-            }
-            break;
-          case 4:
-            secondByte = buf2[offset + 1];
-            thirdByte = buf2[offset + 2];
-            fourthByte = buf2[offset + 3];
-            if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
-              tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
-              if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
-                codePoint = tempCodePoint;
-              }
-            }
-        }
-      }
-      if (codePoint === null) {
-        codePoint = 65533;
-        bytesPerSequence = 1;
-      } else if (codePoint > 65535) {
-        codePoint -= 65536;
-        res.push(codePoint >>> 10 & 1023 | 55296);
-        codePoint = 56320 | codePoint & 1023;
-      }
-      res.push(codePoint);
-      offset += bytesPerSequence;
-    }
-    return decodeCodePointsArray(res);
-  }
-  var MAX_ARGUMENTS_LENGTH = 4096;
-  function decodeCodePointsArray(codePoints) {
-    const len = codePoints.length;
-    if (len <= MAX_ARGUMENTS_LENGTH) {
-      return String.fromCharCode.apply(String, codePoints);
-    }
-    let res = "";
-    let i = 0;
-    while (i < len) {
-      res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
-    }
-    return res;
-  }
-
-  // node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/bl.js
-  var defaultChunkSize = 256;
-  var Bl = class {
-    constructor(chunkSize = defaultChunkSize) {
-      this.chunkSize = chunkSize;
-      this.cursor = 0;
-      this.maxCursor = -1;
-      this.chunks = [];
-      this._initReuseChunk = null;
-    }
-    reset() {
-      this.cursor = 0;
-      this.maxCursor = -1;
-      if (this.chunks.length) {
-        this.chunks = [];
-      }
-      if (this._initReuseChunk !== null) {
-        this.chunks.push(this._initReuseChunk);
-        this.maxCursor = this._initReuseChunk.length - 1;
-      }
-    }
-    push(bytes) {
-      let topChunk = this.chunks[this.chunks.length - 1];
-      const newMax = this.cursor + bytes.length;
-      if (newMax <= this.maxCursor + 1) {
-        const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
-        topChunk.set(bytes, chunkPos);
-      } else {
-        if (topChunk) {
-          const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
-          if (chunkPos < topChunk.length) {
-            this.chunks[this.chunks.length - 1] = topChunk.subarray(0, chunkPos);
-            this.maxCursor = this.cursor - 1;
-          }
-        }
-        if (bytes.length < 64 && bytes.length < this.chunkSize) {
-          topChunk = alloc(this.chunkSize);
-          this.chunks.push(topChunk);
-          this.maxCursor += topChunk.length;
-          if (this._initReuseChunk === null) {
-            this._initReuseChunk = topChunk;
-          }
-          topChunk.set(bytes, 0);
-        } else {
-          this.chunks.push(bytes);
-          this.maxCursor += bytes.length;
-        }
-      }
-      this.cursor += bytes.length;
-    }
-    toBytes(reset = false) {
-      let byts;
-      if (this.chunks.length === 1) {
-        const chunk = this.chunks[0];
-        if (reset && this.cursor > chunk.length / 2) {
-          byts = this.cursor === chunk.length ? chunk : chunk.subarray(0, this.cursor);
-          this._initReuseChunk = null;
-          this.chunks = [];
-        } else {
-          byts = slice(chunk, 0, this.cursor);
-        }
-      } else {
-        byts = concat(this.chunks, this.cursor);
-      }
-      if (reset) {
-        this.reset();
-      }
-      return byts;
-    }
-  };
-
-  // node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/common.js
-  var decodeErrPrefix = "CBOR decode error:";
-  var encodeErrPrefix = "CBOR encode error:";
-  var uintMinorPrefixBytes = [];
-  uintMinorPrefixBytes[23] = 1;
-  uintMinorPrefixBytes[24] = 2;
-  uintMinorPrefixBytes[25] = 3;
-  uintMinorPrefixBytes[26] = 5;
-  uintMinorPrefixBytes[27] = 9;
-  function assertEnoughData(data, pos, need) {
-    if (data.length - pos < need) {
-      throw new Error(`${decodeErrPrefix} not enough data for type`);
-    }
-  }
-
-  // node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/0uint.js
-  var uintBoundaries = [
-    24,
-    256,
-    65536,
-    4294967296,
-    BigInt("18446744073709551616")
-  ];
-  function readUint8(data, offset, options) {
-    assertEnoughData(data, offset, 1);
-    const value = data[offset];
-    if (options.strict === true && value < uintBoundaries[0]) {
-      throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
-    }
-    return value;
-  }
-  function readUint16(data, offset, options) {
-    assertEnoughData(data, offset, 2);
-    const value = data[offset] << 8 | data[offset + 1];
-    if (options.strict === true && value < uintBoundaries[1]) {
-      throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
-    }
-    return value;
-  }
-  function readUint32(data, offset, options) {
-    assertEnoughData(data, offset, 4);
-    const value = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
-    if (options.strict === true && value < uintBoundaries[2]) {
-      throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
-    }
-    return value;
-  }
-  function readUint64(data, offset, options) {
-    assertEnoughData(data, offset, 8);
-    const hi = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
-    const lo = data[offset + 4] * 16777216 + (data[offset + 5] << 16) + (data[offset + 6] << 8) + data[offset + 7];
-    const value = (BigInt(hi) << BigInt(32)) + BigInt(lo);
-    if (options.strict === true && value < uintBoundaries[3]) {
-      throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
-    }
-    if (value <= Number.MAX_SAFE_INTEGER) {
-      return Number(value);
-    }
-    if (options.allowBigInt === true) {
-      return value;
-    }
-    throw new Error(`${decodeErrPrefix} integers outside of the safe integer range are not supported`);
-  }
-  function decodeUint8(data, pos, _minor, options) {
-    return new Token(Type.uint, readUint8(data, pos + 1, options), 2);
-  }
-  function decodeUint16(data, pos, _minor, options) {
-    return new Token(Type.uint, readUint16(data, pos + 1, options), 3);
-  }
-  function decodeUint32(data, pos, _minor, options) {
-    return new Token(Type.uint, readUint32(data, pos + 1, options), 5);
-  }
-  function decodeUint64(data, pos, _minor, options) {
-    return new Token(Type.uint, readUint64(data, pos + 1, options), 9);
-  }
-  function encodeUint(buf2, token) {
-    return encodeUintValue(buf2, 0, token.value);
-  }
-  function encodeUintValue(buf2, major, uint) {
-    if (uint < uintBoundaries[0]) {
-      const nuint = Number(uint);
-      buf2.push([major | nuint]);
-    } else if (uint < uintBoundaries[1]) {
-      const nuint = Number(uint);
-      buf2.push([
-        major | 24,
-        nuint
-      ]);
-    } else if (uint < uintBoundaries[2]) {
-      const nuint = Number(uint);
-      buf2.push([
-        major | 25,
-        nuint >>> 8,
-        nuint & 255
-      ]);
-    } else if (uint < uintBoundaries[3]) {
-      const nuint = Number(uint);
-      buf2.push([
-        major | 26,
-        nuint >>> 24 & 255,
-        nuint >>> 16 & 255,
-        nuint >>> 8 & 255,
-        nuint & 255
-      ]);
-    } else {
-      const buint = BigInt(uint);
-      if (buint < uintBoundaries[4]) {
-        const set = [
-          major | 27,
-          0,
-          0,
-          0,
-          0,
-          0,
-          0,
-          0
-        ];
-        let lo = Number(buint & BigInt(4294967295));
-        let hi = Number(buint >> BigInt(32) & BigInt(4294967295));
-        set[8] = lo & 255;
-        lo = lo >> 8;
-        set[7] = lo & 255;
-        lo = lo >> 8;
-        set[6] = lo & 255;
-        lo = lo >> 8;
-        set[5] = lo & 255;
-        set[4] = hi & 255;
-        hi = hi >> 8;
-        set[3] = hi & 255;
-        hi = hi >> 8;
-        set[2] = hi & 255;
-        hi = hi >> 8;
-        set[1] = hi & 255;
-        buf2.push(set);
-      } else {
-        throw new Error(`${decodeErrPrefix} encountered BigInt larger than allowable range`);
-      }
-    }
-  }
-  encodeUint.encodedSize = function encodedSize(token) {
-    return encodeUintValue.encodedSize(token.value);
-  };
-  encodeUintValue.encodedSize = function encodedSize2(uint) {
-    if (uint < uintBoundaries[0]) {
-      return 1;
-    }
-    if (uint < uintBoundaries[1]) {
-      return 2;
-    }
-    if (uint < uintBoundaries[2]) {
-      return 3;
-    }
-    if (uint < uintBoundaries[3]) {
-      return 5;
-    }
-    return 9;
-  };
-  encodeUint.compareTokens = function compareTokens(tok1, tok2) {
-    return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : 0;
-  };
-
-  // node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/1negint.js
-  function decodeNegint8(data, pos, _minor, options) {
-    return new Token(Type.negint, -1 - readUint8(data, pos + 1, options), 2);
-  }
-  function decodeNegint16(data, pos, _minor, options) {
-    return new Token(Type.negint, -1 - readUint16(data, pos + 1, options), 3);
-  }
-  function decodeNegint32(data, pos, _minor, options) {
-    return new Token(Type.negint, -1 - readUint32(data, pos + 1, options), 5);
-  }
-  var neg1b = BigInt(-1);
-  var pos1b = BigInt(1);
-  function decodeNegint64(data, pos, _minor, options) {
-    const int = readUint64(data, pos + 1, options);
-    if (typeof int !== "bigint") {
-      const value = -1 - int;
-      if (value >= Number.MIN_SAFE_INTEGER) {
-        return new Token(Type.negint, value, 9);
-      }
-    }
-    if (options.allowBigInt !== true) {
-      throw new Error(`${decodeErrPrefix} integers outside of the safe integer range are not supported`);
-    }
-    return new Token(Type.negint, neg1b - BigInt(int), 9);
-  }
-  function encodeNegint(buf2, token) {
-    const negint = token.value;
-    const unsigned = typeof negint === "bigint" ? negint * neg1b - pos1b : negint * -1 - 1;
-    encodeUintValue(buf2, token.type.majorEncoded, unsigned);
-  }
-  encodeNegint.encodedSize = function encodedSize3(token) {
-    const negint = token.value;
-    const unsigned = typeof negint === "bigint" ? negint * neg1b - pos1b : negint * -1 - 1;
-    if (unsigned < uintBoundaries[0]) {
-      return 1;
-    }
-    if (unsigned < uintBoundaries[1]) {
-      return 2;
-    }
-    if (unsigned < uintBoundaries[2]) {
-      return 3;
-    }
-    if (unsigned < uintBoundaries[3]) {
-      return 5;
-    }
-    return 9;
-  };
-  encodeNegint.compareTokens = function compareTokens2(tok1, tok2) {
-    return tok1.value < tok2.value ? 1 : tok1.value > tok2.value ? -1 : 0;
-  };
-
-  // node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/2bytes.js
-  function toToken(data, pos, prefix, length3) {
-    assertEnoughData(data, pos, prefix + length3);
-    const buf2 = slice(data, pos + prefix, pos + prefix + length3);
-    return new Token(Type.bytes, buf2, prefix + length3);
-  }
-  function decodeBytesCompact(data, pos, minor, _options) {
-    return toToken(data, pos, 1, minor);
-  }
-  function decodeBytes8(data, pos, _minor, options) {
-    return toToken(data, pos, 2, readUint8(data, pos + 1, options));
-  }
-  function decodeBytes16(data, pos, _minor, options) {
-    return toToken(data, pos, 3, readUint16(data, pos + 1, options));
-  }
-  function decodeBytes32(data, pos, _minor, options) {
-    return toToken(data, pos, 5, readUint32(data, pos + 1, options));
-  }
-  function decodeBytes64(data, pos, _minor, options) {
-    const l = readUint64(data, pos + 1, options);
-    if (typeof l === "bigint") {
-      throw new Error(`${decodeErrPrefix} 64-bit integer bytes lengths not supported`);
-    }
-    return toToken(data, pos, 9, l);
-  }
-  function tokenBytes(token) {
-    if (token.encodedBytes === void 0) {
-      token.encodedBytes = token.type === Type.string ? fromString2(token.value) : token.value;
-    }
-    return token.encodedBytes;
-  }
-  function encodeBytes(buf2, token) {
-    const bytes = tokenBytes(token);
-    encodeUintValue(buf2, token.type.majorEncoded, bytes.length);
-    buf2.push(bytes);
-  }
-  encodeBytes.encodedSize = function encodedSize4(token) {
-    const bytes = tokenBytes(token);
-    return encodeUintValue.encodedSize(bytes.length) + bytes.length;
-  };
-  encodeBytes.compareTokens = function compareTokens3(tok1, tok2) {
-    return compareBytes(tokenBytes(tok1), tokenBytes(tok2));
-  };
-  function compareBytes(b1, b2) {
-    return b1.length < b2.length ? -1 : b1.length > b2.length ? 1 : compare(b1, b2);
-  }
-
-  // node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/3string.js
-  function toToken2(data, pos, prefix, length3, options) {
-    const totLength = prefix + length3;
-    assertEnoughData(data, pos, totLength);
-    const tok = new Token(Type.string, toString2(data, pos + prefix, pos + totLength), totLength);
-    if (options.retainStringBytes === true) {
-      tok.byteValue = slice(data, pos + prefix, pos + totLength);
-    }
-    return tok;
-  }
-  function decodeStringCompact(data, pos, minor, options) {
-    return toToken2(data, pos, 1, minor, options);
-  }
-  function decodeString8(data, pos, _minor, options) {
-    return toToken2(data, pos, 2, readUint8(data, pos + 1, options), options);
-  }
-  function decodeString16(data, pos, _minor, options) {
-    return toToken2(data, pos, 3, readUint16(data, pos + 1, options), options);
-  }
-  function decodeString32(data, pos, _minor, options) {
-    return toToken2(data, pos, 5, readUint32(data, pos + 1, options), options);
-  }
-  function decodeString64(data, pos, _minor, options) {
-    const l = readUint64(data, pos + 1, options);
-    if (typeof l === "bigint") {
-      throw new Error(`${decodeErrPrefix} 64-bit integer string lengths not supported`);
-    }
-    return toToken2(data, pos, 9, l, options);
-  }
-  var encodeString = encodeBytes;
-
-  // node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/4array.js
-  function toToken3(_data, _pos, prefix, length3) {
-    return new Token(Type.array, length3, prefix);
-  }
-  function decodeArrayCompact(data, pos, minor, _options) {
-    return toToken3(data, pos, 1, minor);
-  }
-  function decodeArray8(data, pos, _minor, options) {
-    return toToken3(data, pos, 2, readUint8(data, pos + 1, options));
-  }
-  function decodeArray16(data, pos, _minor, options) {
-    return toToken3(data, pos, 3, readUint16(data, pos + 1, options));
-  }
-  function decodeArray32(data, pos, _minor, options) {
-    return toToken3(data, pos, 5, readUint32(data, pos + 1, options));
-  }
-  function decodeArray64(data, pos, _minor, options) {
-    const l = readUint64(data, pos + 1, options);
-    if (typeof l === "bigint") {
-      throw new Error(`${decodeErrPrefix} 64-bit integer array lengths not supported`);
-    }
-    return toToken3(data, pos, 9, l);
-  }
-  function decodeArrayIndefinite(data, pos, _minor, options) {
-    if (options.allowIndefinite === false) {
-      throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
-    }
-    return toToken3(data, pos, 1, Infinity);
-  }
-  function encodeArray(buf2, token) {
-    encodeUintValue(buf2, Type.array.majorEncoded, token.value);
-  }
-  encodeArray.compareTokens = encodeUint.compareTokens;
-  encodeArray.encodedSize = function encodedSize5(token) {
-    return encodeUintValue.encodedSize(token.value);
-  };
-
-  // node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/5map.js
-  function toToken4(_data, _pos, prefix, length3) {
-    return new Token(Type.map, length3, prefix);
-  }
-  function decodeMapCompact(data, pos, minor, _options) {
-    return toToken4(data, pos, 1, minor);
-  }
-  function decodeMap8(data, pos, _minor, options) {
-    return toToken4(data, pos, 2, readUint8(data, pos + 1, options));
-  }
-  function decodeMap16(data, pos, _minor, options) {
-    return toToken4(data, pos, 3, readUint16(data, pos + 1, options));
-  }
-  function decodeMap32(data, pos, _minor, options) {
-    return toToken4(data, pos, 5, readUint32(data, pos + 1, options));
-  }
-  function decodeMap64(data, pos, _minor, options) {
-    const l = readUint64(data, pos + 1, options);
-    if (typeof l === "bigint") {
-      throw new Error(`${decodeErrPrefix} 64-bit integer map lengths not supported`);
-    }
-    return toToken4(data, pos, 9, l);
-  }
-  function decodeMapIndefinite(data, pos, _minor, options) {
-    if (options.allowIndefinite === false) {
-      throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
-    }
-    return toToken4(data, pos, 1, Infinity);
-  }
-  function encodeMap(buf2, token) {
-    encodeUintValue(buf2, Type.map.majorEncoded, token.value);
-  }
-  encodeMap.compareTokens = encodeUint.compareTokens;
-  encodeMap.encodedSize = function encodedSize6(token) {
-    return encodeUintValue.encodedSize(token.value);
-  };
-
-  // node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/6tag.js
-  function decodeTagCompact(_data, _pos, minor, _options) {
-    return new Token(Type.tag, minor, 1);
-  }
-  function decodeTag8(data, pos, _minor, options) {
-    return new Token(Type.tag, readUint8(data, pos + 1, options), 2);
-  }
-  function decodeTag16(data, pos, _minor, options) {
-    return new Token(Type.tag, readUint16(data, pos + 1, options), 3);
-  }
-  function decodeTag32(data, pos, _minor, options) {
-    return new Token(Type.tag, readUint32(data, pos + 1, options), 5);
-  }
-  function decodeTag64(data, pos, _minor, options) {
-    return new Token(Type.tag, readUint64(data, pos + 1, options), 9);
-  }
-  function encodeTag(buf2, token) {
-    encodeUintValue(buf2, Type.tag.majorEncoded, token.value);
-  }
-  encodeTag.compareTokens = encodeUint.compareTokens;
-  encodeTag.encodedSize = function encodedSize7(token) {
-    return encodeUintValue.encodedSize(token.value);
-  };
-
-  // node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/7float.js
-  var MINOR_FALSE = 20;
-  var MINOR_TRUE = 21;
-  var MINOR_NULL = 22;
-  var MINOR_UNDEFINED = 23;
-  function decodeUndefined(_data, _pos, _minor, options) {
-    if (options.allowUndefined === false) {
-      throw new Error(`${decodeErrPrefix} undefined values are not supported`);
-    } else if (options.coerceUndefinedToNull === true) {
-      return new Token(Type.null, null, 1);
-    }
-    return new Token(Type.undefined, void 0, 1);
-  }
-  function decodeBreak(_data, _pos, _minor, options) {
-    if (options.allowIndefinite === false) {
-      throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
-    }
-    return new Token(Type.break, void 0, 1);
-  }
-  function createToken(value, bytes, options) {
-    if (options) {
-      if (options.allowNaN === false && Number.isNaN(value)) {
-        throw new Error(`${decodeErrPrefix} NaN values are not supported`);
-      }
-      if (options.allowInfinity === false && (value === Infinity || value === -Infinity)) {
-        throw new Error(`${decodeErrPrefix} Infinity values are not supported`);
-      }
-    }
-    return new Token(Type.float, value, bytes);
-  }
-  function decodeFloat16(data, pos, _minor, options) {
-    return createToken(readFloat16(data, pos + 1), 3, options);
-  }
-  function decodeFloat32(data, pos, _minor, options) {
-    return createToken(readFloat32(data, pos + 1), 5, options);
-  }
-  function decodeFloat64(data, pos, _minor, options) {
-    return createToken(readFloat64(data, pos + 1), 9, options);
-  }
-  function encodeFloat(buf2, token, options) {
-    const float = token.value;
-    if (float === false) {
-      buf2.push([Type.float.majorEncoded | MINOR_FALSE]);
-    } else if (float === true) {
-      buf2.push([Type.float.majorEncoded | MINOR_TRUE]);
-    } else if (float === null) {
-      buf2.push([Type.float.majorEncoded | MINOR_NULL]);
-    } else if (float === void 0) {
-      buf2.push([Type.float.majorEncoded | MINOR_UNDEFINED]);
-    } else {
-      let decoded;
-      let success = false;
-      if (!options || options.float64 !== true) {
-        encodeFloat16(float);
-        decoded = readFloat16(ui8a, 1);
-        if (float === decoded || Number.isNaN(float)) {
-          ui8a[0] = 249;
-          buf2.push(ui8a.slice(0, 3));
-          success = true;
-        } else {
-          encodeFloat32(float);
-          decoded = readFloat32(ui8a, 1);
-          if (float === decoded) {
-            ui8a[0] = 250;
-            buf2.push(ui8a.slice(0, 5));
-            success = true;
-          }
-        }
-      }
-      if (!success) {
-        encodeFloat64(float);
-        decoded = readFloat64(ui8a, 1);
-        ui8a[0] = 251;
-        buf2.push(ui8a.slice(0, 9));
-      }
-    }
-  }
-  encodeFloat.encodedSize = function encodedSize8(token, options) {
-    const float = token.value;
-    if (float === false || float === true || float === null || float === void 0) {
-      return 1;
-    }
-    if (!options || options.float64 !== true) {
-      encodeFloat16(float);
-      let decoded = readFloat16(ui8a, 1);
-      if (float === decoded || Number.isNaN(float)) {
-        return 3;
-      }
-      encodeFloat32(float);
-      decoded = readFloat32(ui8a, 1);
-      if (float === decoded) {
-        return 5;
-      }
-    }
-    return 9;
-  };
-  var buffer = new ArrayBuffer(9);
-  var dataView = new DataView(buffer, 1);
-  var ui8a = new Uint8Array(buffer, 0);
-  function encodeFloat16(inp) {
-    if (inp === Infinity) {
-      dataView.setUint16(0, 31744, false);
-    } else if (inp === -Infinity) {
-      dataView.setUint16(0, 64512, false);
-    } else if (Number.isNaN(inp)) {
-      dataView.setUint16(0, 32256, false);
-    } else {
-      dataView.setFloat32(0, inp);
-      const valu32 = dataView.getUint32(0);
-      const exponent = (valu32 & 2139095040) >> 23;
-      const mantissa = valu32 & 8388607;
-      if (exponent === 255) {
-        dataView.setUint16(0, 31744, false);
-      } else if (exponent === 0) {
-        dataView.setUint16(0, (inp & 2147483648) >> 16 | mantissa >> 13, false);
-      } else {
-        const logicalExponent = exponent - 127;
-        if (logicalExponent < -24) {
-          dataView.setUint16(0, 0);
-        } else if (logicalExponent < -14) {
-          dataView.setUint16(0, (valu32 & 2147483648) >> 16 | 1 << 24 + logicalExponent, false);
-        } else {
-          dataView.setUint16(0, (valu32 & 2147483648) >> 16 | logicalExponent + 15 << 10 | mantissa >> 13, false);
-        }
-      }
-    }
-  }
-  function readFloat16(ui8a2, pos) {
-    if (ui8a2.length - pos < 2) {
-      throw new Error(`${decodeErrPrefix} not enough data for float16`);
-    }
-    const half = (ui8a2[pos] << 8) + ui8a2[pos + 1];
-    if (half === 31744) {
-      return Infinity;
-    }
-    if (half === 64512) {
-      return -Infinity;
-    }
-    if (half === 32256) {
-      return NaN;
-    }
-    const exp = half >> 10 & 31;
-    const mant = half & 1023;
-    let val;
-    if (exp === 0) {
-      val = mant * __pow(2, -24);
-    } else if (exp !== 31) {
-      val = (mant + 1024) * __pow(2, exp - 25);
-    } else {
-      val = mant === 0 ? Infinity : NaN;
-    }
-    return half & 32768 ? -val : val;
-  }
-  function encodeFloat32(inp) {
-    dataView.setFloat32(0, inp, false);
-  }
-  function readFloat32(ui8a2, pos) {
-    if (ui8a2.length - pos < 4) {
-      throw new Error(`${decodeErrPrefix} not enough data for float32`);
-    }
-    const offset = (ui8a2.byteOffset || 0) + pos;
-    return new DataView(ui8a2.buffer, offset, 4).getFloat32(0, false);
-  }
-  function encodeFloat64(inp) {
-    dataView.setFloat64(0, inp, false);
-  }
-  function readFloat64(ui8a2, pos) {
-    if (ui8a2.length - pos < 8) {
-      throw new Error(`${decodeErrPrefix} not enough data for float64`);
-    }
-    const offset = (ui8a2.byteOffset || 0) + pos;
-    return new DataView(ui8a2.buffer, offset, 8).getFloat64(0, false);
-  }
-  encodeFloat.compareTokens = encodeUint.compareTokens;
-
-  // node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/jump.js
-  function invalidMinor(data, pos, minor) {
-    throw new Error(`${decodeErrPrefix} encountered invalid minor (${minor}) for major ${data[pos] >>> 5}`);
-  }
-  function errorer(msg) {
-    return () => {
-      throw new Error(`${decodeErrPrefix} ${msg}`);
-    };
-  }
-  var jump = [];
-  for (let i = 0; i <= 23; i++) {
-    jump[i] = invalidMinor;
-  }
-  jump[24] = decodeUint8;
-  jump[25] = decodeUint16;
-  jump[26] = decodeUint32;
-  jump[27] = decodeUint64;
-  jump[28] = invalidMinor;
-  jump[29] = invalidMinor;
-  jump[30] = invalidMinor;
-  jump[31] = invalidMinor;
-  for (let i = 32; i <= 55; i++) {
-    jump[i] = invalidMinor;
-  }
-  jump[56] = decodeNegint8;
-  jump[57] = decodeNegint16;
-  jump[58] = decodeNegint32;
-  jump[59] = decodeNegint64;
-  jump[60] = invalidMinor;
-  jump[61] = invalidMinor;
-  jump[62] = invalidMinor;
-  jump[63] = invalidMinor;
-  for (let i = 64; i <= 87; i++) {
-    jump[i] = decodeBytesCompact;
-  }
-  jump[88] = decodeBytes8;
-  jump[89] = decodeBytes16;
-  jump[90] = decodeBytes32;
-  jump[91] = decodeBytes64;
-  jump[92] = invalidMinor;
-  jump[93] = invalidMinor;
-  jump[94] = invalidMinor;
-  jump[95] = errorer("indefinite length bytes/strings are not supported");
-  for (let i = 96; i <= 119; i++) {
-    jump[i] = decodeStringCompact;
-  }
-  jump[120] = decodeString8;
-  jump[121] = decodeString16;
-  jump[122] = decodeString32;
-  jump[123] = decodeString64;
-  jump[124] = invalidMinor;
-  jump[125] = invalidMinor;
-  jump[126] = invalidMinor;
-  jump[127] = errorer("indefinite length bytes/strings are not supported");
-  for (let i = 128; i <= 151; i++) {
-    jump[i] = decodeArrayCompact;
-  }
-  jump[152] = decodeArray8;
-  jump[153] = decodeArray16;
-  jump[154] = decodeArray32;
-  jump[155] = decodeArray64;
-  jump[156] = invalidMinor;
-  jump[157] = invalidMinor;
-  jump[158] = invalidMinor;
-  jump[159] = decodeArrayIndefinite;
-  for (let i = 160; i <= 183; i++) {
-    jump[i] = decodeMapCompact;
-  }
-  jump[184] = decodeMap8;
-  jump[185] = decodeMap16;
-  jump[186] = decodeMap32;
-  jump[187] = decodeMap64;
-  jump[188] = invalidMinor;
-  jump[189] = invalidMinor;
-  jump[190] = invalidMinor;
-  jump[191] = decodeMapIndefinite;
-  for (let i = 192; i <= 215; i++) {
-    jump[i] = decodeTagCompact;
-  }
-  jump[216] = decodeTag8;
-  jump[217] = decodeTag16;
-  jump[218] = decodeTag32;
-  jump[219] = decodeTag64;
-  jump[220] = invalidMinor;
-  jump[221] = invalidMinor;
-  jump[222] = invalidMinor;
-  jump[223] = invalidMinor;
-  for (let i = 224; i <= 243; i++) {
-    jump[i] = errorer("simple values are not supported");
-  }
-  jump[244] = invalidMinor;
-  jump[245] = invalidMinor;
-  jump[246] = invalidMinor;
-  jump[247] = decodeUndefined;
-  jump[248] = errorer("simple values are not supported");
-  jump[249] = decodeFloat16;
-  jump[250] = decodeFloat32;
-  jump[251] = decodeFloat64;
-  jump[252] = invalidMinor;
-  jump[253] = invalidMinor;
-  jump[254] = invalidMinor;
-  jump[255] = decodeBreak;
-  var quick = [];
-  for (let i = 0; i < 24; i++) {
-    quick[i] = new Token(Type.uint, i, 1);
-  }
-  for (let i = -1; i >= -24; i--) {
-    quick[31 - i] = new Token(Type.negint, i, 1);
-  }
-  quick[64] = new Token(Type.bytes, new Uint8Array(0), 1);
-  quick[96] = new Token(Type.string, "", 1);
-  quick[128] = new Token(Type.array, 0, 1);
-  quick[160] = new Token(Type.map, 0, 1);
-  quick[244] = new Token(Type.false, false, 1);
-  quick[245] = new Token(Type.true, true, 1);
-  quick[246] = new Token(Type.null, null, 1);
-  function quickEncodeToken(token) {
-    switch (token.type) {
-      case Type.false:
-        return fromArray([244]);
-      case Type.true:
-        return fromArray([245]);
-      case Type.null:
-        return fromArray([246]);
-      case Type.bytes:
-        if (!token.value.length) {
-          return fromArray([64]);
-        }
-        return;
-      case Type.string:
-        if (token.value === "") {
-          return fromArray([96]);
-        }
-        return;
-      case Type.array:
-        if (token.value === 0) {
-          return fromArray([128]);
-        }
-        return;
-      case Type.map:
-        if (token.value === 0) {
-          return fromArray([160]);
-        }
-        return;
-      case Type.uint:
-        if (token.value < 24) {
-          return fromArray([Number(token.value)]);
-        }
-        return;
-      case Type.negint:
-        if (token.value >= -24) {
-          return fromArray([31 - Number(token.value)]);
-        }
-    }
-  }
-
-  // node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/encode.js
-  var defaultEncodeOptions = {
-    float64: false,
-    mapSorter,
-    quickEncodeToken
-  };
-  function makeCborEncoders() {
-    const encoders = [];
-    encoders[Type.uint.major] = encodeUint;
-    encoders[Type.negint.major] = encodeNegint;
-    encoders[Type.bytes.major] = encodeBytes;
-    encoders[Type.string.major] = encodeString;
-    encoders[Type.array.major] = encodeArray;
-    encoders[Type.map.major] = encodeMap;
-    encoders[Type.tag.major] = encodeTag;
-    encoders[Type.float.major] = encodeFloat;
-    return encoders;
-  }
-  var cborEncoders = makeCborEncoders();
-  var buf = new Bl();
-  var Ref = class _Ref {
-    constructor(obj, parent) {
-      this.obj = obj;
-      this.parent = parent;
-    }
-    includes(obj) {
-      let p = this;
-      do {
-        if (p.obj === obj) {
-          return true;
-        }
-      } while (p = p.parent);
-      return false;
-    }
-    static createCheck(stack, obj) {
-      if (stack && stack.includes(obj)) {
-        throw new Error(`${encodeErrPrefix} object contains circular references`);
-      }
-      return new _Ref(obj, stack);
-    }
-  };
-  var simpleTokens = {
-    null: new Token(Type.null, null),
-    undefined: new Token(Type.undefined, void 0),
-    true: new Token(Type.true, true),
-    false: new Token(Type.false, false),
-    emptyArray: new Token(Type.array, 0),
-    emptyMap: new Token(Type.map, 0)
-  };
-  var typeEncoders = {
-    number(obj, _typ, _options, _refStack) {
-      if (!Number.isInteger(obj) || !Number.isSafeInteger(obj)) {
-        return new Token(Type.float, obj);
-      } else if (obj >= 0) {
-        return new Token(Type.uint, obj);
-      } else {
-        return new Token(Type.negint, obj);
-      }
-    },
-    bigint(obj, _typ, _options, _refStack) {
-      if (obj >= BigInt(0)) {
-        return new Token(Type.uint, obj);
-      } else {
-        return new Token(Type.negint, obj);
-      }
-    },
-    Uint8Array(obj, _typ, _options, _refStack) {
-      return new Token(Type.bytes, obj);
-    },
-    string(obj, _typ, _options, _refStack) {
-      return new Token(Type.string, obj);
-    },
-    boolean(obj, _typ, _options, _refStack) {
-      return obj ? simpleTokens.true : simpleTokens.false;
-    },
-    null(_obj, _typ, _options, _refStack) {
-      return simpleTokens.null;
-    },
-    undefined(_obj, _typ, _options, _refStack) {
-      return simpleTokens.undefined;
-    },
-    ArrayBuffer(obj, _typ, _options, _refStack) {
-      return new Token(Type.bytes, new Uint8Array(obj));
-    },
-    DataView(obj, _typ, _options, _refStack) {
-      return new Token(Type.bytes, new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength));
-    },
-    Array(obj, _typ, options, refStack) {
-      if (!obj.length) {
-        if (options.addBreakTokens === true) {
-          return [
-            simpleTokens.emptyArray,
-            new Token(Type.break)
-          ];
-        }
-        return simpleTokens.emptyArray;
-      }
-      refStack = Ref.createCheck(refStack, obj);
-      const entries2 = [];
-      let i = 0;
-      for (const e of obj) {
-        entries2[i++] = objectToTokens(e, options, refStack);
-      }
-      if (options.addBreakTokens) {
-        return [
-          new Token(Type.array, obj.length),
-          entries2,
-          new Token(Type.break)
-        ];
-      }
-      return [
-        new Token(Type.array, obj.length),
-        entries2
-      ];
-    },
-    Object(obj, typ, options, refStack) {
-      const isMap = typ !== "Object";
-      const keys = isMap ? obj.keys() : Object.keys(obj);
-      const length3 = isMap ? obj.size : keys.length;
-      if (!length3) {
-        if (options.addBreakTokens === true) {
-          return [
-            simpleTokens.emptyMap,
-            new Token(Type.break)
-          ];
-        }
-        return simpleTokens.emptyMap;
-      }
-      refStack = Ref.createCheck(refStack, obj);
-      const entries2 = [];
-      let i = 0;
-      for (const key of keys) {
-        entries2[i++] = [
-          objectToTokens(key, options, refStack),
-          objectToTokens(isMap ? obj.get(key) : obj[key], options, refStack)
-        ];
-      }
-      sortMapEntries(entries2, options);
-      if (options.addBreakTokens) {
-        return [
-          new Token(Type.map, length3),
-          entries2,
-          new Token(Type.break)
-        ];
-      }
-      return [
-        new Token(Type.map, length3),
-        entries2
-      ];
-    }
-  };
-  typeEncoders.Map = typeEncoders.Object;
-  typeEncoders.Buffer = typeEncoders.Uint8Array;
-  for (const typ of "Uint8Clamped Uint16 Uint32 Int8 Int16 Int32 BigUint64 BigInt64 Float32 Float64".split(" ")) {
-    typeEncoders[`${typ}Array`] = typeEncoders.DataView;
-  }
-  function objectToTokens(obj, options = {}, refStack) {
-    const typ = is(obj);
-    const customTypeEncoder = options && options.typeEncoders && options.typeEncoders[typ] || typeEncoders[typ];
-    if (typeof customTypeEncoder === "function") {
-      const tokens = customTypeEncoder(obj, typ, options, refStack);
-      if (tokens != null) {
-        return tokens;
-      }
-    }
-    const typeEncoder = typeEncoders[typ];
-    if (!typeEncoder) {
-      throw new Error(`${encodeErrPrefix} unsupported type: ${typ}`);
-    }
-    return typeEncoder(obj, typ, options, refStack);
-  }
-  function sortMapEntries(entries2, options) {
-    if (options.mapSorter) {
-      entries2.sort(options.mapSorter);
-    }
-  }
-  function mapSorter(e1, e2) {
-    const keyToken1 = Array.isArray(e1[0]) ? e1[0][0] : e1[0];
-    const keyToken2 = Array.isArray(e2[0]) ? e2[0][0] : e2[0];
-    if (keyToken1.type !== keyToken2.type) {
-      return keyToken1.type.compare(keyToken2.type);
-    }
-    const major = keyToken1.type.major;
-    const tcmp = cborEncoders[major].compareTokens(keyToken1, keyToken2);
-    if (tcmp === 0) {
-      console.warn("WARNING: complex key types used, CBOR key sorting guarantees are gone");
-    }
-    return tcmp;
-  }
-  function tokensToEncoded(buf2, tokens, encoders, options) {
-    if (Array.isArray(tokens)) {
-      for (const token of tokens) {
-        tokensToEncoded(buf2, token, encoders, options);
-      }
-    } else {
-      encoders[tokens.type.major](buf2, tokens, options);
-    }
-  }
-  function encodeCustom(data, encoders, options) {
-    const tokens = objectToTokens(data, options);
-    if (!Array.isArray(tokens) && options.quickEncodeToken) {
-      const quickBytes = options.quickEncodeToken(tokens);
-      if (quickBytes) {
-        return quickBytes;
-      }
-      const encoder = encoders[tokens.type.major];
-      if (encoder.encodedSize) {
-        const size = encoder.encodedSize(tokens, options);
-        const buf2 = new Bl(size);
-        encoder(buf2, tokens, options);
-        if (buf2.chunks.length !== 1) {
-          throw new Error(`Unexpected error: pre-calculated length for ${tokens} was wrong`);
-        }
-        return asU8A(buf2.chunks[0]);
-      }
-    }
-    buf.reset();
-    tokensToEncoded(buf, tokens, encoders, options);
-    return buf.toBytes(true);
-  }
-  function encode4(data, options) {
-    options = Object.assign({}, defaultEncodeOptions, options);
-    return encodeCustom(data, cborEncoders, options);
-  }
-
-  // node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/decode.js
-  var defaultDecodeOptions = {
-    strict: false,
-    allowIndefinite: true,
-    allowUndefined: true,
-    allowBigInt: true
-  };
-  var Tokeniser = class {
-    constructor(data, options = {}) {
-      this.pos = 0;
-      this.data = data;
-      this.options = options;
-    }
-    done() {
-      return this.pos >= this.data.length;
-    }
-    next() {
-      const byt = this.data[this.pos];
-      let token = quick[byt];
-      if (token === void 0) {
-        const decoder = jump[byt];
-        if (!decoder) {
-          throw new Error(`${decodeErrPrefix} no decoder for major type ${byt >>> 5} (byte 0x${byt.toString(16).padStart(2, "0")})`);
-        }
-        const minor = byt & 31;
-        token = decoder(this.data, this.pos, minor, this.options);
-      }
-      this.pos += token.encodedLength;
-      return token;
-    }
-  };
-  var DONE = Symbol.for("DONE");
-  var BREAK = Symbol.for("BREAK");
-  function tokenToArray(token, tokeniser, options) {
-    const arr = [];
-    for (let i = 0; i < token.value; i++) {
-      const value = tokensToObject(tokeniser, options);
-      if (value === BREAK) {
-        if (token.value === Infinity) {
-          break;
-        }
-        throw new Error(`${decodeErrPrefix} got unexpected break to lengthed array`);
-      }
-      if (value === DONE) {
-        throw new Error(`${decodeErrPrefix} found array but not enough entries (got ${i}, expected ${token.value})`);
-      }
-      arr[i] = value;
-    }
-    return arr;
-  }
-  function tokenToMap(token, tokeniser, options) {
-    const useMaps = options.useMaps === true;
-    const obj = useMaps ? void 0 : {};
-    const m = useMaps ? /* @__PURE__ */ new Map() : void 0;
-    for (let i = 0; i < token.value; i++) {
-      const key = tokensToObject(tokeniser, options);
-      if (key === BREAK) {
-        if (token.value === Infinity) {
-          break;
-        }
-        throw new Error(`${decodeErrPrefix} got unexpected break to lengthed map`);
-      }
-      if (key === DONE) {
-        throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no key], expected ${token.value})`);
-      }
-      if (useMaps !== true && typeof key !== "string") {
-        throw new Error(`${decodeErrPrefix} non-string keys not supported (got ${typeof key})`);
-      }
-      if (options.rejectDuplicateMapKeys === true) {
-        if (useMaps && m.has(key) || !useMaps && key in obj) {
-          throw new Error(`${decodeErrPrefix} found repeat map key "${key}"`);
-        }
-      }
-      const value = tokensToObject(tokeniser, options);
-      if (value === DONE) {
-        throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no value], expected ${token.value})`);
-      }
-      if (useMaps) {
-        m.set(key, value);
-      } else {
-        obj[key] = value;
-      }
-    }
-    return useMaps ? m : obj;
-  }
-  function tokensToObject(tokeniser, options) {
-    if (tokeniser.done()) {
-      return DONE;
-    }
-    const token = tokeniser.next();
-    if (token.type === Type.break) {
-      return BREAK;
-    }
-    if (token.type.terminal) {
-      return token.value;
-    }
-    if (token.type === Type.array) {
-      return tokenToArray(token, tokeniser, options);
-    }
-    if (token.type === Type.map) {
-      return tokenToMap(token, tokeniser, options);
-    }
-    if (token.type === Type.tag) {
-      if (options.tags && typeof options.tags[token.value] === "function") {
-        const tagged = tokensToObject(tokeniser, options);
-        return options.tags[token.value](tagged);
-      }
-      throw new Error(`${decodeErrPrefix} tag not supported (${token.value})`);
-    }
-    throw new Error("unsupported");
-  }
-  function decode6(data, options) {
-    if (!(data instanceof Uint8Array)) {
-      throw new Error(`${decodeErrPrefix} data to decode must be a Uint8Array`);
-    }
-    options = Object.assign({}, defaultDecodeOptions, options);
-    const tokeniser = options.tokenizer || new Tokeniser(data, options);
-    const decoded = tokensToObject(tokeniser, options);
-    if (decoded === DONE) {
-      throw new Error(`${decodeErrPrefix} did not find any content to decode`);
-    }
-    if (decoded === BREAK) {
-      throw new Error(`${decodeErrPrefix} got unexpected break`);
-    }
-    if (!tokeniser.done()) {
-      throw new Error(`${decodeErrPrefix} too many terminals, data makes no sense`);
-    }
-    return decoded;
-  }
-
-  // node_modules/@ipld/dag-cbor/src/index.js
-  var CID_CBOR_TAG = 42;
-  function cidEncoder(obj) {
-    if (obj.asCID !== obj && obj["/"] !== obj.bytes) {
-      return null;
-    }
-    const cid = CID.asCID(obj);
-    if (!cid) {
-      return null;
-    }
-    const bytes = new Uint8Array(cid.bytes.byteLength + 1);
-    bytes.set(cid.bytes, 1);
-    return [
-      new Token(Type.tag, CID_CBOR_TAG),
-      new Token(Type.bytes, bytes)
-    ];
-  }
-  function undefinedEncoder() {
-    throw new Error("`undefined` is not supported by the IPLD Data Model and cannot be encoded");
-  }
-  function numberEncoder(num) {
-    if (Number.isNaN(num)) {
-      throw new Error("`NaN` is not supported by the IPLD Data Model and cannot be encoded");
-    }
-    if (num === Infinity || num === -Infinity) {
-      throw new Error("`Infinity` and `-Infinity` is not supported by the IPLD Data Model and cannot be encoded");
-    }
-    return null;
-  }
-  var encodeOptions = {
-    float64: true,
-    typeEncoders: {
-      Object: cidEncoder,
-      undefined: undefinedEncoder,
-      number: numberEncoder
-    }
-  };
-  function cidDecoder(bytes) {
-    if (bytes[0] !== 0) {
-      throw new Error("Invalid CID for CBOR tag 42; expected leading 0x00");
-    }
-    return CID.decode(bytes.subarray(1));
-  }
-  var decodeOptions = {
-    allowIndefinite: false,
-    coerceUndefinedToNull: true,
-    allowNaN: false,
-    allowInfinity: false,
-    allowBigInt: true,
-    // this will lead to BigInt for ints outside of
-    // safe-integer range, which may surprise users
-    strict: true,
-    useMaps: false,
-    rejectDuplicateMapKeys: true,
-    /** @type {import('cborg').TagDecoder[]} */
-    tags: []
-  };
-  decodeOptions.tags[CID_CBOR_TAG] = cidDecoder;
-  var name = "dag-cbor";
-  var code = 113;
-  var encode5 = (node) => encode4(node, encodeOptions);
-  var decode7 = (data) => decode6(data, decodeOptions);
-
-  // node_modules/@alanshaw/pail/node_modules/multiformats/vendor/varint.js
-  var encode_12 = encode6;
-  var MSB2 = 128;
-  var REST2 = 127;
-  var MSBALL2 = ~REST2;
-  var INT2 = Math.pow(2, 31);
-  function encode6(num, out, offset) {
-    out = out || [];
-    offset = offset || 0;
-    var oldOffset = offset;
-    while (num >= INT2) {
-      out[offset++] = num & 255 | MSB2;
-      num /= 128;
-    }
-    while (num & MSBALL2) {
-      out[offset++] = num & 255 | MSB2;
-      num >>>= 7;
-    }
-    out[offset] = num | 0;
-    encode6.bytes = offset - oldOffset + 1;
-    return out;
-  }
-  var decode8 = read2;
-  var MSB$12 = 128;
-  var REST$12 = 127;
-  function read2(buf2, offset) {
-    var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf2.length;
-    do {
-      if (counter >= l) {
-        read2.bytes = 0;
-        throw new RangeError("Could not decode varint");
-      }
-      b = buf2[counter++];
-      res += shift < 28 ? (b & REST$12) << shift : (b & REST$12) * Math.pow(2, shift);
-      shift += 7;
-    } while (b >= MSB$12);
-    read2.bytes = counter - offset;
-    return res;
-  }
-  var N12 = Math.pow(2, 7);
-  var N22 = Math.pow(2, 14);
-  var N32 = Math.pow(2, 21);
-  var N42 = Math.pow(2, 28);
-  var N52 = Math.pow(2, 35);
-  var N62 = Math.pow(2, 42);
-  var N72 = Math.pow(2, 49);
-  var N82 = Math.pow(2, 56);
-  var N92 = Math.pow(2, 63);
-  var length2 = function(value) {
-    return value < N12 ? 1 : value < N22 ? 2 : value < N32 ? 3 : value < N42 ? 4 : value < N52 ? 5 : value < N62 ? 6 : value < N72 ? 7 : value < N82 ? 8 : value < N92 ? 9 : 10;
-  };
-  var varint2 = {
-    encode: encode_12,
-    decode: decode8,
-    encodingLength: length2
-  };
-  var _brrp_varint2 = varint2;
-  var varint_default2 = _brrp_varint2;
-
-  // node_modules/@alanshaw/pail/node_modules/multiformats/src/varint.js
-  var decode9 = (data, offset = 0) => {
-    const code2 = varint_default2.decode(data, offset);
-    return [code2, varint_default2.decode.bytes];
-  };
-  var encodeTo2 = (int, target, offset = 0) => {
-    varint_default2.encode(int, target, offset);
-    return target;
-  };
-  var encodingLength2 = (int) => {
-    return varint_default2.encodingLength(int);
-  };
-
-  // node_modules/@alanshaw/pail/node_modules/multiformats/src/bytes.js
-  var empty2 = new Uint8Array(0);
-  var equals3 = (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;
-  };
-  var coerce2 = (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");
-  };
-
-  // node_modules/@alanshaw/pail/node_modules/multiformats/src/hashes/digest.js
-  var create3 = (code2, digest) => {
-    const size = digest.byteLength;
-    const sizeOffset = encodingLength2(code2);
-    const digestOffset = sizeOffset + encodingLength2(size);
-    const bytes = new Uint8Array(digestOffset + size);
-    encodeTo2(code2, bytes, 0);
-    encodeTo2(size, bytes, sizeOffset);
-    bytes.set(digest, digestOffset);
-    return new Digest2(code2, size, digest, bytes);
-  };
-  var decode10 = (multihash) => {
-    const bytes = coerce2(multihash);
-    const [code2, sizeOffset] = decode9(bytes);
-    const [size, digestOffset] = decode9(bytes.subarray(sizeOffset));
-    const digest = bytes.subarray(sizeOffset + digestOffset);
-    if (digest.byteLength !== size) {
-      throw new Error("Incorrect length");
-    }
-    return new Digest2(code2, size, digest, bytes);
-  };
-  var equals4 = (a, b) => {
-    if (a === b) {
-      return true;
-    } else {
-      const data = (
-        /** @type {{code?:unknown, size?:unknown, bytes?:unknown}} */
-        b
-      );
-      return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals3(a.bytes, data.bytes);
-    }
-  };
-  var Digest2 = class {
-    /**
-     * Creates a multihash digest.
-     *
-     * @param {Code} code
-     * @param {Size} size
-     * @param {Uint8Array} digest
-     * @param {Uint8Array} bytes
-     */
-    constructor(code2, size, digest, bytes) {
-      this.code = code2;
-      this.size = size;
-      this.digest = digest;
-      this.bytes = bytes;
-    }
-  };
-
-  // node_modules/@alanshaw/pail/node_modules/multiformats/vendor/base-x.js
-  function base2(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 encode9(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 length3 = 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 < length3) && 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");
-        }
-        length3 = i2;
-        pbegin++;
-      }
-      var it2 = size - length3;
-      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 length3 = 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 < length3) && 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");
-        }
-        length3 = i2;
-        psz++;
-      }
-      if (source[psz] === " ") {
-        return;
-      }
-      var it4 = size - length3;
-      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 decode13(string) {
-      var buffer2 = decodeUnsafe(string);
-      if (buffer2) {
-        return buffer2;
-      }
-      throw new Error(`Non-${name2} character`);
-    }
-    return {
-      encode: encode9,
-      decodeUnsafe,
-      decode: decode13
-    };
-  }
-  var src2 = base2;
-  var _brrp__multiformats_scope_baseX2 = src2;
-  var base_x_default2 = _brrp__multiformats_scope_baseX2;
-
-  // node_modules/@alanshaw/pail/node_modules/multiformats/src/bases/base.js
-  var Encoder2 = class {
-    /**
-     * @param {Base} name
-     * @param {Prefix} prefix
-     * @param {(bytes:Uint8Array) => string} baseEncode
-     */
-    constructor(name2, prefix, baseEncode) {
-      this.name = name2;
-      this.prefix = prefix;
-      this.baseEncode = baseEncode;
-    }
-    /**
-     * @param {Uint8Array} bytes
-     * @returns {API.Multibase<Prefix>}
-     */
-    encode(bytes) {
-      if (bytes instanceof Uint8Array) {
-        return `${this.prefix}${this.baseEncode(bytes)}`;
-      } else {
-        throw Error("Unknown type, must be binary type");
-      }
-    }
-  };
-  var Decoder2 = class {
-    /**
-     * @param {Base} name
-     * @param {Prefix} prefix
-     * @param {(text:string) => Uint8Array} baseDecode
-     */
-    constructor(name2, prefix, baseDecode) {
-      this.name = name2;
-      this.prefix = prefix;
-      if (prefix.codePointAt(0) === void 0) {
-        throw new Error("Invalid prefix character");
-      }
-      this.prefixCodePoint = /** @type {number} */
-      prefix.codePointAt(0);
-      this.baseDecode = baseDecode;
-    }
-    /**
-     * @param {string} text
-     */
-    decode(text) {
-      if (typeof text === "string") {
-        if (text.codePointAt(0) !== this.prefixCodePoint) {
-          throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
-        }
-        return this.baseDecode(text.slice(this.prefix.length));
-      } else {
-        throw Error("Can only multibase decode strings");
-      }
-    }
-    /**
-     * @template {string} OtherPrefix
-     * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
-     * @returns {ComposedDecoder<Prefix|OtherPrefix>}
-     */
-    or(decoder) {
-      return or2(this, decoder);
-    }
-  };
-  var ComposedDecoder2 = class {
-    /**
-     * @param {Decoders<Prefix>} decoders
-     */
-    constructor(decoders) {
-      this.decoders = decoders;
-    }
-    /**
-     * @template {string} OtherPrefix
-     * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
-     * @returns {ComposedDecoder<Prefix|OtherPrefix>}
-     */
-    or(decoder) {
-      return or2(this, decoder);
-    }
-    /**
-     * @param {string} input
-     * @returns {Uint8Array}
-     */
-    decode(input) {
-      const prefix = (
-        /** @type {Prefix} */
-        input[0]
-      );
-      const decoder = this.decoders[prefix];
-      if (decoder) {
-        return decoder.decode(input);
-      } else {
-        throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
-      }
-    }
-  };
-  var or2 = (left, right) => new ComposedDecoder2(
-    /** @type {Decoders<L|R>} */
-    __spreadValues(__spreadValues({}, left.decoders || { [
-      /** @type API.UnibaseDecoder<L> */
-      left.prefix
-    ]: left }), right.decoders || { [
-      /** @type API.UnibaseDecoder<R> */
-      right.prefix
-    ]: right })
-  );
-  var Codec2 = class {
-    /**
-     * @param {Base} name
-     * @param {Prefix} prefix
-     * @param {(bytes:Uint8Array) => string} baseEncode
-     * @param {(text:string) => Uint8Array} baseDecode
-     */
-    constructor(name2, prefix, baseEncode, baseDecode) {
-      this.name = name2;
-      this.prefix = prefix;
-      this.baseEncode = baseEncode;
-      this.baseDecode = baseDecode;
-      this.encoder = new Encoder2(name2, prefix, baseEncode);
-      this.decoder = new Decoder2(name2, prefix, baseDecode);
-    }
-    /**
-     * @param {Uint8Array} input
-     */
-    encode(input) {
-      return this.encoder.encode(input);
-    }
-    /**
-     * @param {string} input
-     */
-    decode(input) {
-      return this.decoder.decode(input);
-    }
-  };
-  var from3 = ({ name: name2, prefix, encode: encode9, decode: decode13 }) => new Codec2(name2, prefix, encode9, decode13);
-  var baseX2 = ({ prefix, name: name2, alphabet }) => {
-    const { encode: encode9, decode: decode13 } = base_x_default2(alphabet, name2);
-    return from3({
-      prefix,
-      name: name2,
-      encode: encode9,
-      /**
-       * @param {string} text
-       */
-      decode: (text) => coerce2(decode13(text))
-    });
-  };
-  var decode11 = (string, alphabet, bitsPerChar, name2) => {
-    const codes = {};
-    for (let i = 0; i < alphabet.length; ++i) {
-      codes[alphabet[i]] = i;
-    }
-    let end = string.length;
-    while (string[end - 1] === "=") {
-      --end;
-    }
-    const out = new Uint8Array(end * bitsPerChar / 8 | 0);
-    let bits = 0;
-    let buffer2 = 0;
-    let written = 0;
-    for (let i = 0; i < end; ++i) {
-      const value = codes[string[i]];
-      if (value === void 0) {
-        throw new SyntaxError(`Non-${name2} character`);
-      }
-      buffer2 = buffer2 << bitsPerChar | value;
-      bits += bitsPerChar;
-      if (bits >= 8) {
-        bits -= 8;
-        out[written++] = 255 & buffer2 >> bits;
-      }
-    }
-    if (bits >= bitsPerChar || 255 & buffer2 << 8 - bits) {
-      throw new SyntaxError("Unexpected end of data");
-    }
-    return out;
-  };
-  var encode7 = (data, alphabet, bitsPerChar) => {
-    const pad = alphabet[alphabet.length - 1] === "=";
-    const mask = (1 << bitsPerChar) - 1;
-    let out = "";
-    let bits = 0;
-    let buffer2 = 0;
-    for (let i = 0; i < data.length; ++i) {
-      buffer2 = buffer2 << 8 | data[i];
-      bits += 8;
-      while (bits > bitsPerChar) {
-        bits -= bitsPerChar;
-        out += alphabet[mask & buffer2 >> bits];
-      }
-    }
-    if (bits) {
-      out += alphabet[mask & buffer2 << bitsPerChar - bits];
-    }
-    if (pad) {
-      while (out.length * bitsPerChar & 7) {
-        out += "=";
-      }
-    }
-    return out;
-  };
-  var rfc46482 = ({ name: name2, prefix, bitsPerChar, alphabet }) => {
-    return from3({
-      prefix,
-      name: name2,
-      encode(input) {
-        return encode7(input, alphabet, bitsPerChar);
-      },
-      decode(input) {
-        return decode11(input, alphabet, bitsPerChar, name2);
-      }
-    });
-  };
-
-  // node_modules/@alanshaw/pail/node_modules/multiformats/src/bases/base58.js
-  var base58btc2 = baseX2({
-    name: "base58btc",
-    prefix: "z",
-    alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-  });
-  var base58flickr2 = baseX2({
-    name: "base58flickr",
-    prefix: "Z",
-    alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
-  });
-
-  // node_modules/@alanshaw/pail/node_modules/multiformats/src/bases/base32.js
-  var base322 = rfc46482({
-    prefix: "b",
-    name: "base32",
-    alphabet: "abcdefghijklmnopqrstuvwxyz234567",
-    bitsPerChar: 5
-  });
-  var base32upper2 = rfc46482({
-    prefix: "B",
-    name: "base32upper",
-    alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
-    bitsPerChar: 5
-  });
-  var base32pad2 = rfc46482({
-    prefix: "c",
-    name: "base32pad",
-    alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
-    bitsPerChar: 5
-  });
-  var base32padupper2 = rfc46482({
-    prefix: "C",
-    name: "base32padupper",
-    alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
-    bitsPerChar: 5
-  });
-  var base32hex2 = rfc46482({
-    prefix: "v",
-    name: "base32hex",
-    alphabet: "0123456789abcdefghijklmnopqrstuv",
-    bitsPerChar: 5
-  });
-  var base32hexupper2 = rfc46482({
-    prefix: "V",
-    name: "base32hexupper",
-    alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
-    bitsPerChar: 5
-  });
-  var base32hexpad2 = rfc46482({
-    prefix: "t",
-    name: "base32hexpad",
-    alphabet: "0123456789abcdefghijklmnopqrstuv=",
-    bitsPerChar: 5
-  });
-  var base32hexpadupper2 = rfc46482({
-    prefix: "T",
-    name: "base32hexpadupper",
-    alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
-    bitsPerChar: 5
-  });
-  var base32z2 = rfc46482({
-    prefix: "h",
-    name: "base32z",
-    alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
-    bitsPerChar: 5
-  });
-
-  // node_modules/@alanshaw/pail/node_modules/multiformats/src/cid.js
-  var format2 = (link, base3) => {
-    const { bytes, version } = link;
-    switch (version) {
-      case 0:
-        return toStringV02(
-          bytes,
-          baseCache2(link),
-          /** @type {API.MultibaseEncoder<"z">} */
-          base3 || base58btc2.encoder
-        );
-      default:
-        return toStringV12(
-          bytes,
-          baseCache2(link),
-          /** @type {API.MultibaseEncoder<Prefix>} */
-          base3 || base322.encoder
-        );
-    }
-  };
-  var cache2 = /* @__PURE__ */ new WeakMap();
-  var baseCache2 = (cid) => {
-    const baseCache3 = cache2.get(cid);
-    if (baseCache3 == null) {
-      const baseCache4 = /* @__PURE__ */ new Map();
-      cache2.set(cid, baseCache4);
-      return baseCache4;
-    }
-    return baseCache3;
-  };
-  var CID2 = class _CID {
-    /**
-     * @param {Version} version - Version of the CID
-     * @param {Format} code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
-     * @param {API.MultihashDigest<Alg>} multihash - (Multi)hash of the of the content.
-     * @param {Uint8Array} bytes
-     *
-     */
-    constructor(version, 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;
-    }
-    /**
-     * @returns {CID<Data, API.DAG_PB, API.SHA_256, 0>}
-     */
-    toV0() {
-      switch (this.version) {
-        case 0: {
-          return (
-            /** @type {CID<Data, API.DAG_PB, API.SHA_256, 0>} */
-            this
-          );
-        }
-        case 1: {
-          const { code: code2, multihash } = this;
-          if (code2 !== DAG_PB_CODE2) {
-            throw new Error("Cannot convert a non dag-pb CID to CIDv0");
-          }
-          if (multihash.code !== SHA_256_CODE2) {
-            throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
-          }
-          return (
-            /** @type {CID<Data, API.DAG_PB, API.SHA_256, 0>} */
-            _CID.createV0(
-              /** @type {API.MultihashDigest<API.SHA_256>} */
-              multihash
-            )
-          );
-        }
-        default: {
-          throw Error(
-            `Can not convert CID version ${this.version} to version 0. This is a bug please report`
-          );
-        }
-      }
-    }
-    /**
-     * @returns {CID<Data, Format, Alg, 1>}
-     */
-    toV1() {
-      switch (this.version) {
-        case 0: {
-          const { code: code2, digest } = this.multihash;
-          const multihash = create3(code2, digest);
-          return (
-            /** @type {CID<Data, Format, Alg, 1>} */
-            _CID.createV1(this.code, multihash)
-          );
-        }
-        case 1: {
-          return (
-            /** @type {CID<Data, Format, Alg, 1>} */
-            this
-          );
-        }
-        default: {
-          throw Error(
-            `Can not convert CID version ${this.version} to version 1. This is a bug please report`
-          );
-        }
-      }
-    }
-    /**
-     * @param {unknown} other
-     * @returns {other is CID<Data, Format, Alg, Version>}
-     */
-    equals(other) {
-      return _CID.equals(this, other);
-    }
-    /**
-     * @template {unknown} Data
-     * @template {number} Format
-     * @template {number} Alg
-     * @template {API.Version} Version
-     * @param {API.Link<Data, Format, Alg, Version>} self
-     * @param {unknown} other
-     * @returns {other is CID}
-     */
-    static equals(self, other) {
-      const unknown = (
-        /** @type {{code?:unknown, version?:unknown, multihash?:unknown}} */
-        other
-      );
-      return unknown && self.code === unknown.code && self.version === unknown.version && equals4(self.multihash, unknown.multihash);
-    }
-    /**
-     * @param {API.MultibaseEncoder<string>} [base]
-     * @returns {string}
-     */
-    toString(base3) {
-      return format2(this, base3);
-    }
-    toJSON() {
-      return { "/": format2(this) };
-    }
-    link() {
-      return this;
-    }
-    get [Symbol.toStringTag]() {
-      return "CID";
-    }
-    // Legacy
-    [Symbol.for("nodejs.util.inspect.custom")]() {
-      return `CID(${this.toString()})`;
-    }
-    /**
-     * Takes any input `value` and returns a `CID` instance if it was
-     * a `CID` otherwise returns `null`. If `value` is instanceof `CID`
-     * it will return value back. If `value` is not instance of this CID
-     * class, but is compatible CID it will return new instance of this
-     * `CID` class. Otherwise returns null.
-     *
-     * This allows two different incompatible versions of CID library to
-     * co-exist and interop as long as binary interface is compatible.
-     *
-     * @template {unknown} Data
-     * @template {number} Format
-     * @template {number} Alg
-     * @template {API.Version} Version
-     * @template {unknown} U
-     * @param {API.Link<Data, Format, Alg, Version>|U} input
-     * @returns {CID<Data, Format, Alg, Version>|null}
-     */
-    static asCID(input) {
-      if (input == null) {
-        return null;
-      }
-      const value = (
-        /** @type {any} */
-        input
-      );
-      if (value instanceof _CID) {
-        return value;
-      } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
-        const { version, code: code2, multihash, bytes } = value;
-        return new _CID(
-          version,
-          code2,
-          /** @type {API.MultihashDigest<Alg>} */
-          multihash,
-          bytes || encodeCID2(version, code2, multihash.bytes)
-        );
-      } else if (value[cidSymbol2] === true) {
-        const { version, multihash, code: code2 } = value;
-        const digest = (
-          /** @type {API.MultihashDigest<Alg>} */
-          decode10(multihash)
-        );
-        return _CID.create(version, code2, digest);
-      } else {
-        return null;
-      }
-    }
-    /**
-     *
-     * @template {unknown} Data
-     * @template {number} Format
-     * @template {number} Alg
-     * @template {API.Version} Version
-     * @param {Version} version - Version of the CID
-     * @param {Format} code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
-     * @param {API.MultihashDigest<Alg>} digest - (Multi)hash of the of the content.
-     * @returns {CID<Data, Format, Alg, Version>}
-     */
-    static create(version, code2, digest) {
-      if (typeof code2 !== "number") {
-        throw new Error("String codecs are no longer supported");
-      }
-      if (!(digest.bytes instanceof Uint8Array)) {
-        throw new Error("Invalid digest");
-      }
-      switch (version) {
-        case 0: {
-          if (code2 !== DAG_PB_CODE2) {
-            throw new Error(
-              `Version 0 CID must use dag-pb (code: ${DAG_PB_CODE2}) block encoding`
-            );
-          } else {
-            return new _CID(version, code2, digest, digest.bytes);
-          }
-        }
-        case 1: {
-          const bytes = encodeCID2(version, code2, digest.bytes);
-          return new _CID(version, code2, digest, bytes);
-        }
-        default: {
-          throw new Error("Invalid version");
-        }
-      }
-    }
-    /**
-     * Simplified version of `create` for CIDv0.
-     *
-     * @template {unknown} [T=unknown]
-     * @param {API.MultihashDigest<typeof SHA_256_CODE>} digest - Multihash.
-     * @returns {CID<T, typeof DAG_PB_CODE, typeof SHA_256_CODE, 0>}
-     */
-    static createV0(digest) {
-      return _CID.create(0, DAG_PB_CODE2, digest);
-    }
-    /**
-     * Simplified version of `create` for CIDv1.
-     *
-     * @template {unknown} Data
-     * @template {number} Code
-     * @template {number} Alg
-     * @param {Code} code - Content encoding format code.
-     * @param {API.MultihashDigest<Alg>} digest - Miltihash of the content.
-     * @returns {CID<Data, Code, Alg, 1>}
-     */
-    static createV1(code2, digest) {
-      return _CID.create(1, code2, digest);
-    }
-    /**
-     * Decoded a CID from its binary representation. The byte array must contain
-     * only the CID with no additional bytes.
-     *
-     * An error will be thrown if the bytes provided do not contain a valid
-     * binary representation of a CID.
-     *
-     * @template {unknown} Data
-     * @template {number} Code
-     * @template {number} Alg
-     * @template {API.Version} Ver
-     * @param {API.ByteView<API.Link<Data, Code, Alg, Ver>>} bytes
-     * @returns {CID<Data, Code, Alg, Ver>}
-     */
-    static decode(bytes) {
-      const [cid, remainder] = _CID.decodeFirst(bytes);
-      if (remainder.length) {
-        throw new Error("Incorrect length");
-      }
-      return cid;
-    }
-    /**
-     * Decoded a CID from its binary representation at the beginning of a byte
-     * array.
-     *
-     * Returns an array with the first element containing the CID and the second
-     * element containing the remainder of the original byte array. The remainder
-     * will be a zero-length byte array if the provided bytes only contained a
-     * binary CID representation.
-     *
-     * @template {unknown} T
-     * @template {number} C
-     * @template {number} A
-     * @template {API.Version} V
-     * @param {API.ByteView<API.Link<T, C, A, V>>} bytes
-     * @returns {[CID<T, C, A, V>, Uint8Array]}
-     */
-    static decodeFirst(bytes) {
-      const specs = _CID.inspectBytes(bytes);
-      const prefixSize = specs.size - specs.multihashSize;
-      const multihashBytes = coerce2(
-        bytes.subarray(prefixSize, prefixSize + specs.multihashSize)
-      );
-      if (multihashBytes.byteLength !== specs.multihashSize) {
-        throw new Error("Incorrect length");
-      }
-      const digestBytes = multihashBytes.subarray(
-        specs.multihashSize - specs.digestSize
-      );
-      const digest = new Digest2(
-        specs.multihashCode,
-        specs.digestSize,
-        digestBytes,
-        multihashBytes
-      );
-      const cid = specs.version === 0 ? _CID.createV0(
-        /** @type {API.MultihashDigest<API.SHA_256>} */
-        digest
-      ) : _CID.createV1(specs.codec, digest);
-      return [
-        /** @type {CID<T, C, A, V>} */
-        cid,
-        bytes.subarray(specs.size)
-      ];
-    }
-    /**
-     * Inspect the initial bytes of a CID to determine its properties.
-     *
-     * Involves decoding up to 4 varints. Typically this will require only 4 to 6
-     * bytes but for larger multicodec code values and larger multihash digest
-     * lengths these varints can be quite large. It is recommended that at least
-     * 10 bytes be made available in the `initialBytes` argument for a complete
-     * inspection.
-     *
-     * @template {unknown} T
-     * @template {number} C
-     * @template {number} A
-     * @template {API.Version} V
-     * @param {API.ByteView<API.Link<T, C, A, V>>} initialBytes
-     * @returns {{ version:V, codec:C, multihashCode:A, digestSize:number, multihashSize:number, size:number }}
-     */
-    static inspectBytes(initialBytes) {
-      let offset = 0;
-      const next = () => {
-        const [i, length3] = decode9(initialBytes.subarray(offset));
-        offset += length3;
-        return i;
-      };
-      let version = (
-        /** @type {V} */
-        next()
-      );
-      let codec = (
-        /** @type {C} */
-        DAG_PB_CODE2
-      );
-      if (
-        /** @type {number} */
-        version === 18
-      ) {
-        version = /** @type {V} */
-        0;
-        offset = 0;
-      } else {
-        codec = /** @type {C} */
-        next();
-      }
-      if (version !== 0 && version !== 1) {
-        throw new RangeError(`Invalid CID version ${version}`);
-      }
-      const prefixSize = offset;
-      const multihashCode = (
-        /** @type {A} */
-        next()
-      );
-      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).
-     *
-     * @template {string} Prefix
-     * @template {unknown} Data
-     * @template {number} Code
-     * @template {number} Alg
-     * @template {API.Version} Ver
-     * @param {API.ToString<API.Link<Data, Code, Alg, Ver>, Prefix>} source
-     * @param {API.MultibaseDecoder<Prefix>} [base]
-     * @returns {CID<Data, Code, Alg, Ver>}
-     */
-    static parse(source, base3) {
-      const [prefix, bytes] = parseCIDtoBytes2(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");
-      }
-      baseCache2(cid).set(prefix, source);
-      return cid;
-    }
-  };
-  var parseCIDtoBytes2 = (source, base3) => {
-    switch (source[0]) {
-      case "Q": {
-        const decoder = base3 || base58btc2;
-        return [
-          /** @type {Prefix} */
-          base58btc2.prefix,
-          decoder.decode(`${base58btc2.prefix}${source}`)
-        ];
-      }
-      case base58btc2.prefix: {
-        const decoder = base3 || base58btc2;
-        return [
-          /** @type {Prefix} */
-          base58btc2.prefix,
-          decoder.decode(source)
-        ];
-      }
-      case base322.prefix: {
-        const decoder = base3 || base322;
-        return [
-          /** @type {Prefix} */
-          base322.prefix,
-          decoder.decode(source)
-        ];
-      }
-      default: {
-        if (base3 == null) {
-          throw Error(
-            "To parse non base32 or base58btc encoded CID multibase decoder must be provided"
-          );
-        }
-        return [
-          /** @type {Prefix} */
-          source[0],
-          base3.decode(source)
-        ];
-      }
-    }
-  };
-  var toStringV02 = (bytes, cache3, base3) => {
-    const { prefix } = base3;
-    if (prefix !== base58btc2.prefix) {
-      throw Error(`Cannot string encode V0 in ${base3.name} encoding`);
-    }
-    const cid = cache3.get(prefix);
-    if (cid == null) {
-      const cid2 = base3.encode(bytes).slice(1);
-      cache3.set(prefix, cid2);
-      return cid2;
-    } else {
-      return cid;
-    }
-  };
-  var toStringV12 = (bytes, cache3, base3) => {
-    const { prefix } = base3;
-    const cid = cache3.get(prefix);
-    if (cid == null) {
-      const cid2 = base3.encode(bytes);
-      cache3.set(prefix, cid2);
-      return cid2;
-    } else {
-      return cid;
-    }
-  };
-  var DAG_PB_CODE2 = 112;
-  var SHA_256_CODE2 = 18;
-  var encodeCID2 = (version, code2, multihash) => {
-    const codeOffset = encodingLength2(version);
-    const hashOffset = codeOffset + encodingLength2(code2);
-    const bytes = new Uint8Array(hashOffset + multihash.byteLength);
-    encodeTo2(version, bytes, 0);
-    encodeTo2(code2, bytes, codeOffset);
-    bytes.set(multihash, hashOffset);
-    return bytes;
-  };
-  var cidSymbol2 = Symbol.for("@ipld/js-cid/CID");
-
-  // node_modules/@alanshaw/pail/node_modules/multiformats/src/hashes/hasher.js
-  var from4 = ({ name: name2, code: code2, encode: encode9 }) => new Hasher2(name2, code2, encode9);
-  var Hasher2 = class {
-    /**
-     *
-     * @param {Name} name
-     * @param {Code} code
-     * @param {(input: Uint8Array) => Await<Uint8Array>} encode
-     */
-    constructor(name2, code2, encode9) {
-      this.name = name2;
-      this.code = code2;
-      this.encode = encode9;
-    }
-    /**
-     * @param {Uint8Array} input
-     * @returns {Await<Digest.Digest<Code, number>>}
-     */
-    digest(input) {
-      if (input instanceof Uint8Array) {
-        const result = this.encode(input);
-        return result instanceof Uint8Array ? create3(this.code, result) : result.then((digest) => create3(this.code, digest));
-      } else {
-        throw Error("Unknown type, must be binary type");
-      }
-    }
-  };
-
-  // node_modules/@alanshaw/pail/node_modules/multiformats/src/block.js
-  function readonly2({ enumerable = true, configurable = false } = {}) {
-    return { enumerable, configurable, writable: false };
-  }
-  function* linksWithin2(path, value) {
-    if (value != null && typeof value === "object") {
-      if (Array.isArray(value)) {
-        for (const [index, element] of value.entries()) {
-          const elementPath = [...path, index];
-          const cid = CID2.asCID(element);
-          if (cid) {
-            yield [elementPath.join("/"), cid];
-          } else if (typeof element === "object") {
-            yield* __yieldStar(links2(element, elementPath));
-          }
-        }
-      } else {
-        const cid = CID2.asCID(value);
-        if (cid) {
-          yield [path.join("/"), cid];
-        } else {
-          yield* __yieldStar(links2(value, path));
-        }
-      }
-    }
-  }
-  function* links2(source, base3) {
-    if (source == null || source instanceof Uint8Array) {
-      return;
-    }
-    const cid = CID2.asCID(source);
-    if (cid) {
-      yield [base3.join("/"), cid];
-    }
-    for (const [key, value] of Object.entries(source)) {
-      const path = (
-        /** @type {[string|number, string]} */
-        [...base3, key]
-      );
-      yield* __yieldStar(linksWithin2(path, value));
-    }
-  }
-  function* treeWithin2(path, value) {
-    if (Array.isArray(value)) {
-      for (const [index, element] of value.entries()) {
-        const elementPath = [...path, index];
-        yield elementPath.join("/");
-        if (typeof element === "object" && !CID2.asCID(element)) {
-          yield* __yieldStar(tree2(element, elementPath));
-        }
-      }
-    } else {
-      yield* __yieldStar(tree2(value, path));
-    }
-  }
-  function* tree2(source, base3) {
-    if (source == null || typeof source !== "object") {
-      return;
-    }
-    for (const [key, value] of Object.entries(source)) {
-      const path = (
-        /** @type {[string|number, string]} */
-        [...base3, key]
-      );
-      yield path.join("/");
-      if (value != null && !(value instanceof Uint8Array) && typeof value === "object" && !CID2.asCID(value)) {
-        yield* __yieldStar(treeWithin2(path, value));
-      }
-    }
-  }
-  function get2(source, path) {
-    let node = (
-      /** @type {Record<string, any>} */
-      source
-    );
-    for (const [index, key] of path.entries()) {
-      node = node[key];
-      if (node == null) {
-        throw new Error(`Object has no property at ${path.slice(0, index + 1).map((part) => `[${JSON.stringify(part)}]`).join("")}`);
-      }
-      const cid = CID2.asCID(node);
-      if (cid) {
-        return { value: cid, remaining: path.slice(index + 1).join("/") };
-      }
-    }
-    return { value: node };
-  }
-  var Block2 = class {
-    /**
-     * @param {object} options
-     * @param {CID<T, C, A, V>} options.cid
-     * @param {API.ByteView<T>} options.bytes
-     * @param {T} options.value
-     */
-    constructor({ cid, bytes, value }) {
-      if (!cid || !bytes || typeof value === "undefined") {
-        throw new Error("Missing required argument");
-      }
-      this.cid = cid;
-      this.bytes = bytes;
-      this.value = value;
-      this.asBlock = this;
-      Object.defineProperties(this, {
-        cid: readonly2(),
-        bytes: readonly2(),
-        value: readonly2(),
-        asBlock: readonly2()
-      });
-    }
-    links() {
-      return links2(this.value, []);
-    }
-    tree() {
-      return tree2(this.value, []);
-    }
-    /**
-     *
-     * @param {string} [path]
-     * @returns {API.BlockCursorView<unknown>}
-     */
-    get(path = "/") {
-      return get2(this.value, path.split("/").filter(Boolean));
-    }
-  };
-  function encode8(_0) {
-    return __async(this, arguments, function* ({ value, codec, hasher }) {
-      if (typeof value === "undefined")
-        throw new Error('Missing required argument "value"');
-      if (!codec || !hasher)
-        throw new Error("Missing required argument: codec or hasher");
-      const bytes = codec.encode(value);
-      const hash = yield hasher.digest(bytes);
-      const cid = CID2.create(
-        1,
-        codec.code,
-        hash
-      );
-      return new Block2({ value, bytes, cid });
-    });
-  }
-  function decode12(_0) {
-    return __async(this, arguments, function* ({ bytes, codec, hasher }) {
-      if (!bytes)
-        throw new Error('Missing required argument "bytes"');
-      if (!codec || !hasher)
-        throw new Error("Missing required argument: codec or hasher");
-      const value = codec.decode(bytes);
-      const hash = yield hasher.digest(bytes);
-      const cid = CID2.create(1, codec.code, hash);
-      return new Block2({ value, bytes, cid });
-    });
-  }
-
-  // node_modules/@alanshaw/pail/node_modules/multiformats/src/hashes/sha2-browser.js
-  var sha2 = (name2) => (
-    /**
-     * @param {Uint8Array} data
-     */
-    (data) => __async(void 0, null, function* () {
-      return new Uint8Array(yield crypto.subtle.digest(name2, data));
-    })
-  );
-  var sha2562 = from4({
-    name: "sha2-256",
-    code: 18,
-    encode: sha2("SHA-256")
-  });
-  var sha5122 = from4({
-    name: "sha2-512",
-    code: 19,
-    encode: sha2("SHA-512")
-  });
-
-  // node_modules/@alanshaw/pail/src/clock.js
-  function advance(blocks, head, event) {
-    return __async(this, null, function* () {
-      const events = new EventFetcher(blocks);
-      const headmap = new Map(head.map((cid) => [cid.toString(), cid]));
-      if (headmap.has(event.toString()))
-        return head;
-      let changed = false;
-      for (const cid of head) {
-        if (yield contains(events, event, cid)) {
-          headmap.delete(cid.toString());
-          headmap.set(event.toString(), event);
-          changed = true;
-        }
-      }
-      if (changed) {
-        return [...headmap.values()];
-      }
-      for (const p of head) {
-        if (yield contains(events, p, event)) {
-          return head;
-        }
-      }
-      return head.concat(event);
-    });
-  }
-  var EventBlock = class extends Block2 {
-    /**
-     * @param {object} config
-     * @param {EventLink<T>} config.cid
-     * @param {Event} config.value
-     * @param {Uint8Array} config.bytes
-     * @param {string} config.prefix
-     */
-    constructor({ cid, value, bytes, prefix }) {
-      super({ cid, value, bytes });
-      this.prefix = prefix;
-    }
-    /**
-     * @template T
-     * @param {T} data
-     * @param {EventLink<T>[]} [parents]
-     */
-    static create(data, parents) {
-      return encodeEventBlock({ data, parents: parents != null ? parents : [] });
-    }
-  };
-  var EventFetcher = class {
-    /** @param {import('./block').BlockFetcher} blocks */
-    constructor(blocks) {
-      this._blocks = blocks;
-    }
-    /**
-     * @param {EventLink<T>} link
-     * @returns {Promise<EventBlockView<T>>}
-     */
-    get(link) {
-      return __async(this, null, function* () {
-        const block = yield this._blocks.get(link);
-        if (!block)
-          throw new Error(`missing block: ${link}`);
-        return decodeEventBlock(block.bytes);
-      });
-    }
-  };
-  function encodeEventBlock(value) {
-    return __async(this, null, function* () {
-      const { cid, bytes } = yield encode8({ value, codec: src_exports, hasher: sha2562 });
-      return new Block2({ cid, value, bytes });
-    });
-  }
-  function decodeEventBlock(bytes) {
-    return __async(this, null, function* () {
-      const { cid, value } = yield decode12({ bytes, codec: src_exports, hasher: sha2562 });
-      return new Block2({ cid, value, bytes });
-    });
-  }
-  function contains(events, a, b) {
-    return __async(this, null, function* () {
-      if (a.toString() === b.toString())
-        return true;
-      const [{ value: aevent }, { value: bevent }] = yield Promise.all([events.get(a), events.get(b)]);
-      const links3 = [...aevent.parents];
-      while (links3.length) {
-        const link = links3.shift();
-        if (!link)
-          break;
-        if (link.toString() === b.toString())
-          return true;
-        if (bevent.parents.some((p) => link.toString() === p.toString()))
-          continue;
-        const { value: event } = yield events.get(link);
-        links3.push(...event.parents);
-      }
-      return false;
-    });
-  }
-
-  // node_modules/@alanshaw/pail/src/shard.js
-  var ShardBlock = class extends Block2 {
-    /**
-     * @param {object} config
-     * @param {ShardLink} config.cid
-     * @param {Shard} config.value
-     * @param {Uint8Array} config.bytes
-     * @param {string} config.prefix
-     */
-    constructor({ cid, value, bytes, prefix }) {
-      super({ cid, value, bytes });
-      this.prefix = prefix;
-    }
-    static create() {
-      return encodeShardBlock([]);
-    }
-  };
-  function encodeShardBlock(value, prefix) {
-    return __async(this, null, function* () {
-      const { cid, bytes } = yield encode8({ value, codec: src_exports, hasher: sha2562 });
-      return new ShardBlock({ cid, value, bytes, prefix: prefix != null ? prefix : "" });
-    });
-  }
-  function decodeShardBlock(bytes, prefix) {
-    return __async(this, null, function* () {
-      const { cid, value } = yield decode12({ bytes, codec: src_exports, hasher: sha2562 });
-      if (!Array.isArray(value))
-        throw new Error(`invalid shard: ${cid}`);
-      return new ShardBlock({ cid, value, bytes, prefix: prefix != null ? prefix : "" });
-    });
-  }
-  var ShardFetcher = class {
-    /** @param {import('./block').BlockFetcher} blocks */
-    constructor(blocks) {
-      this._blocks = blocks;
-    }
-    /**
-     * @param {ShardLink} link
-     * @param {string} [prefix]
-     * @returns {Promise<ShardBlockView>}
-     */
-    get(link, prefix = "") {
-      return __async(this, null, function* () {
-        const block = yield this._blocks.get(link);
-        if (!block)
-          throw new Error(`missing block: ${link}`);
-        return decodeShardBlock(block.bytes, prefix);
-      });
-    }
-  };
-  function putEntry(target, entry) {
-    if (!target.length)
-      return [entry];
-    const shard = [];
-    for (const [i, [k, v]] of target.entries()) {
-      if (entry[0] === k) {
-        if (Array.isArray(entry[1])) {
-          if (Array.isArray(v) && v[1] != null && entry[1][1] == null) {
-            shard.push([k, [entry[1][0], v[1]]]);
-          } else {
-            shard.push(entry);
-          }
-        } else {
-          const newEntry = Array.isArray(v) ? [k, [v[0], entry[1]]] : entry;
-          shard.push(newEntry);
-        }
-        for (let j = i + 1; j < target.length; j++) {
-          shard.push(target[j]);
-        }
-        return shard;
-      }
-      if (i === 0 && entry[0] < k) {
-        shard.push(entry);
-        for (let j = i; j < target.length; j++) {
-          shard.push(target[j]);
-        }
-        return shard;
-      }
-      if (i > 0 && entry[0] > target[i - 1][0] && entry[0] < k) {
-        shard.push(entry);
-        for (let j = i; j < target.length; j++) {
-          shard.push(target[j]);
-        }
-        return shard;
-      }
-      shard.push([k, v]);
-    }
-    shard.push(entry);
-    return shard;
-  }
-  function findCommonPrefix(shard, skey) {
-    const startidx = shard.findIndex(([k]) => skey === k);
-    if (startidx === -1)
-      throw new Error(`key not found in shard: ${skey}`);
-    let i = startidx;
-    let pfx;
-    while (true) {
-      pfx = shard[i][0].slice(0, -1);
-      if (pfx.length) {
-        while (true) {
-          const matches = shard.filter((entry) => entry[0].startsWith(pfx));
-          if (matches.length > 1)
-            return { prefix: pfx, matches };
-          pfx = pfx.slice(0, -1);
-          if (!pfx.length)
-            break;
-        }
-      }
-      i++;
-      if (i >= shard.length) {
-        i = 0;
-      }
-      if (i === startidx) {
-        return;
-      }
-    }
-  }
-
-  // node_modules/@alanshaw/pail/src/index.js
-  var MaxKeyLength = 64;
-  var MaxShardSize = 512 * 1024;
-  function put(_0, _1, _2, _3) {
-    return __async(this, arguments, function* (blocks, root2, key, value, options = {}) {
-      var _a;
-      const shards = new ShardFetcher(blocks);
-      const rshard = yield shards.get(root2);
-      const path = yield traverse(shards, rshard, key);
-      const target = path[path.length - 1];
-      const skey = key.slice(target.prefix.length);
-      let entry = [skey, value];
-      const additions = [];
-      if (skey.length > MaxKeyLength) {
-        const pfxskeys = Array.from(Array(Math.ceil(skey.length / MaxKeyLength)), (_, i) => {
-          const start = i * MaxKeyLength;
-          return {
-            prefix: target.prefix + skey.slice(0, start),
-            skey: skey.slice(start, start + MaxKeyLength)
-          };
-        });
-        let child2 = yield encodeShardBlock([[pfxskeys[pfxskeys.length - 1].skey, value]], pfxskeys[pfxskeys.length - 1].prefix);
-        additions.push(child2);
-        for (let i = pfxskeys.length - 2; i > 0; i--) {
-          child2 = yield encodeShardBlock([[pfxskeys[i].skey, [child2.cid]]], pfxskeys[i].prefix);
-          additions.push(child2);
-        }
-        entry = [pfxskeys[0].skey, [child2.cid]];
-      }
-      let shard = putEntry(target.value, entry);
-      let child = yield encodeShardBlock(shard, target.prefix);
-      if (child.bytes.length > ((_a = options.maxShardSize) != null ? _a : MaxShardSize)) {
-        const common = findCommonPrefix(shard, entry[0]);
-        if (!common)
-          throw new Error("shard limit reached");
-        const { prefix, matches } = common;
-        const block = yield encodeShardBlock(
-          matches.filter(([k]) => k !== prefix).map(([k, v]) => [k.slice(prefix.length), v]),
-          target.prefix + prefix
-        );
-        additions.push(block);
-        let value2;
-        const pfxmatch = matches.find(([k]) => k === prefix);
-        if (pfxmatch) {
-          if (Array.isArray(pfxmatch[1])) {
-            throw new Error(`expected "${prefix}" to be a shard value but found a shard link`);
-          }
-          value2 = [block.cid, pfxmatch[1]];
-        } else {
-          value2 = [block.cid];
-        }
-        shard = shard.filter((e) => matches.every((m) => e[0] !== m[0]));
-        shard = putEntry(shard, [prefix, value2]);
-        child = yield encodeShardBlock(shard, target.prefix);
-      }
-      additions.push(child);
-      for (let i = path.length - 2; i >= 0; i--) {
-        const parent = path[i];
-        const key2 = child.prefix.slice(parent.prefix.length);
-        const value2 = parent.value.map((entry2) => {
-          const [k, v] = entry2;
-          if (k !== key2)
-            return entry2;
-          if (!Array.isArray(v))
-            throw new Error(`"${key2}" is not a shard link in: ${parent.cid}`);
-          return (
-            /** @type {import('./shard').ShardEntry} */
-            v[1] == null ? [k, [child.cid]] : [k, [child.cid, v[1]]]
-          );
-        });
-        child = yield encodeShardBlock(value2, parent.prefix);
-        additions.push(child);
-      }
-      return { root: additions[additions.length - 1].cid, additions, removals: path };
-    });
-  }
-  function get3(blocks, root2, key) {
-    return __async(this, null, function* () {
-      const shards = new ShardFetcher(blocks);
-      const rshard = yield shards.get(root2);
-      const path = yield traverse(shards, rshard, key);
-      const target = path[path.length - 1];
-      const skey = key.slice(target.prefix.length);
-      const entry = target.value.find(([k]) => k === skey);
-      if (!entry)
-        return;
-      return Array.isArray(entry[1]) ? entry[1][1] : entry[1];
-    });
-  }
-  function del(blocks, root2, key) {
-    return __async(this, null, function* () {
-      const shards = new ShardFetcher(blocks);
-      const rshard = yield shards.get(root2);
-      const path = yield traverse(shards, rshard, key);
-      const target = path[path.length - 1];
-      const skey = key.slice(target.prefix.length);
-      const entryidx = target.value.findIndex(([k]) => k === skey);
-      if (entryidx === -1)
-        return { root: root2, additions: [], removals: [] };
-      const entry = target.value[entryidx];
-      if (Array.isArray(entry[1]) && entry[1][1] == null)
-        return { root: root2, additions: [], removals: [] };
-      const additions = [];
-      const removals = [...path];
-      let shard = [...target.value];
-      if (Array.isArray(entry[1])) {
-        shard[entryidx] = [entry[0], [entry[1][0]]];
-      } else {
-        shard.splice(entryidx, 1);
-        while (!shard.length) {
-          const child2 = path[path.length - 1];
-          const parent = path[path.length - 2];
-          if (!parent)
-            break;
-          path.pop();
-          shard = parent.value.filter((e) => {
-            if (!Array.isArray(e[1]))
-              return true;
-            return e[1][0].toString() !== child2.cid.toString();
-          });
-        }
-      }
-      let child = yield encodeShardBlock(shard, path[path.length - 1].prefix);
-      additions.push(child);
-      for (let i = path.length - 2; i >= 0; i--) {
-        const parent = path[i];
-        const key2 = child.prefix.slice(parent.prefix.length);
-        const value = parent.value.map((entry2) => {
-          const [k, v] = entry2;
-          if (k !== key2)
-            return entry2;
-          if (!Array.isArray(v))
-            throw new Error(`"${key2}" is not a shard link in: ${parent.cid}`);
-          return (
-            /** @type {import('./shard').ShardEntry} */
-            v[1] == null ? [k, [child.cid]] : [k, [child.cid, v[1]]]
-          );
-        });
-        child = yield encodeShardBlock(value, parent.prefix);
-        additions.push(child);
-      }
-      return { root: additions[additions.length - 1].cid, additions, removals };
-    });
-  }
-  function traverse(shards, shard, key) {
-    return __async(this, null, function* () {
-      for (const [k, v] of shard.value) {
-        if (key === k)
-          return [shard];
-        if (key.startsWith(k) && Array.isArray(v)) {
-          const path = yield traverse(shards, yield shards.get(v[0], shard.prefix + k), key.slice(k.length));
-          return [shard, ...path];
-        }
-      }
-      return [shard];
-    });
-  }
-
-  // node_modules/@alanshaw/pail/node_modules/multiformats/src/link.js
-  var parse = (source, base3) => CID2.parse(source, base3);
-
-  // node_modules/@alanshaw/pail/src/block.js
-  var _blocks;
-  var MemoryBlockstore = class {
-    /**
-     * @param {Array<AnyBlock>} [blocks]
-     */
-    constructor(blocks) {
-      /** @type {Map<string, Uint8Array>} */
-      __privateAdd(this, _blocks, /* @__PURE__ */ new Map());
-      if (blocks) {
-        __privateSet(this, _blocks, new Map(blocks.map((b) => [b.cid.toString(), b.bytes])));
-      }
-    }
-    /**
-     * @param {import('./link').AnyLink} cid
-     * @returns {Promise<AnyBlock | undefined>}
-     */
-    get(cid) {
-      return __async(this, null, function* () {
-        const bytes = __privateGet(this, _blocks).get(cid.toString());
-        if (!bytes)
-          return;
-        return { cid, bytes };
-      });
-    }
-    /**
-     * @param {import('./link').AnyLink} cid
-     * @param {Uint8Array} bytes
-     */
-    put(cid, bytes) {
-      return __async(this, null, function* () {
-        __privateGet(this, _blocks).set(cid.toString(), bytes);
-      });
-    }
-    /**
-     * @param {import('./link').AnyLink} cid
-     * @param {Uint8Array} bytes
-     */
-    putSync(cid, bytes) {
-      __privateGet(this, _blocks).set(cid.toString(), bytes);
-    }
-    /** @param {import('./link').AnyLink} cid */
-    delete(cid) {
-      return __async(this, null, function* () {
-        __privateGet(this, _blocks).delete(cid.toString());
-      });
-    }
-    /** @param {import('./link').AnyLink} cid */
-    deleteSync(cid) {
-      __privateGet(this, _blocks).delete(cid.toString());
-    }
-    *entries() {
-      for (const [str, bytes] of __privateGet(this, _blocks)) {
-        yield { cid: parse(str), bytes };
-      }
-    }
-  };
-  _blocks = new WeakMap();
-  var _fetchers;
-  var MultiBlockFetcher = class {
-    /** @param {BlockFetcher[]} fetchers */
-    constructor(...fetchers) {
-      /** @type {BlockFetcher[]} */
-      __privateAdd(this, _fetchers, void 0);
-      __privateSet(this, _fetchers, fetchers);
-    }
-    /** @param {import('./link').AnyLink} link */
-    get(link) {
-      return __async(this, null, function* () {
-        for (const f of __privateGet(this, _fetchers)) {
-          const v = yield f.get(link);
-          if (v)
-            return v;
-        }
-      });
-    }
-  };
-  _fetchers = new WeakMap();
-
-  // node_modules/@alanshaw/pail/src/crdt.js
-  function put2(blocks, head, key, value, options) {
-    return __async(this, null, function* () {
-      const mblocks = new MemoryBlockstore();
-      blocks = new MultiBlockFetcher(mblocks, blocks);
-      if (!head.length) {
-        const shard = yield ShardBlock.create();
-        mblocks.putSync(shard.cid, shard.bytes);
-        const result2 = yield put(blocks, shard.cid, key, value, options);
-        const data2 = { type: "put", root: result2.root, key, value };
-        const event2 = yield EventBlock.create(data2, head);
-        head = yield advance(blocks, head, event2.cid);
-        return {
-          root: result2.root,
-          additions: [shard, ...result2.additions],
-          removals: result2.removals,
-          head,
-          event: event2
-        };
-      }
-      const events = new EventFetcher(blocks);
-      const ancestor = yield findCommonAncestor(events, head);
-      if (!ancestor)
-        throw new Error("failed to find common ancestor event");
-      const aevent = yield events.get(ancestor);
-      let { root: root2 } = aevent.value.data;
-      const sorted = yield findSortedEvents(events, head, ancestor);
-      const additions = /* @__PURE__ */ new Map();
-      const removals = /* @__PURE__ */ new Map();
-      for (const { value: event2 } of sorted) {
-        if (!["put", "del"].includes(event2.data.type)) {
-          throw new Error(`unknown event type: ${event2.data.type}`);
-        }
-        const result2 = event2.data.type === "put" ? yield put(blocks, root2, event2.data.key, event2.data.value) : yield del(blocks, root2, event2.data.key);
-        root2 = result2.root;
-        for (const a of result2.additions) {
-          mblocks.putSync(a.cid, a.bytes);
-          additions.set(a.cid.toString(), a);
-        }
-        for (const r of result2.removals) {
-          removals.set(r.cid.toString(), r);
-        }
-      }
-      const result = yield put(blocks, root2, key, value, options);
-      for (const a of result.additions) {
-        mblocks.putSync(a.cid, a.bytes);
-        additions.set(a.cid.toString(), a);
-      }
-      for (const r of result.removals) {
-        removals.set(r.cid.toString(), r);
-      }
-      const data = { type: "put", root: result.root, key, value };
-      const event = yield EventBlock.create(data, head);
-      mblocks.putSync(event.cid, event.bytes);
-      head = yield advance(blocks, head, event.cid);
-      for (const k of removals.keys()) {
-        if (additions.has(k)) {
-          additions.delete(k);
-          removals.delete(k);
-        }
-      }
-      return {
-        root: result.root,
-        additions: [...additions.values()],
-        removals: [...removals.values()],
-        head,
-        event
-      };
-    });
-  }
-  function root(blocks, head) {
-    return __async(this, null, function* () {
-      if (!head.length)
-        throw new Error("cannot determine root of headless clock");
-      const mblocks = new MemoryBlockstore();
-      blocks = new MultiBlockFetcher(mblocks, blocks);
-      const events = new EventFetcher(blocks);
-      if (head.length === 1) {
-        const event = yield events.get(head[0]);
-        const { root: root3 } = event.value.data;
-        return { root: root3, additions: [], removals: [] };
-      }
-      const ancestor = yield findCommonAncestor(events, head);
-      if (!ancestor)
-        throw new Error("failed to find common ancestor event");
-      const aevent = yield events.get(ancestor);
-      let { root: root2 } = aevent.value.data;
-      const sorted = yield findSortedEvents(events, head, ancestor);
-      const additions = /* @__PURE__ */ new Map();
-      const removals = /* @__PURE__ */ new Map();
-      for (const { value: event } of sorted) {
-        if (!["put", "del"].includes(event.data.type)) {
-          throw new Error(`unknown event type: ${event.data.type}`);
-        }
-        const result = event.data.type === "put" ? yield put(blocks, root2, event.data.key, event.data.value) : yield del(blocks, root2, event.data.key);
-        root2 = result.root;
-        for (const a of result.additions) {
-          mblocks.putSync(a.cid, a.bytes);
-          additions.set(a.cid.toString(), a);
-        }
-        for (const r of result.removals) {
-          removals.set(r.cid.toString(), r);
-        }
-      }
-      for (const k of removals.keys()) {
-        if (additions.has(k)) {
-          additions.delete(k);
-          removals.delete(k);
-        }
-      }
-      return {
-        root: root2,
-        additions: [...additions.values()],
-        removals: [...removals.values()]
-      };
-    });
-  }
-  function get4(blocks, head, key) {
-    return __async(this, null, function* () {
-      if (!head.length)
-        return;
-      const result = yield root(blocks, head);
-      if (result.additions.length) {
-        blocks = new MultiBlockFetcher(new MemoryBlockstore(result.additions), blocks);
-      }
-      return get3(blocks, result.root, key);
-    });
-  }
-  function findCommonAncestor(events, children) {
-    return __async(this, null, function* () {
-      if (!children.length)
-        return;
-      const candidates = children.map((c) => [c]);
-      while (true) {
-        let changed = false;
-        for (const c of candidates) {
-          const candidate = yield findAncestorCandidate(events, c[c.length - 1]);
-          if (!candidate)
-            continue;
-          changed = true;
-          c.push(candidate);
-          const ancestor = findCommonString(candidates);
-          if (ancestor)
-            return ancestor;
-        }
-        if (!changed)
-          return;
-      }
-    });
-  }
-  function findAncestorCandidate(events, root2) {
-    return __async(this, null, function* () {
-      const { value: event } = yield events.get(root2);
-      if (!event.parents.length)
-        return root2;
-      return event.parents.length === 1 ? event.parents[0] : findCommonAncestor(events, event.parents);
-    });
-  }
-  function findCommonString(arrays) {
-    arrays = arrays.map((a) => [...a]);
-    for (const arr of arrays) {
-      for (const item of arr) {
-        let matched = true;
-        for (const other of arrays) {
-          if (arr === other)
-            continue;
-          matched = other.some((i) => String(i) === String(item));
-          if (!matched)
-            break;
-        }
-        if (matched)
-          return item;
-      }
-    }
-  }
-  function findSortedEvents(events, head, tail) {
-    return __async(this, null, function* () {
-      const weights = /* @__PURE__ */ new Map();
-      const all = yield Promise.all(head.map((h) => findEvents(events, h, tail)));
-      for (const arr of all) {
-        for (const { event, depth } of arr) {
-          const info = weights.get(event.cid.toString());
-          if (info) {
-            info.weight += depth;
-          } else {
-            weights.set(event.cid.toString(), { event, weight: depth });
-          }
-        }
-      }
-      const buckets = /* @__PURE__ */ new Map();
-      for (const { event, weight } of weights.values()) {
-        const bucket = buckets.get(weight);
-        if (bucket) {
-          bucket.push(event);
-        } else {
-          buckets.set(weight, [event]);
-        }
-      }
-      return Array.from(buckets).sort((a, b) => b[0] - a[0]).flatMap(([, es]) => es.sort((a, b) => String(a.cid) < String(b.cid) ? -1 : 1));
-    });
-  }
-  function findEvents(events, start, end, depth = 0) {
-    return __async(this, null, function* () {
-      const event = yield events.get(start);
-      const acc = [{ event, depth }];
-      const { parents } = event.value;
-      if (parents.length === 1 && String(parents[0]) === String(end))
-        return acc;
-      const rest = yield Promise.all(parents.map((p) => findEvents(events, p, end, depth + 1)));
-      return acc.concat(...rest);
-    });
-  }
-
-  // src/crdt-helpers.ts
-  function makeGetBlock(blocks) {
-    return (address) => __async(this, null, function* () {
-      const block = yield blocks.get(address);
-      if (!block)
-        throw new Error(`Missing block ${address.toString()}`);
-      const { cid, bytes } = block;
-      return create2({ cid, bytes, hasher: sha256, codec: src_exports });
-    });
-  }
-  function applyBulkUpdateToCrdt(tblocks, head, updates, options) {
-    return __async(this, null, function* () {
-      for (const update of updates) {
-        const link = yield makeLinkForDoc(tblocks, update);
-        const result = yield put2(tblocks, head, update.key, link, options);
-        for (const { cid, bytes } of [...result.additions, ...result.removals, result.event]) {
-          tblocks.putSync(cid, bytes);
-        }
-        head = result.head;
-      }
-      return { head };
-    });
-  }
-  function makeLinkForDoc(blocks, update) {
-    return __async(this, null, function* () {
-      let value;
-      if (update.del) {
-        value = { del: true };
-      } else {
-        value = { doc: update.value };
-      }
-      const block = yield encode3({ value, hasher: sha256, codec: src_exports });
-      blocks.putSync(block.cid, block.bytes);
-      return block.cid;
-    });
-  }
-  function getValueFromCrdt(blocks, head, key) {
-    return __async(this, null, function* () {
-      const link = yield get4(blocks, head, key);
-      if (!link)
-        throw new Error(`Missing key ${key}`);
-      return yield getValueFromLink(blocks, link);
-    });
-  }
-  function getValueFromLink(blocks, link) {
-    return __async(this, null, function* () {
-      const block = yield blocks.get(link);
-      if (!block)
-        throw new Error(`Missing block ${link.toString()}`);
-      const { value } = yield decode5({ bytes: block.bytes, hasher: sha256, codec: src_exports });
-      return value;
-    });
-  }
-  function clockChangesSince(blocks, _head, _since) {
-    return __async(this, null, function* () {
-      const eventsFetcher = new EventFetcher(blocks);
-      const updates = yield gatherUpdates(blocks, eventsFetcher, _head, _since);
-      return { result: updates.reverse() };
-    });
-  }
-  function gatherUpdates(_0, _1, _2, _3) {
-    return __async(this, arguments, function* (blocks, eventsFetcher, head, since, updates = []) {
-      for (const link of since) {
-        if (head.includes(link)) {
-          throw new Error("found since in head, this is good, remove this error " + updates.length);
-          return updates;
-        }
-      }
-      for (const link of head) {
-        const { value: event } = yield eventsFetcher.get(link);
-        const { key, value } = event.data;
-        const docValue = yield getValueFromLink(blocks, value);
-        updates.push({ key, value: docValue.doc, del: docValue.del });
-        if (event.parents) {
-          updates = yield gatherUpdates(blocks, eventsFetcher, event.parents, since, updates);
-        }
-      }
-      return updates;
-    });
-  }
-})();
-//# sourceMappingURL=crdt-helpers.browser.js.map