@fireproof/core 0.10.0-dev → 0.10.1-dev

package/dist/loader-helpers.esm.js

@@ -1,4408 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name3 in all)
-    __defProp(target, name3, { get: all[name3], enumerable: true });
-};
-var __copyProps = (to, from3, except, desc) => {
-  if (from3 && typeof from3 === "object" || typeof from3 === "function") {
-    for (let key of __getOwnPropNames(from3))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from3[key], enumerable: !(desc = __getOwnPropDesc(from3, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// node_modules/varint/encode.js
-var require_encode = __commonJS({
-  "node_modules/varint/encode.js"(exports, module) {
-    module.exports = encode8;
-    var MSB2 = 128;
-    var REST2 = 127;
-    var MSBALL2 = ~REST2;
-    var INT2 = Math.pow(2, 31);
-    function encode8(num, out, offset) {
-      if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
-        encode8.bytes = 0;
-        throw new RangeError("Could not encode varint");
-      }
-      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;
-      encode8.bytes = offset - oldOffset + 1;
-      return out;
-    }
-  }
-});
-
-// node_modules/varint/decode.js
-var require_decode = __commonJS({
-  "node_modules/varint/decode.js"(exports, module) {
-    module.exports = read2;
-    var MSB2 = 128;
-    var REST2 = 127;
-    function read2(buf3, offset) {
-      var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf3.length;
-      do {
-        if (counter >= l || shift > 49) {
-          read2.bytes = 0;
-          throw new RangeError("Could not decode varint");
-        }
-        b = buf3[counter++];
-        res += shift < 28 ? (b & REST2) << shift : (b & REST2) * Math.pow(2, shift);
-        shift += 7;
-      } while (b >= MSB2);
-      read2.bytes = counter - offset;
-      return res;
-    }
-  }
-});
-
-// node_modules/varint/length.js
-var require_length = __commonJS({
-  "node_modules/varint/length.js"(exports, module) {
-    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);
-    module.exports = 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;
-    };
-  }
-});
-
-// node_modules/varint/index.js
-var require_varint = __commonJS({
-  "node_modules/varint/index.js"(exports, module) {
-    module.exports = {
-      encode: require_encode(),
-      decode: require_decode(),
-      encodingLength: require_length()
-    };
-  }
-});
-
-// 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(buf3, offset) {
-  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf3.length;
-  do {
-    if (counter >= l) {
-      read.bytes = 0;
-      throw new RangeError("Could not decode varint");
-    }
-    b = buf3[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 code3 = varint_default.decode(data, offset);
-  return [code3, 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 empty = new Uint8Array(0);
-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");
-};
-
-// node_modules/multiformats/src/hashes/digest.js
-var create = (code3, digest) => {
-  const size = digest.byteLength;
-  const sizeOffset = encodingLength(code3);
-  const digestOffset = sizeOffset + encodingLength(size);
-  const bytes = new Uint8Array(digestOffset + size);
-  encodeTo(code3, bytes, 0);
-  encodeTo(size, bytes, sizeOffset);
-  bytes.set(digest, digestOffset);
-  return new Digest(code3, size, digest, bytes);
-};
-var decode3 = (multihash) => {
-  const bytes = coerce(multihash);
-  const [code3, 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(code3, 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(code3, size, digest, bytes) {
-    this.code = code3;
-    this.size = size;
-    this.digest = digest;
-    this.bytes = bytes;
-  }
-};
-
-// node_modules/multiformats/vendor/base-x.js
-function base(ALPHABET, name3) {
-  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 encode8(source) {
-    if (source instanceof Uint8Array)
-      ;
-    else if (ArrayBuffer.isView(source)) {
-      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-    } else if (Array.isArray(source)) {
-      source = Uint8Array.from(source);
-    }
-    if (!(source instanceof Uint8Array)) {
-      throw new TypeError("Expected Uint8Array");
-    }
-    if (source.length === 0) {
-      return "";
-    }
-    var zeroes = 0;
-    var length2 = 0;
-    var pbegin = 0;
-    var pend = source.length;
-    while (pbegin !== pend && source[pbegin] === 0) {
-      pbegin++;
-      zeroes++;
-    }
-    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
-    var b58 = new Uint8Array(size);
-    while (pbegin !== pend) {
-      var carry = source[pbegin];
-      var i2 = 0;
-      for (var it1 = size - 1; (carry !== 0 || i2 < length2) && it1 !== -1; it1--, i2++) {
-        carry += 256 * b58[it1] >>> 0;
-        b58[it1] = carry % BASE >>> 0;
-        carry = carry / BASE >>> 0;
-      }
-      if (carry !== 0) {
-        throw new Error("Non-zero carry");
-      }
-      length2 = i2;
-      pbegin++;
-    }
-    var it2 = size - length2;
-    while (it2 !== size && b58[it2] === 0) {
-      it2++;
-    }
-    var str = LEADER.repeat(zeroes);
-    for (; it2 < size; ++it2) {
-      str += ALPHABET.charAt(b58[it2]);
-    }
-    return str;
-  }
-  function decodeUnsafe(source) {
-    if (typeof source !== "string") {
-      throw new TypeError("Expected String");
-    }
-    if (source.length === 0) {
-      return new Uint8Array();
-    }
-    var psz = 0;
-    if (source[psz] === " ") {
-      return;
-    }
-    var zeroes = 0;
-    var length2 = 0;
-    while (source[psz] === LEADER) {
-      zeroes++;
-      psz++;
-    }
-    var size = (source.length - psz) * FACTOR + 1 >>> 0;
-    var b256 = new Uint8Array(size);
-    while (source[psz]) {
-      var carry = BASE_MAP[source.charCodeAt(psz)];
-      if (carry === 255) {
-        return;
-      }
-      var i2 = 0;
-      for (var it3 = size - 1; (carry !== 0 || i2 < length2) && it3 !== -1; it3--, i2++) {
-        carry += BASE * b256[it3] >>> 0;
-        b256[it3] = carry % 256 >>> 0;
-        carry = carry / 256 >>> 0;
-      }
-      if (carry !== 0) {
-        throw new Error("Non-zero carry");
-      }
-      length2 = i2;
-      psz++;
-    }
-    if (source[psz] === " ") {
-      return;
-    }
-    var it4 = size - length2;
-    while (it4 !== size && b256[it4] === 0) {
-      it4++;
-    }
-    var vch = new Uint8Array(zeroes + (size - it4));
-    var j2 = zeroes;
-    while (it4 !== size) {
-      vch[j2++] = b256[it4++];
-    }
-    return vch;
-  }
-  function decode10(string) {
-    var buffer3 = decodeUnsafe(string);
-    if (buffer3) {
-      return buffer3;
-    }
-    throw new Error(`Non-${name3} character`);
-  }
-  return {
-    encode: encode8,
-    decodeUnsafe,
-    decode: decode10
-  };
-}
-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(name3, prefix, baseEncode) {
-    this.name = name3;
-    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(name3, prefix, baseDecode) {
-    this.name = name3;
-    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>} */
-  {
-    ...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(name3, prefix, baseEncode, baseDecode) {
-    this.name = name3;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-    this.baseDecode = baseDecode;
-    this.encoder = new Encoder(name3, prefix, baseEncode);
-    this.decoder = new Decoder(name3, 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: name3, prefix, encode: encode8, decode: decode10 }) => new Codec(name3, prefix, encode8, decode10);
-var baseX = ({ prefix, name: name3, alphabet }) => {
-  const { encode: encode8, decode: decode10 } = base_x_default(alphabet, name3);
-  return from({
-    prefix,
-    name: name3,
-    encode: encode8,
-    /**
-     * @param {string} text
-     */
-    decode: (text) => coerce(decode10(text))
-  });
-};
-var decode4 = (string, alphabet, bitsPerChar, name3) => {
-  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 buffer3 = 0;
-  let written = 0;
-  for (let i = 0; i < end; ++i) {
-    const value = codes[string[i]];
-    if (value === void 0) {
-      throw new SyntaxError(`Non-${name3} character`);
-    }
-    buffer3 = buffer3 << bitsPerChar | value;
-    bits += bitsPerChar;
-    if (bits >= 8) {
-      bits -= 8;
-      out[written++] = 255 & buffer3 >> bits;
-    }
-  }
-  if (bits >= bitsPerChar || 255 & buffer3 << 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 buffer3 = 0;
-  for (let i = 0; i < data.length; ++i) {
-    buffer3 = buffer3 << 8 | data[i];
-    bits += 8;
-    while (bits > bitsPerChar) {
-      bits -= bitsPerChar;
-      out += alphabet[mask & buffer3 >> bits];
-    }
-  }
-  if (bits) {
-    out += alphabet[mask & buffer3 << bitsPerChar - bits];
-  }
-  if (pad) {
-    while (out.length * bitsPerChar & 7) {
-      out += "=";
-    }
-  }
-  return out;
-};
-var rfc4648 = ({ name: name3, prefix, bitsPerChar, alphabet }) => {
-  return from({
-    prefix,
-    name: name3,
-    encode(input) {
-      return encode2(input, alphabet, bitsPerChar);
-    },
-    decode(input) {
-      return decode4(input, alphabet, bitsPerChar, name3);
-    }
-  });
-};
-
-// 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, base2) => {
-  const { bytes, version } = link;
-  switch (version) {
-    case 0:
-      return toStringV0(
-        bytes,
-        baseCache(link),
-        /** @type {API.MultibaseEncoder<"z">} */
-        base2 || base58btc.encoder
-      );
-    default:
-      return toStringV1(
-        bytes,
-        baseCache(link),
-        /** @type {API.MultibaseEncoder<Prefix>} */
-        base2 || base32.encoder
-      );
-  }
-};
-var cache = /* @__PURE__ */ new WeakMap();
-var baseCache = (cid) => {
-  const baseCache2 = cache.get(cid);
-  if (baseCache2 == null) {
-    const baseCache3 = /* @__PURE__ */ new Map();
-    cache.set(cid, baseCache3);
-    return baseCache3;
-  }
-  return baseCache2;
-};
-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, code3, multihash, bytes) {
-    this.code = code3;
-    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: code3, multihash } = this;
-        if (code3 !== 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: code3, digest } = this.multihash;
-        const multihash = create(code3, 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(base2) {
-    return format(this, base2);
-  }
-  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: code3, multihash, bytes } = value;
-      return new _CID(
-        version,
-        code3,
-        /** @type {API.MultihashDigest<Alg>} */
-        multihash,
-        bytes || encodeCID(version, code3, multihash.bytes)
-      );
-    } else if (value[cidSymbol] === true) {
-      const { version, multihash, code: code3 } = value;
-      const digest = (
-        /** @type {API.MultihashDigest<Alg>} */
-        decode3(multihash)
-      );
-      return _CID.create(version, code3, 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, code3, digest) {
-    if (typeof code3 !== "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 (code3 !== DAG_PB_CODE) {
-          throw new Error(
-            `Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`
-          );
-        } else {
-          return new _CID(version, code3, digest, digest.bytes);
-        }
-      }
-      case 1: {
-        const bytes = encodeCID(version, code3, digest.bytes);
-        return new _CID(version, code3, 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(code3, digest) {
-    return _CID.create(1, code3, 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, length2] = decode2(initialBytes.subarray(offset));
-      offset += length2;
-      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, base2) {
-    const [prefix, bytes] = parseCIDtoBytes(source, base2);
-    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, base2) => {
-  switch (source[0]) {
-    case "Q": {
-      const decoder = base2 || base58btc;
-      return [
-        /** @type {Prefix} */
-        base58btc.prefix,
-        decoder.decode(`${base58btc.prefix}${source}`)
-      ];
-    }
-    case base58btc.prefix: {
-      const decoder = base2 || base58btc;
-      return [
-        /** @type {Prefix} */
-        base58btc.prefix,
-        decoder.decode(source)
-      ];
-    }
-    case base32.prefix: {
-      const decoder = base2 || base32;
-      return [
-        /** @type {Prefix} */
-        base32.prefix,
-        decoder.decode(source)
-      ];
-    }
-    default: {
-      if (base2 == null) {
-        throw Error(
-          "To parse non base32 or base58btc encoded CID multibase decoder must be provided"
-        );
-      }
-      return [
-        /** @type {Prefix} */
-        source[0],
-        base2.decode(source)
-      ];
-    }
-  }
-};
-var toStringV0 = (bytes, cache2, base2) => {
-  const { prefix } = base2;
-  if (prefix !== base58btc.prefix) {
-    throw Error(`Cannot string encode V0 in ${base2.name} encoding`);
-  }
-  const cid = cache2.get(prefix);
-  if (cid == null) {
-    const cid2 = base2.encode(bytes).slice(1);
-    cache2.set(prefix, cid2);
-    return cid2;
-  } else {
-    return cid;
-  }
-};
-var toStringV1 = (bytes, cache2, base2) => {
-  const { prefix } = base2;
-  const cid = cache2.get(prefix);
-  if (cid == null) {
-    const cid2 = base2.encode(bytes);
-    cache2.set(prefix, cid2);
-    return cid2;
-  } else {
-    return cid;
-  }
-};
-var DAG_PB_CODE = 112;
-var SHA_256_CODE = 18;
-var encodeCID = (version, code3, multihash) => {
-  const codeOffset = encodingLength(version);
-  const hashOffset = codeOffset + encodingLength(code3);
-  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
-  encodeTo(version, bytes, 0);
-  encodeTo(code3, 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: name3, code: code3, encode: encode8 }) => new Hasher(name3, code3, encode8);
-var Hasher = class {
-  /**
-   *
-   * @param {Name} name
-   * @param {Code} code
-   * @param {(input: Uint8Array) => Await<Uint8Array>} encode
-   */
-  constructor(name3, code3, encode8) {
-    this.name = name3;
-    this.code = code3;
-    this.encode = encode8;
-  }
-  /**
-   * @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* links(element, elementPath);
-        }
-      }
-    } else {
-      const cid = CID.asCID(value);
-      if (cid) {
-        yield [path.join("/"), cid];
-      } else {
-        yield* links(value, path);
-      }
-    }
-  }
-}
-function* links(source, base2) {
-  if (source == null || source instanceof Uint8Array) {
-    return;
-  }
-  const cid = CID.asCID(source);
-  if (cid) {
-    yield [base2.join("/"), cid];
-  }
-  for (const [key, value] of Object.entries(source)) {
-    const path = (
-      /** @type {[string|number, string]} */
-      [...base2, key]
-    );
-    yield* 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* tree(element, elementPath);
-      }
-    }
-  } else {
-    yield* tree(value, path);
-  }
-}
-function* tree(source, base2) {
-  if (source == null || typeof source !== "object") {
-    return;
-  }
-  for (const [key, value] of Object.entries(source)) {
-    const path = (
-      /** @type {[string|number, string]} */
-      [...base2, key]
-    );
-    yield path.join("/");
-    if (value != null && !(value instanceof Uint8Array) && typeof value === "object" && !CID.asCID(value)) {
-      yield* 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));
-  }
-};
-async function encode3({ 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 = await hasher.digest(bytes);
-  const cid = CID.create(
-    1,
-    codec.code,
-    hash
-  );
-  return new Block({ value, bytes, cid });
-}
-async function decode5({ 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 = await hasher.digest(bytes);
-  const cid = CID.create(1, codec.code, hash);
-  return new Block({ value, bytes, cid });
-}
-
-// node_modules/multiformats/src/hashes/sha2.js
-import crypto from "crypto";
-var sha256 = from2({
-  name: "sha2-256",
-  code: 18,
-  encode: (input) => coerce(crypto.createHash("sha256").update(input).digest())
-});
-var sha512 = from2({
-  name: "sha2-512",
-  code: 19,
-  encode: (input) => coerce(crypto.createHash("sha512").update(input).digest())
-});
-
-// node_modules/multiformats/src/codecs/raw.js
-var raw_exports = {};
-__export(raw_exports, {
-  code: () => code,
-  decode: () => decode6,
-  encode: () => encode4,
-  name: () => name
-});
-var name = "raw";
-var code = 85;
-var encode4 = (node) => coerce(node);
-var decode6 = (data) => coerce(data);
-
-// node_modules/@ipld/car/src/buffer-writer.js
-var import_varint2 = __toESM(require_varint(), 1);
-
-// 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/cborg/esm/lib/token.js
-var Type = class {
-  constructor(major, name3, terminal) {
-    this.major = major;
-    this.majorEncoded = major << 5;
-    this.name = name3;
-    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/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(buf3) {
-  return useBuffer && globalThis.Buffer.isBuffer(buf3);
-}
-function asU8A(buf3) {
-  if (!(buf3 instanceof Uint8Array)) {
-    return Uint8Array.from(buf3);
-  }
-  return isBuffer2(buf3) ? new Uint8Array(buf3.buffer, buf3.byteOffset, buf3.byteLength) : buf3;
-}
-var toString = 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 fromString = 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, length2) => {
-  chunks = chunks.map((c) => c instanceof Uint8Array ? c : globalThis.Buffer.from(c));
-  return asU8A(globalThis.Buffer.concat(chunks, length2));
-} : (chunks, length2) => {
-  const out = new Uint8Array(length2);
-  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 length2 = string.length;
-  let leadSurrogate = null;
-  const bytes = [];
-  for (let i = 0; i < length2; ++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 === length2) {
-          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(buf3, offset, end) {
-  const res = [];
-  while (offset < end) {
-    const firstByte = buf3[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 = buf3[offset + 1];
-          if ((secondByte & 192) === 128) {
-            tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
-            if (tempCodePoint > 127) {
-              codePoint = tempCodePoint;
-            }
-          }
-          break;
-        case 3:
-          secondByte = buf3[offset + 1];
-          thirdByte = buf3[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 = buf3[offset + 1];
-          thirdByte = buf3[offset + 2];
-          fourthByte = buf3[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/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/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/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(buf3, token) {
-  return encodeUintValue(buf3, 0, token.value);
-}
-function encodeUintValue(buf3, major, uint) {
-  if (uint < uintBoundaries[0]) {
-    const nuint = Number(uint);
-    buf3.push([major | nuint]);
-  } else if (uint < uintBoundaries[1]) {
-    const nuint = Number(uint);
-    buf3.push([
-      major | 24,
-      nuint
-    ]);
-  } else if (uint < uintBoundaries[2]) {
-    const nuint = Number(uint);
-    buf3.push([
-      major | 25,
-      nuint >>> 8,
-      nuint & 255
-    ]);
-  } else if (uint < uintBoundaries[3]) {
-    const nuint = Number(uint);
-    buf3.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;
-      buf3.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/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(buf3, token) {
-  const negint = token.value;
-  const unsigned = typeof negint === "bigint" ? negint * neg1b - pos1b : negint * -1 - 1;
-  encodeUintValue(buf3, 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/cborg/esm/lib/2bytes.js
-function toToken(data, pos, prefix, length2) {
-  assertEnoughData(data, pos, prefix + length2);
-  const buf3 = slice(data, pos + prefix, pos + prefix + length2);
-  return new Token(Type.bytes, buf3, prefix + length2);
-}
-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 ? fromString(token.value) : token.value;
-  }
-  return token.encodedBytes;
-}
-function encodeBytes(buf3, token) {
-  const bytes = tokenBytes(token);
-  encodeUintValue(buf3, token.type.majorEncoded, bytes.length);
-  buf3.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/cborg/esm/lib/3string.js
-function toToken2(data, pos, prefix, length2, options) {
-  const totLength = prefix + length2;
-  assertEnoughData(data, pos, totLength);
-  const tok = new Token(Type.string, toString(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/cborg/esm/lib/4array.js
-function toToken3(_data, _pos, prefix, length2) {
-  return new Token(Type.array, length2, 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(buf3, token) {
-  encodeUintValue(buf3, Type.array.majorEncoded, token.value);
-}
-encodeArray.compareTokens = encodeUint.compareTokens;
-encodeArray.encodedSize = function encodedSize5(token) {
-  return encodeUintValue.encodedSize(token.value);
-};
-
-// node_modules/cborg/esm/lib/5map.js
-function toToken4(_data, _pos, prefix, length2) {
-  return new Token(Type.map, length2, 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(buf3, token) {
-  encodeUintValue(buf3, Type.map.majorEncoded, token.value);
-}
-encodeMap.compareTokens = encodeUint.compareTokens;
-encodeMap.encodedSize = function encodedSize6(token) {
-  return encodeUintValue.encodedSize(token.value);
-};
-
-// 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(buf3, token) {
-  encodeUintValue(buf3, Type.tag.majorEncoded, token.value);
-}
-encodeTag.compareTokens = encodeUint.compareTokens;
-encodeTag.encodedSize = function encodedSize7(token) {
-  return encodeUintValue.encodedSize(token.value);
-};
-
-// 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(buf3, token, options) {
-  const float = token.value;
-  if (float === false) {
-    buf3.push([Type.float.majorEncoded | MINOR_FALSE]);
-  } else if (float === true) {
-    buf3.push([Type.float.majorEncoded | MINOR_TRUE]);
-  } else if (float === null) {
-    buf3.push([Type.float.majorEncoded | MINOR_NULL]);
-  } else if (float === void 0) {
-    buf3.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;
-        buf3.push(ui8a.slice(0, 3));
-        success = true;
-      } else {
-        encodeFloat32(float);
-        decoded = readFloat32(ui8a, 1);
-        if (float === decoded) {
-          ui8a[0] = 250;
-          buf3.push(ui8a.slice(0, 5));
-          success = true;
-        }
-      }
-    }
-    if (!success) {
-      encodeFloat64(float);
-      decoded = readFloat64(ui8a, 1);
-      ui8a[0] = 251;
-      buf3.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(ui8a3, pos) {
-  if (ui8a3.length - pos < 2) {
-    throw new Error(`${decodeErrPrefix} not enough data for float16`);
-  }
-  const half = (ui8a3[pos] << 8) + ui8a3[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 * 2 ** -24;
-  } else if (exp !== 31) {
-    val = (mant + 1024) * 2 ** (exp - 25);
-  } else {
-    val = mant === 0 ? Infinity : NaN;
-  }
-  return half & 32768 ? -val : val;
-}
-function encodeFloat32(inp) {
-  dataView.setFloat32(0, inp, false);
-}
-function readFloat32(ui8a3, pos) {
-  if (ui8a3.length - pos < 4) {
-    throw new Error(`${decodeErrPrefix} not enough data for float32`);
-  }
-  const offset = (ui8a3.byteOffset || 0) + pos;
-  return new DataView(ui8a3.buffer, offset, 4).getFloat32(0, false);
-}
-function encodeFloat64(inp) {
-  dataView.setFloat64(0, inp, false);
-}
-function readFloat64(ui8a3, pos) {
-  if (ui8a3.length - pos < 8) {
-    throw new Error(`${decodeErrPrefix} not enough data for float64`);
-  }
-  const offset = (ui8a3.byteOffset || 0) + pos;
-  return new DataView(ui8a3.buffer, offset, 8).getFloat64(0, false);
-}
-encodeFloat.compareTokens = encodeUint.compareTokens;
-
-// 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/cborg/esm/lib/encode.js
-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 entries = [];
-    let i = 0;
-    for (const e of obj) {
-      entries[i++] = objectToTokens(e, options, refStack);
-    }
-    if (options.addBreakTokens) {
-      return [
-        new Token(Type.array, obj.length),
-        entries,
-        new Token(Type.break)
-      ];
-    }
-    return [
-      new Token(Type.array, obj.length),
-      entries
-    ];
-  },
-  Object(obj, typ, options, refStack) {
-    const isMap = typ !== "Object";
-    const keys = isMap ? obj.keys() : Object.keys(obj);
-    const length2 = isMap ? obj.size : keys.length;
-    if (!length2) {
-      if (options.addBreakTokens === true) {
-        return [
-          simpleTokens.emptyMap,
-          new Token(Type.break)
-        ];
-      }
-      return simpleTokens.emptyMap;
-    }
-    refStack = Ref.createCheck(refStack, obj);
-    const entries = [];
-    let i = 0;
-    for (const key of keys) {
-      entries[i++] = [
-        objectToTokens(key, options, refStack),
-        objectToTokens(isMap ? obj.get(key) : obj[key], options, refStack)
-      ];
-    }
-    sortMapEntries(entries, options);
-    if (options.addBreakTokens) {
-      return [
-        new Token(Type.map, length2),
-        entries,
-        new Token(Type.break)
-      ];
-    }
-    return [
-      new Token(Type.map, length2),
-      entries
-    ];
-  }
-};
-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(entries, options) {
-  if (options.mapSorter) {
-    entries.sort(options.mapSorter);
-  }
-}
-
-// node_modules/cborg/esm/lib/decode.js
-var DONE = Symbol.for("DONE");
-var BREAK = Symbol.for("BREAK");
-
-// node_modules/cborg/esm/lib/length.js
-var cborEncoders2 = makeCborEncoders();
-var defaultEncodeOptions = {
-  float64: false,
-  quickEncodeToken
-};
-function tokensToLength(tokens, encoders = cborEncoders2, options = defaultEncodeOptions) {
-  if (Array.isArray(tokens)) {
-    let len = 0;
-    for (const token of tokens) {
-      len += tokensToLength(token, encoders, options);
-    }
-    return len;
-  } else {
-    const encoder = encoders[tokens.type.major];
-    if (encoder.encodedSize === void 0 || typeof encoder.encodedSize !== "function") {
-      throw new Error(`Encoder for ${tokens.type.name} does not have an encodedSize()`);
-    }
-    return encoder.encodedSize(tokens, options);
-  }
-}
-
-// node_modules/@ipld/dag-cbor/src/index.js
-var src_exports = {};
-__export(src_exports, {
-  code: () => code2,
-  decode: () => decode9,
-  encode: () => encode7,
-  name: () => name2
-});
-
-// node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/is.js
-var typeofs2 = [
-  "string",
-  "number",
-  "bigint",
-  "symbol"
-];
-var objectTypeNames2 = [
-  "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 is2(value) {
-  if (value === null) {
-    return "null";
-  }
-  if (value === void 0) {
-    return "undefined";
-  }
-  if (value === true || value === false) {
-    return "boolean";
-  }
-  const typeOf = typeof value;
-  if (typeofs2.includes(typeOf)) {
-    return typeOf;
-  }
-  if (typeOf === "function") {
-    return "Function";
-  }
-  if (Array.isArray(value)) {
-    return "Array";
-  }
-  if (isBuffer3(value)) {
-    return "Buffer";
-  }
-  const objectType = getObjectType2(value);
-  if (objectType) {
-    return objectType;
-  }
-  return "Object";
-}
-function isBuffer3(value) {
-  return value && value.constructor && value.constructor.isBuffer && value.constructor.isBuffer.call(null, value);
-}
-function getObjectType2(value) {
-  const objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
-  if (objectTypeNames2.includes(objectTypeName)) {
-    return objectTypeName;
-  }
-  return void 0;
-}
-
-// node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/token.js
-var Type2 = class {
-  constructor(major, name3, terminal) {
-    this.major = major;
-    this.majorEncoded = major << 5;
-    this.name = name3;
-    this.terminal = terminal;
-  }
-  toString() {
-    return `Type[${this.major}].${this.name}`;
-  }
-  compare(typ) {
-    return this.major < typ.major ? -1 : this.major > typ.major ? 1 : 0;
-  }
-};
-Type2.uint = new Type2(0, "uint", true);
-Type2.negint = new Type2(1, "negint", true);
-Type2.bytes = new Type2(2, "bytes", true);
-Type2.string = new Type2(3, "string", true);
-Type2.array = new Type2(4, "array", false);
-Type2.map = new Type2(5, "map", false);
-Type2.tag = new Type2(6, "tag", false);
-Type2.float = new Type2(7, "float", true);
-Type2.false = new Type2(7, "false", true);
-Type2.true = new Type2(7, "true", true);
-Type2.null = new Type2(7, "null", true);
-Type2.undefined = new Type2(7, "undefined", true);
-Type2.break = new Type2(7, "break", true);
-var Token2 = 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 useBuffer2 = globalThis.process && !globalThis.process.browser && globalThis.Buffer && typeof globalThis.Buffer.isBuffer === "function";
-var textDecoder2 = new TextDecoder();
-var textEncoder2 = new TextEncoder();
-function isBuffer4(buf3) {
-  return useBuffer2 && globalThis.Buffer.isBuffer(buf3);
-}
-function asU8A2(buf3) {
-  if (!(buf3 instanceof Uint8Array)) {
-    return Uint8Array.from(buf3);
-  }
-  return isBuffer4(buf3) ? new Uint8Array(buf3.buffer, buf3.byteOffset, buf3.byteLength) : buf3;
-}
-var toString2 = useBuffer2 ? (bytes, start, end) => {
-  return end - start > 64 ? globalThis.Buffer.from(bytes.subarray(start, end)).toString("utf8") : utf8Slice2(bytes, start, end);
-} : (bytes, start, end) => {
-  return end - start > 64 ? textDecoder2.decode(bytes.subarray(start, end)) : utf8Slice2(bytes, start, end);
-};
-var fromString2 = useBuffer2 ? (string) => {
-  return string.length > 64 ? globalThis.Buffer.from(string) : utf8ToBytes2(string);
-} : (string) => {
-  return string.length > 64 ? textEncoder2.encode(string) : utf8ToBytes2(string);
-};
-var fromArray2 = (arr) => {
-  return Uint8Array.from(arr);
-};
-var slice2 = useBuffer2 ? (bytes, start, end) => {
-  if (isBuffer4(bytes)) {
-    return new Uint8Array(bytes.subarray(start, end));
-  }
-  return bytes.slice(start, end);
-} : (bytes, start, end) => {
-  return bytes.slice(start, end);
-};
-var concat2 = useBuffer2 ? (chunks, length2) => {
-  chunks = chunks.map((c) => c instanceof Uint8Array ? c : globalThis.Buffer.from(c));
-  return asU8A2(globalThis.Buffer.concat(chunks, length2));
-} : (chunks, length2) => {
-  const out = new Uint8Array(length2);
-  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 alloc2 = useBuffer2 ? (size) => {
-  return globalThis.Buffer.allocUnsafe(size);
-} : (size) => {
-  return new Uint8Array(size);
-};
-function compare2(b1, b2) {
-  if (isBuffer4(b1) && isBuffer4(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 utf8ToBytes2(string, units = Infinity) {
-  let codePoint;
-  const length2 = string.length;
-  let leadSurrogate = null;
-  const bytes = [];
-  for (let i = 0; i < length2; ++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 === length2) {
-          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 utf8Slice2(buf3, offset, end) {
-  const res = [];
-  while (offset < end) {
-    const firstByte = buf3[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 = buf3[offset + 1];
-          if ((secondByte & 192) === 128) {
-            tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
-            if (tempCodePoint > 127) {
-              codePoint = tempCodePoint;
-            }
-          }
-          break;
-        case 3:
-          secondByte = buf3[offset + 1];
-          thirdByte = buf3[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 = buf3[offset + 1];
-          thirdByte = buf3[offset + 2];
-          fourthByte = buf3[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 decodeCodePointsArray2(res);
-}
-var MAX_ARGUMENTS_LENGTH2 = 4096;
-function decodeCodePointsArray2(codePoints) {
-  const len = codePoints.length;
-  if (len <= MAX_ARGUMENTS_LENGTH2) {
-    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_LENGTH2));
-  }
-  return res;
-}
-
-// node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/bl.js
-var defaultChunkSize2 = 256;
-var Bl2 = class {
-  constructor(chunkSize = defaultChunkSize2) {
-    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 = alloc2(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 = slice2(chunk, 0, this.cursor);
-      }
-    } else {
-      byts = concat2(this.chunks, this.cursor);
-    }
-    if (reset) {
-      this.reset();
-    }
-    return byts;
-  }
-};
-
-// node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/common.js
-var decodeErrPrefix2 = "CBOR decode error:";
-var encodeErrPrefix2 = "CBOR encode error:";
-var uintMinorPrefixBytes2 = [];
-uintMinorPrefixBytes2[23] = 1;
-uintMinorPrefixBytes2[24] = 2;
-uintMinorPrefixBytes2[25] = 3;
-uintMinorPrefixBytes2[26] = 5;
-uintMinorPrefixBytes2[27] = 9;
-function assertEnoughData2(data, pos, need) {
-  if (data.length - pos < need) {
-    throw new Error(`${decodeErrPrefix2} not enough data for type`);
-  }
-}
-
-// node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/0uint.js
-var uintBoundaries2 = [
-  24,
-  256,
-  65536,
-  4294967296,
-  BigInt("18446744073709551616")
-];
-function readUint82(data, offset, options) {
-  assertEnoughData2(data, offset, 1);
-  const value = data[offset];
-  if (options.strict === true && value < uintBoundaries2[0]) {
-    throw new Error(`${decodeErrPrefix2} integer encoded in more bytes than necessary (strict decode)`);
-  }
-  return value;
-}
-function readUint162(data, offset, options) {
-  assertEnoughData2(data, offset, 2);
-  const value = data[offset] << 8 | data[offset + 1];
-  if (options.strict === true && value < uintBoundaries2[1]) {
-    throw new Error(`${decodeErrPrefix2} integer encoded in more bytes than necessary (strict decode)`);
-  }
-  return value;
-}
-function readUint322(data, offset, options) {
-  assertEnoughData2(data, offset, 4);
-  const value = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
-  if (options.strict === true && value < uintBoundaries2[2]) {
-    throw new Error(`${decodeErrPrefix2} integer encoded in more bytes than necessary (strict decode)`);
-  }
-  return value;
-}
-function readUint642(data, offset, options) {
-  assertEnoughData2(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 < uintBoundaries2[3]) {
-    throw new Error(`${decodeErrPrefix2} 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(`${decodeErrPrefix2} integers outside of the safe integer range are not supported`);
-}
-function decodeUint82(data, pos, _minor, options) {
-  return new Token2(Type2.uint, readUint82(data, pos + 1, options), 2);
-}
-function decodeUint162(data, pos, _minor, options) {
-  return new Token2(Type2.uint, readUint162(data, pos + 1, options), 3);
-}
-function decodeUint322(data, pos, _minor, options) {
-  return new Token2(Type2.uint, readUint322(data, pos + 1, options), 5);
-}
-function decodeUint642(data, pos, _minor, options) {
-  return new Token2(Type2.uint, readUint642(data, pos + 1, options), 9);
-}
-function encodeUint2(buf3, token) {
-  return encodeUintValue2(buf3, 0, token.value);
-}
-function encodeUintValue2(buf3, major, uint) {
-  if (uint < uintBoundaries2[0]) {
-    const nuint = Number(uint);
-    buf3.push([major | nuint]);
-  } else if (uint < uintBoundaries2[1]) {
-    const nuint = Number(uint);
-    buf3.push([
-      major | 24,
-      nuint
-    ]);
-  } else if (uint < uintBoundaries2[2]) {
-    const nuint = Number(uint);
-    buf3.push([
-      major | 25,
-      nuint >>> 8,
-      nuint & 255
-    ]);
-  } else if (uint < uintBoundaries2[3]) {
-    const nuint = Number(uint);
-    buf3.push([
-      major | 26,
-      nuint >>> 24 & 255,
-      nuint >>> 16 & 255,
-      nuint >>> 8 & 255,
-      nuint & 255
-    ]);
-  } else {
-    const buint = BigInt(uint);
-    if (buint < uintBoundaries2[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;
-      buf3.push(set);
-    } else {
-      throw new Error(`${decodeErrPrefix2} encountered BigInt larger than allowable range`);
-    }
-  }
-}
-encodeUint2.encodedSize = function encodedSize9(token) {
-  return encodeUintValue2.encodedSize(token.value);
-};
-encodeUintValue2.encodedSize = function encodedSize10(uint) {
-  if (uint < uintBoundaries2[0]) {
-    return 1;
-  }
-  if (uint < uintBoundaries2[1]) {
-    return 2;
-  }
-  if (uint < uintBoundaries2[2]) {
-    return 3;
-  }
-  if (uint < uintBoundaries2[3]) {
-    return 5;
-  }
-  return 9;
-};
-encodeUint2.compareTokens = function compareTokens4(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 decodeNegint82(data, pos, _minor, options) {
-  return new Token2(Type2.negint, -1 - readUint82(data, pos + 1, options), 2);
-}
-function decodeNegint162(data, pos, _minor, options) {
-  return new Token2(Type2.negint, -1 - readUint162(data, pos + 1, options), 3);
-}
-function decodeNegint322(data, pos, _minor, options) {
-  return new Token2(Type2.negint, -1 - readUint322(data, pos + 1, options), 5);
-}
-var neg1b2 = BigInt(-1);
-var pos1b2 = BigInt(1);
-function decodeNegint642(data, pos, _minor, options) {
-  const int = readUint642(data, pos + 1, options);
-  if (typeof int !== "bigint") {
-    const value = -1 - int;
-    if (value >= Number.MIN_SAFE_INTEGER) {
-      return new Token2(Type2.negint, value, 9);
-    }
-  }
-  if (options.allowBigInt !== true) {
-    throw new Error(`${decodeErrPrefix2} integers outside of the safe integer range are not supported`);
-  }
-  return new Token2(Type2.negint, neg1b2 - BigInt(int), 9);
-}
-function encodeNegint2(buf3, token) {
-  const negint = token.value;
-  const unsigned = typeof negint === "bigint" ? negint * neg1b2 - pos1b2 : negint * -1 - 1;
-  encodeUintValue2(buf3, token.type.majorEncoded, unsigned);
-}
-encodeNegint2.encodedSize = function encodedSize11(token) {
-  const negint = token.value;
-  const unsigned = typeof negint === "bigint" ? negint * neg1b2 - pos1b2 : negint * -1 - 1;
-  if (unsigned < uintBoundaries2[0]) {
-    return 1;
-  }
-  if (unsigned < uintBoundaries2[1]) {
-    return 2;
-  }
-  if (unsigned < uintBoundaries2[2]) {
-    return 3;
-  }
-  if (unsigned < uintBoundaries2[3]) {
-    return 5;
-  }
-  return 9;
-};
-encodeNegint2.compareTokens = function compareTokens5(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 toToken5(data, pos, prefix, length2) {
-  assertEnoughData2(data, pos, prefix + length2);
-  const buf3 = slice2(data, pos + prefix, pos + prefix + length2);
-  return new Token2(Type2.bytes, buf3, prefix + length2);
-}
-function decodeBytesCompact2(data, pos, minor, _options) {
-  return toToken5(data, pos, 1, minor);
-}
-function decodeBytes82(data, pos, _minor, options) {
-  return toToken5(data, pos, 2, readUint82(data, pos + 1, options));
-}
-function decodeBytes162(data, pos, _minor, options) {
-  return toToken5(data, pos, 3, readUint162(data, pos + 1, options));
-}
-function decodeBytes322(data, pos, _minor, options) {
-  return toToken5(data, pos, 5, readUint322(data, pos + 1, options));
-}
-function decodeBytes642(data, pos, _minor, options) {
-  const l = readUint642(data, pos + 1, options);
-  if (typeof l === "bigint") {
-    throw new Error(`${decodeErrPrefix2} 64-bit integer bytes lengths not supported`);
-  }
-  return toToken5(data, pos, 9, l);
-}
-function tokenBytes2(token) {
-  if (token.encodedBytes === void 0) {
-    token.encodedBytes = token.type === Type2.string ? fromString2(token.value) : token.value;
-  }
-  return token.encodedBytes;
-}
-function encodeBytes2(buf3, token) {
-  const bytes = tokenBytes2(token);
-  encodeUintValue2(buf3, token.type.majorEncoded, bytes.length);
-  buf3.push(bytes);
-}
-encodeBytes2.encodedSize = function encodedSize12(token) {
-  const bytes = tokenBytes2(token);
-  return encodeUintValue2.encodedSize(bytes.length) + bytes.length;
-};
-encodeBytes2.compareTokens = function compareTokens6(tok1, tok2) {
-  return compareBytes2(tokenBytes2(tok1), tokenBytes2(tok2));
-};
-function compareBytes2(b1, b2) {
-  return b1.length < b2.length ? -1 : b1.length > b2.length ? 1 : compare2(b1, b2);
-}
-
-// node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/3string.js
-function toToken6(data, pos, prefix, length2, options) {
-  const totLength = prefix + length2;
-  assertEnoughData2(data, pos, totLength);
-  const tok = new Token2(Type2.string, toString2(data, pos + prefix, pos + totLength), totLength);
-  if (options.retainStringBytes === true) {
-    tok.byteValue = slice2(data, pos + prefix, pos + totLength);
-  }
-  return tok;
-}
-function decodeStringCompact2(data, pos, minor, options) {
-  return toToken6(data, pos, 1, minor, options);
-}
-function decodeString82(data, pos, _minor, options) {
-  return toToken6(data, pos, 2, readUint82(data, pos + 1, options), options);
-}
-function decodeString162(data, pos, _minor, options) {
-  return toToken6(data, pos, 3, readUint162(data, pos + 1, options), options);
-}
-function decodeString322(data, pos, _minor, options) {
-  return toToken6(data, pos, 5, readUint322(data, pos + 1, options), options);
-}
-function decodeString642(data, pos, _minor, options) {
-  const l = readUint642(data, pos + 1, options);
-  if (typeof l === "bigint") {
-    throw new Error(`${decodeErrPrefix2} 64-bit integer string lengths not supported`);
-  }
-  return toToken6(data, pos, 9, l, options);
-}
-var encodeString2 = encodeBytes2;
-
-// node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/4array.js
-function toToken7(_data, _pos, prefix, length2) {
-  return new Token2(Type2.array, length2, prefix);
-}
-function decodeArrayCompact2(data, pos, minor, _options) {
-  return toToken7(data, pos, 1, minor);
-}
-function decodeArray82(data, pos, _minor, options) {
-  return toToken7(data, pos, 2, readUint82(data, pos + 1, options));
-}
-function decodeArray162(data, pos, _minor, options) {
-  return toToken7(data, pos, 3, readUint162(data, pos + 1, options));
-}
-function decodeArray322(data, pos, _minor, options) {
-  return toToken7(data, pos, 5, readUint322(data, pos + 1, options));
-}
-function decodeArray642(data, pos, _minor, options) {
-  const l = readUint642(data, pos + 1, options);
-  if (typeof l === "bigint") {
-    throw new Error(`${decodeErrPrefix2} 64-bit integer array lengths not supported`);
-  }
-  return toToken7(data, pos, 9, l);
-}
-function decodeArrayIndefinite2(data, pos, _minor, options) {
-  if (options.allowIndefinite === false) {
-    throw new Error(`${decodeErrPrefix2} indefinite length items not allowed`);
-  }
-  return toToken7(data, pos, 1, Infinity);
-}
-function encodeArray2(buf3, token) {
-  encodeUintValue2(buf3, Type2.array.majorEncoded, token.value);
-}
-encodeArray2.compareTokens = encodeUint2.compareTokens;
-encodeArray2.encodedSize = function encodedSize13(token) {
-  return encodeUintValue2.encodedSize(token.value);
-};
-
-// node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/5map.js
-function toToken8(_data, _pos, prefix, length2) {
-  return new Token2(Type2.map, length2, prefix);
-}
-function decodeMapCompact2(data, pos, minor, _options) {
-  return toToken8(data, pos, 1, minor);
-}
-function decodeMap82(data, pos, _minor, options) {
-  return toToken8(data, pos, 2, readUint82(data, pos + 1, options));
-}
-function decodeMap162(data, pos, _minor, options) {
-  return toToken8(data, pos, 3, readUint162(data, pos + 1, options));
-}
-function decodeMap322(data, pos, _minor, options) {
-  return toToken8(data, pos, 5, readUint322(data, pos + 1, options));
-}
-function decodeMap642(data, pos, _minor, options) {
-  const l = readUint642(data, pos + 1, options);
-  if (typeof l === "bigint") {
-    throw new Error(`${decodeErrPrefix2} 64-bit integer map lengths not supported`);
-  }
-  return toToken8(data, pos, 9, l);
-}
-function decodeMapIndefinite2(data, pos, _minor, options) {
-  if (options.allowIndefinite === false) {
-    throw new Error(`${decodeErrPrefix2} indefinite length items not allowed`);
-  }
-  return toToken8(data, pos, 1, Infinity);
-}
-function encodeMap2(buf3, token) {
-  encodeUintValue2(buf3, Type2.map.majorEncoded, token.value);
-}
-encodeMap2.compareTokens = encodeUint2.compareTokens;
-encodeMap2.encodedSize = function encodedSize14(token) {
-  return encodeUintValue2.encodedSize(token.value);
-};
-
-// node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/6tag.js
-function decodeTagCompact2(_data, _pos, minor, _options) {
-  return new Token2(Type2.tag, minor, 1);
-}
-function decodeTag82(data, pos, _minor, options) {
-  return new Token2(Type2.tag, readUint82(data, pos + 1, options), 2);
-}
-function decodeTag162(data, pos, _minor, options) {
-  return new Token2(Type2.tag, readUint162(data, pos + 1, options), 3);
-}
-function decodeTag322(data, pos, _minor, options) {
-  return new Token2(Type2.tag, readUint322(data, pos + 1, options), 5);
-}
-function decodeTag642(data, pos, _minor, options) {
-  return new Token2(Type2.tag, readUint642(data, pos + 1, options), 9);
-}
-function encodeTag2(buf3, token) {
-  encodeUintValue2(buf3, Type2.tag.majorEncoded, token.value);
-}
-encodeTag2.compareTokens = encodeUint2.compareTokens;
-encodeTag2.encodedSize = function encodedSize15(token) {
-  return encodeUintValue2.encodedSize(token.value);
-};
-
-// node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/7float.js
-var MINOR_FALSE2 = 20;
-var MINOR_TRUE2 = 21;
-var MINOR_NULL2 = 22;
-var MINOR_UNDEFINED2 = 23;
-function decodeUndefined2(_data, _pos, _minor, options) {
-  if (options.allowUndefined === false) {
-    throw new Error(`${decodeErrPrefix2} undefined values are not supported`);
-  } else if (options.coerceUndefinedToNull === true) {
-    return new Token2(Type2.null, null, 1);
-  }
-  return new Token2(Type2.undefined, void 0, 1);
-}
-function decodeBreak2(_data, _pos, _minor, options) {
-  if (options.allowIndefinite === false) {
-    throw new Error(`${decodeErrPrefix2} indefinite length items not allowed`);
-  }
-  return new Token2(Type2.break, void 0, 1);
-}
-function createToken2(value, bytes, options) {
-  if (options) {
-    if (options.allowNaN === false && Number.isNaN(value)) {
-      throw new Error(`${decodeErrPrefix2} NaN values are not supported`);
-    }
-    if (options.allowInfinity === false && (value === Infinity || value === -Infinity)) {
-      throw new Error(`${decodeErrPrefix2} Infinity values are not supported`);
-    }
-  }
-  return new Token2(Type2.float, value, bytes);
-}
-function decodeFloat162(data, pos, _minor, options) {
-  return createToken2(readFloat162(data, pos + 1), 3, options);
-}
-function decodeFloat322(data, pos, _minor, options) {
-  return createToken2(readFloat322(data, pos + 1), 5, options);
-}
-function decodeFloat642(data, pos, _minor, options) {
-  return createToken2(readFloat642(data, pos + 1), 9, options);
-}
-function encodeFloat2(buf3, token, options) {
-  const float = token.value;
-  if (float === false) {
-    buf3.push([Type2.float.majorEncoded | MINOR_FALSE2]);
-  } else if (float === true) {
-    buf3.push([Type2.float.majorEncoded | MINOR_TRUE2]);
-  } else if (float === null) {
-    buf3.push([Type2.float.majorEncoded | MINOR_NULL2]);
-  } else if (float === void 0) {
-    buf3.push([Type2.float.majorEncoded | MINOR_UNDEFINED2]);
-  } else {
-    let decoded;
-    let success = false;
-    if (!options || options.float64 !== true) {
-      encodeFloat162(float);
-      decoded = readFloat162(ui8a2, 1);
-      if (float === decoded || Number.isNaN(float)) {
-        ui8a2[0] = 249;
-        buf3.push(ui8a2.slice(0, 3));
-        success = true;
-      } else {
-        encodeFloat322(float);
-        decoded = readFloat322(ui8a2, 1);
-        if (float === decoded) {
-          ui8a2[0] = 250;
-          buf3.push(ui8a2.slice(0, 5));
-          success = true;
-        }
-      }
-    }
-    if (!success) {
-      encodeFloat642(float);
-      decoded = readFloat642(ui8a2, 1);
-      ui8a2[0] = 251;
-      buf3.push(ui8a2.slice(0, 9));
-    }
-  }
-}
-encodeFloat2.encodedSize = function encodedSize16(token, options) {
-  const float = token.value;
-  if (float === false || float === true || float === null || float === void 0) {
-    return 1;
-  }
-  if (!options || options.float64 !== true) {
-    encodeFloat162(float);
-    let decoded = readFloat162(ui8a2, 1);
-    if (float === decoded || Number.isNaN(float)) {
-      return 3;
-    }
-    encodeFloat322(float);
-    decoded = readFloat322(ui8a2, 1);
-    if (float === decoded) {
-      return 5;
-    }
-  }
-  return 9;
-};
-var buffer2 = new ArrayBuffer(9);
-var dataView2 = new DataView(buffer2, 1);
-var ui8a2 = new Uint8Array(buffer2, 0);
-function encodeFloat162(inp) {
-  if (inp === Infinity) {
-    dataView2.setUint16(0, 31744, false);
-  } else if (inp === -Infinity) {
-    dataView2.setUint16(0, 64512, false);
-  } else if (Number.isNaN(inp)) {
-    dataView2.setUint16(0, 32256, false);
-  } else {
-    dataView2.setFloat32(0, inp);
-    const valu32 = dataView2.getUint32(0);
-    const exponent = (valu32 & 2139095040) >> 23;
-    const mantissa = valu32 & 8388607;
-    if (exponent === 255) {
-      dataView2.setUint16(0, 31744, false);
-    } else if (exponent === 0) {
-      dataView2.setUint16(0, (inp & 2147483648) >> 16 | mantissa >> 13, false);
-    } else {
-      const logicalExponent = exponent - 127;
-      if (logicalExponent < -24) {
-        dataView2.setUint16(0, 0);
-      } else if (logicalExponent < -14) {
-        dataView2.setUint16(0, (valu32 & 2147483648) >> 16 | 1 << 24 + logicalExponent, false);
-      } else {
-        dataView2.setUint16(0, (valu32 & 2147483648) >> 16 | logicalExponent + 15 << 10 | mantissa >> 13, false);
-      }
-    }
-  }
-}
-function readFloat162(ui8a3, pos) {
-  if (ui8a3.length - pos < 2) {
-    throw new Error(`${decodeErrPrefix2} not enough data for float16`);
-  }
-  const half = (ui8a3[pos] << 8) + ui8a3[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 * 2 ** -24;
-  } else if (exp !== 31) {
-    val = (mant + 1024) * 2 ** (exp - 25);
-  } else {
-    val = mant === 0 ? Infinity : NaN;
-  }
-  return half & 32768 ? -val : val;
-}
-function encodeFloat322(inp) {
-  dataView2.setFloat32(0, inp, false);
-}
-function readFloat322(ui8a3, pos) {
-  if (ui8a3.length - pos < 4) {
-    throw new Error(`${decodeErrPrefix2} not enough data for float32`);
-  }
-  const offset = (ui8a3.byteOffset || 0) + pos;
-  return new DataView(ui8a3.buffer, offset, 4).getFloat32(0, false);
-}
-function encodeFloat642(inp) {
-  dataView2.setFloat64(0, inp, false);
-}
-function readFloat642(ui8a3, pos) {
-  if (ui8a3.length - pos < 8) {
-    throw new Error(`${decodeErrPrefix2} not enough data for float64`);
-  }
-  const offset = (ui8a3.byteOffset || 0) + pos;
-  return new DataView(ui8a3.buffer, offset, 8).getFloat64(0, false);
-}
-encodeFloat2.compareTokens = encodeUint2.compareTokens;
-
-// node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/jump.js
-function invalidMinor2(data, pos, minor) {
-  throw new Error(`${decodeErrPrefix2} encountered invalid minor (${minor}) for major ${data[pos] >>> 5}`);
-}
-function errorer2(msg) {
-  return () => {
-    throw new Error(`${decodeErrPrefix2} ${msg}`);
-  };
-}
-var jump2 = [];
-for (let i = 0; i <= 23; i++) {
-  jump2[i] = invalidMinor2;
-}
-jump2[24] = decodeUint82;
-jump2[25] = decodeUint162;
-jump2[26] = decodeUint322;
-jump2[27] = decodeUint642;
-jump2[28] = invalidMinor2;
-jump2[29] = invalidMinor2;
-jump2[30] = invalidMinor2;
-jump2[31] = invalidMinor2;
-for (let i = 32; i <= 55; i++) {
-  jump2[i] = invalidMinor2;
-}
-jump2[56] = decodeNegint82;
-jump2[57] = decodeNegint162;
-jump2[58] = decodeNegint322;
-jump2[59] = decodeNegint642;
-jump2[60] = invalidMinor2;
-jump2[61] = invalidMinor2;
-jump2[62] = invalidMinor2;
-jump2[63] = invalidMinor2;
-for (let i = 64; i <= 87; i++) {
-  jump2[i] = decodeBytesCompact2;
-}
-jump2[88] = decodeBytes82;
-jump2[89] = decodeBytes162;
-jump2[90] = decodeBytes322;
-jump2[91] = decodeBytes642;
-jump2[92] = invalidMinor2;
-jump2[93] = invalidMinor2;
-jump2[94] = invalidMinor2;
-jump2[95] = errorer2("indefinite length bytes/strings are not supported");
-for (let i = 96; i <= 119; i++) {
-  jump2[i] = decodeStringCompact2;
-}
-jump2[120] = decodeString82;
-jump2[121] = decodeString162;
-jump2[122] = decodeString322;
-jump2[123] = decodeString642;
-jump2[124] = invalidMinor2;
-jump2[125] = invalidMinor2;
-jump2[126] = invalidMinor2;
-jump2[127] = errorer2("indefinite length bytes/strings are not supported");
-for (let i = 128; i <= 151; i++) {
-  jump2[i] = decodeArrayCompact2;
-}
-jump2[152] = decodeArray82;
-jump2[153] = decodeArray162;
-jump2[154] = decodeArray322;
-jump2[155] = decodeArray642;
-jump2[156] = invalidMinor2;
-jump2[157] = invalidMinor2;
-jump2[158] = invalidMinor2;
-jump2[159] = decodeArrayIndefinite2;
-for (let i = 160; i <= 183; i++) {
-  jump2[i] = decodeMapCompact2;
-}
-jump2[184] = decodeMap82;
-jump2[185] = decodeMap162;
-jump2[186] = decodeMap322;
-jump2[187] = decodeMap642;
-jump2[188] = invalidMinor2;
-jump2[189] = invalidMinor2;
-jump2[190] = invalidMinor2;
-jump2[191] = decodeMapIndefinite2;
-for (let i = 192; i <= 215; i++) {
-  jump2[i] = decodeTagCompact2;
-}
-jump2[216] = decodeTag82;
-jump2[217] = decodeTag162;
-jump2[218] = decodeTag322;
-jump2[219] = decodeTag642;
-jump2[220] = invalidMinor2;
-jump2[221] = invalidMinor2;
-jump2[222] = invalidMinor2;
-jump2[223] = invalidMinor2;
-for (let i = 224; i <= 243; i++) {
-  jump2[i] = errorer2("simple values are not supported");
-}
-jump2[244] = invalidMinor2;
-jump2[245] = invalidMinor2;
-jump2[246] = invalidMinor2;
-jump2[247] = decodeUndefined2;
-jump2[248] = errorer2("simple values are not supported");
-jump2[249] = decodeFloat162;
-jump2[250] = decodeFloat322;
-jump2[251] = decodeFloat642;
-jump2[252] = invalidMinor2;
-jump2[253] = invalidMinor2;
-jump2[254] = invalidMinor2;
-jump2[255] = decodeBreak2;
-var quick2 = [];
-for (let i = 0; i < 24; i++) {
-  quick2[i] = new Token2(Type2.uint, i, 1);
-}
-for (let i = -1; i >= -24; i--) {
-  quick2[31 - i] = new Token2(Type2.negint, i, 1);
-}
-quick2[64] = new Token2(Type2.bytes, new Uint8Array(0), 1);
-quick2[96] = new Token2(Type2.string, "", 1);
-quick2[128] = new Token2(Type2.array, 0, 1);
-quick2[160] = new Token2(Type2.map, 0, 1);
-quick2[244] = new Token2(Type2.false, false, 1);
-quick2[245] = new Token2(Type2.true, true, 1);
-quick2[246] = new Token2(Type2.null, null, 1);
-function quickEncodeToken2(token) {
-  switch (token.type) {
-    case Type2.false:
-      return fromArray2([244]);
-    case Type2.true:
-      return fromArray2([245]);
-    case Type2.null:
-      return fromArray2([246]);
-    case Type2.bytes:
-      if (!token.value.length) {
-        return fromArray2([64]);
-      }
-      return;
-    case Type2.string:
-      if (token.value === "") {
-        return fromArray2([96]);
-      }
-      return;
-    case Type2.array:
-      if (token.value === 0) {
-        return fromArray2([128]);
-      }
-      return;
-    case Type2.map:
-      if (token.value === 0) {
-        return fromArray2([160]);
-      }
-      return;
-    case Type2.uint:
-      if (token.value < 24) {
-        return fromArray2([Number(token.value)]);
-      }
-      return;
-    case Type2.negint:
-      if (token.value >= -24) {
-        return fromArray2([31 - Number(token.value)]);
-      }
-  }
-}
-
-// node_modules/@ipld/dag-cbor/node_modules/cborg/esm/lib/encode.js
-var defaultEncodeOptions2 = {
-  float64: false,
-  mapSorter,
-  quickEncodeToken: quickEncodeToken2
-};
-function makeCborEncoders2() {
-  const encoders = [];
-  encoders[Type2.uint.major] = encodeUint2;
-  encoders[Type2.negint.major] = encodeNegint2;
-  encoders[Type2.bytes.major] = encodeBytes2;
-  encoders[Type2.string.major] = encodeString2;
-  encoders[Type2.array.major] = encodeArray2;
-  encoders[Type2.map.major] = encodeMap2;
-  encoders[Type2.tag.major] = encodeTag2;
-  encoders[Type2.float.major] = encodeFloat2;
-  return encoders;
-}
-var cborEncoders3 = makeCborEncoders2();
-var buf2 = new Bl2();
-var Ref2 = 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(`${encodeErrPrefix2} object contains circular references`);
-    }
-    return new _Ref(obj, stack);
-  }
-};
-var simpleTokens2 = {
-  null: new Token2(Type2.null, null),
-  undefined: new Token2(Type2.undefined, void 0),
-  true: new Token2(Type2.true, true),
-  false: new Token2(Type2.false, false),
-  emptyArray: new Token2(Type2.array, 0),
-  emptyMap: new Token2(Type2.map, 0)
-};
-var typeEncoders2 = {
-  number(obj, _typ, _options, _refStack) {
-    if (!Number.isInteger(obj) || !Number.isSafeInteger(obj)) {
-      return new Token2(Type2.float, obj);
-    } else if (obj >= 0) {
-      return new Token2(Type2.uint, obj);
-    } else {
-      return new Token2(Type2.negint, obj);
-    }
-  },
-  bigint(obj, _typ, _options, _refStack) {
-    if (obj >= BigInt(0)) {
-      return new Token2(Type2.uint, obj);
-    } else {
-      return new Token2(Type2.negint, obj);
-    }
-  },
-  Uint8Array(obj, _typ, _options, _refStack) {
-    return new Token2(Type2.bytes, obj);
-  },
-  string(obj, _typ, _options, _refStack) {
-    return new Token2(Type2.string, obj);
-  },
-  boolean(obj, _typ, _options, _refStack) {
-    return obj ? simpleTokens2.true : simpleTokens2.false;
-  },
-  null(_obj, _typ, _options, _refStack) {
-    return simpleTokens2.null;
-  },
-  undefined(_obj, _typ, _options, _refStack) {
-    return simpleTokens2.undefined;
-  },
-  ArrayBuffer(obj, _typ, _options, _refStack) {
-    return new Token2(Type2.bytes, new Uint8Array(obj));
-  },
-  DataView(obj, _typ, _options, _refStack) {
-    return new Token2(Type2.bytes, new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength));
-  },
-  Array(obj, _typ, options, refStack) {
-    if (!obj.length) {
-      if (options.addBreakTokens === true) {
-        return [
-          simpleTokens2.emptyArray,
-          new Token2(Type2.break)
-        ];
-      }
-      return simpleTokens2.emptyArray;
-    }
-    refStack = Ref2.createCheck(refStack, obj);
-    const entries = [];
-    let i = 0;
-    for (const e of obj) {
-      entries[i++] = objectToTokens2(e, options, refStack);
-    }
-    if (options.addBreakTokens) {
-      return [
-        new Token2(Type2.array, obj.length),
-        entries,
-        new Token2(Type2.break)
-      ];
-    }
-    return [
-      new Token2(Type2.array, obj.length),
-      entries
-    ];
-  },
-  Object(obj, typ, options, refStack) {
-    const isMap = typ !== "Object";
-    const keys = isMap ? obj.keys() : Object.keys(obj);
-    const length2 = isMap ? obj.size : keys.length;
-    if (!length2) {
-      if (options.addBreakTokens === true) {
-        return [
-          simpleTokens2.emptyMap,
-          new Token2(Type2.break)
-        ];
-      }
-      return simpleTokens2.emptyMap;
-    }
-    refStack = Ref2.createCheck(refStack, obj);
-    const entries = [];
-    let i = 0;
-    for (const key of keys) {
-      entries[i++] = [
-        objectToTokens2(key, options, refStack),
-        objectToTokens2(isMap ? obj.get(key) : obj[key], options, refStack)
-      ];
-    }
-    sortMapEntries2(entries, options);
-    if (options.addBreakTokens) {
-      return [
-        new Token2(Type2.map, length2),
-        entries,
-        new Token2(Type2.break)
-      ];
-    }
-    return [
-      new Token2(Type2.map, length2),
-      entries
-    ];
-  }
-};
-typeEncoders2.Map = typeEncoders2.Object;
-typeEncoders2.Buffer = typeEncoders2.Uint8Array;
-for (const typ of "Uint8Clamped Uint16 Uint32 Int8 Int16 Int32 BigUint64 BigInt64 Float32 Float64".split(" ")) {
-  typeEncoders2[`${typ}Array`] = typeEncoders2.DataView;
-}
-function objectToTokens2(obj, options = {}, refStack) {
-  const typ = is2(obj);
-  const customTypeEncoder = options && options.typeEncoders && options.typeEncoders[typ] || typeEncoders2[typ];
-  if (typeof customTypeEncoder === "function") {
-    const tokens = customTypeEncoder(obj, typ, options, refStack);
-    if (tokens != null) {
-      return tokens;
-    }
-  }
-  const typeEncoder = typeEncoders2[typ];
-  if (!typeEncoder) {
-    throw new Error(`${encodeErrPrefix2} unsupported type: ${typ}`);
-  }
-  return typeEncoder(obj, typ, options, refStack);
-}
-function sortMapEntries2(entries, options) {
-  if (options.mapSorter) {
-    entries.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 = cborEncoders3[major].compareTokens(keyToken1, keyToken2);
-  if (tcmp === 0) {
-    console.warn("WARNING: complex key types used, CBOR key sorting guarantees are gone");
-  }
-  return tcmp;
-}
-function tokensToEncoded(buf3, tokens, encoders, options) {
-  if (Array.isArray(tokens)) {
-    for (const token of tokens) {
-      tokensToEncoded(buf3, token, encoders, options);
-    }
-  } else {
-    encoders[tokens.type.major](buf3, tokens, options);
-  }
-}
-function encodeCustom(data, encoders, options) {
-  const tokens = objectToTokens2(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 buf3 = new Bl2(size);
-      encoder(buf3, tokens, options);
-      if (buf3.chunks.length !== 1) {
-        throw new Error(`Unexpected error: pre-calculated length for ${tokens} was wrong`);
-      }
-      return asU8A2(buf3.chunks[0]);
-    }
-  }
-  buf2.reset();
-  tokensToEncoded(buf2, tokens, encoders, options);
-  return buf2.toBytes(true);
-}
-function encode6(data, options) {
-  options = Object.assign({}, defaultEncodeOptions2, options);
-  return encodeCustom(data, cborEncoders3, 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 = quick2[byt];
-    if (token === void 0) {
-      const decoder = jump2[byt];
-      if (!decoder) {
-        throw new Error(`${decodeErrPrefix2} 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 DONE2 = Symbol.for("DONE");
-var BREAK2 = 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 === BREAK2) {
-      if (token.value === Infinity) {
-        break;
-      }
-      throw new Error(`${decodeErrPrefix2} got unexpected break to lengthed array`);
-    }
-    if (value === DONE2) {
-      throw new Error(`${decodeErrPrefix2} 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 === BREAK2) {
-      if (token.value === Infinity) {
-        break;
-      }
-      throw new Error(`${decodeErrPrefix2} got unexpected break to lengthed map`);
-    }
-    if (key === DONE2) {
-      throw new Error(`${decodeErrPrefix2} found map but not enough entries (got ${i} [no key], expected ${token.value})`);
-    }
-    if (useMaps !== true && typeof key !== "string") {
-      throw new Error(`${decodeErrPrefix2} non-string keys not supported (got ${typeof key})`);
-    }
-    if (options.rejectDuplicateMapKeys === true) {
-      if (useMaps && m.has(key) || !useMaps && key in obj) {
-        throw new Error(`${decodeErrPrefix2} found repeat map key "${key}"`);
-      }
-    }
-    const value = tokensToObject(tokeniser, options);
-    if (value === DONE2) {
-      throw new Error(`${decodeErrPrefix2} 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 DONE2;
-  }
-  const token = tokeniser.next();
-  if (token.type === Type2.break) {
-    return BREAK2;
-  }
-  if (token.type.terminal) {
-    return token.value;
-  }
-  if (token.type === Type2.array) {
-    return tokenToArray(token, tokeniser, options);
-  }
-  if (token.type === Type2.map) {
-    return tokenToMap(token, tokeniser, options);
-  }
-  if (token.type === Type2.tag) {
-    if (options.tags && typeof options.tags[token.value] === "function") {
-      const tagged = tokensToObject(tokeniser, options);
-      return options.tags[token.value](tagged);
-    }
-    throw new Error(`${decodeErrPrefix2} tag not supported (${token.value})`);
-  }
-  throw new Error("unsupported");
-}
-function decode8(data, options) {
-  if (!(data instanceof Uint8Array)) {
-    throw new Error(`${decodeErrPrefix2} 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 === DONE2) {
-    throw new Error(`${decodeErrPrefix2} did not find any content to decode`);
-  }
-  if (decoded === BREAK2) {
-    throw new Error(`${decodeErrPrefix2} got unexpected break`);
-  }
-  if (!tokeniser.done()) {
-    throw new Error(`${decodeErrPrefix2} 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 Token2(Type2.tag, CID_CBOR_TAG),
-    new Token2(Type2.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 name2 = "dag-cbor";
-var code2 = 113;
-var encode7 = (node) => encode6(node, encodeOptions);
-var decode9 = (data) => decode8(data, decodeOptions);
-
-// node_modules/@ipld/car/src/buffer-writer.js
-var CarBufferWriter = class {
-  /**
-   * @param {Uint8Array} bytes
-   * @param {number} headerSize
-   */
-  constructor(bytes, headerSize) {
-    this.bytes = bytes;
-    this.byteOffset = headerSize;
-    this.roots = [];
-    this.headerSize = headerSize;
-  }
-  /**
-   * Add a root to this writer, to be used to create a header when the CAR is
-   * finalized with {@link CarBufferWriter.close `close()`}
-   *
-   * @param {CID} root
-   * @param {{resize?:boolean}} [options]
-   * @returns {CarBufferWriter}
-   */
-  addRoot(root, options) {
-    addRoot(this, root, options);
-    return this;
-  }
-  /**
-   * Write a `Block` (a `{ cid:CID, bytes:Uint8Array }` pair) to the archive.
-   * Throws if there is not enough capacity.
-   *
-   * @param {Block} block - A `{ cid:CID, bytes:Uint8Array }` pair.
-   * @returns {CarBufferWriter}
-   */
-  write(block) {
-    addBlock(this, block);
-    return this;
-  }
-  /**
-   * Finalize the CAR and return it as a `Uint8Array`.
-   *
-   * @param {object} [options]
-   * @param {boolean} [options.resize]
-   * @returns {Uint8Array}
-   */
-  close(options) {
-    return close(this, options);
-  }
-};
-var addRoot = (writer, root, options = {}) => {
-  const { resize = false } = options;
-  const { bytes, headerSize, byteOffset, roots } = writer;
-  writer.roots.push(root);
-  const size = headerLength(writer);
-  if (size > headerSize) {
-    if (size - headerSize + byteOffset < bytes.byteLength) {
-      if (resize) {
-        resizeHeader(writer, size);
-      } else {
-        roots.pop();
-        throw new RangeError(`Header of size ${headerSize} has no capacity for new root ${root}.
-  However there is a space in the buffer and you could call addRoot(root, { resize: root }) to resize header to make a space for this root.`);
-      }
-    } else {
-      roots.pop();
-      throw new RangeError(`Buffer has no capacity for a new root ${root}`);
-    }
-  }
-};
-var blockLength = ({ cid, bytes }) => {
-  const size = cid.bytes.byteLength + bytes.byteLength;
-  return import_varint2.default.encodingLength(size) + size;
-};
-var addBlock = (writer, { cid, bytes }) => {
-  const byteLength = cid.bytes.byteLength + bytes.byteLength;
-  const size = import_varint2.default.encode(byteLength);
-  if (writer.byteOffset + size.length + byteLength > writer.bytes.byteLength) {
-    throw new RangeError("Buffer has no capacity for this block");
-  } else {
-    writeBytes(writer, size);
-    writeBytes(writer, cid.bytes);
-    writeBytes(writer, bytes);
-  }
-};
-var close = (writer, options = {}) => {
-  const { resize = false } = options;
-  const { roots, bytes, byteOffset, headerSize } = writer;
-  const headerBytes = encode7({ version: 1, roots });
-  const varintBytes = import_varint2.default.encode(headerBytes.length);
-  const size = varintBytes.length + headerBytes.byteLength;
-  const offset = headerSize - size;
-  if (offset === 0) {
-    writeHeader(writer, varintBytes, headerBytes);
-    return bytes.subarray(0, byteOffset);
-  } else if (resize) {
-    resizeHeader(writer, size);
-    writeHeader(writer, varintBytes, headerBytes);
-    return bytes.subarray(0, writer.byteOffset);
-  } else {
-    throw new RangeError(`Header size was overestimated.
-You can use close({ resize: true }) to resize header`);
-  }
-};
-var resizeHeader = (writer, byteLength) => {
-  const { bytes, headerSize } = writer;
-  bytes.set(bytes.subarray(headerSize, writer.byteOffset), byteLength);
-  writer.byteOffset += byteLength - headerSize;
-  writer.headerSize = byteLength;
-};
-var writeBytes = (writer, bytes) => {
-  writer.bytes.set(bytes, writer.byteOffset);
-  writer.byteOffset += bytes.length;
-};
-var writeHeader = ({ bytes }, varint3, header) => {
-  bytes.set(varint3);
-  bytes.set(header, varint3.length);
-};
-var headerPreludeTokens = [
-  new Token(Type.map, 2),
-  new Token(Type.string, "version"),
-  new Token(Type.uint, 1),
-  new Token(Type.string, "roots")
-];
-var CID_TAG = new Token(Type.tag, 42);
-var calculateHeaderLength = (rootLengths) => {
-  const tokens = [...headerPreludeTokens];
-  tokens.push(new Token(Type.array, rootLengths.length));
-  for (const rootLength of rootLengths) {
-    tokens.push(CID_TAG);
-    tokens.push(new Token(Type.bytes, { length: rootLength + 1 }));
-  }
-  const length2 = tokensToLength(tokens);
-  return import_varint2.default.encodingLength(length2) + length2;
-};
-var headerLength = ({ roots }) => calculateHeaderLength(roots.map((cid) => cid.bytes.byteLength));
-var createWriter = (buffer3, options = {}) => {
-  const {
-    roots = [],
-    byteOffset = 0,
-    byteLength = buffer3.byteLength,
-    headerSize = headerLength({ roots })
-  } = options;
-  const bytes = new Uint8Array(buffer3, byteOffset, byteLength);
-  const writer = new CarBufferWriter(bytes, headerSize);
-  for (const root of roots) {
-    writer.addRoot(root);
-  }
-  return writer;
-};
-
-// src/loader-helpers.ts
-async function makeCarFile(t, { head }, cars) {
-  if (!head)
-    throw new Error("no head");
-  const fpCarHeaderBlock = await encode3({
-    value: { fp: { head, cars } },
-    hasher: sha256,
-    codec: src_exports
-  });
-  await t.put(fpCarHeaderBlock.cid, fpCarHeaderBlock.bytes);
-  let size = 0;
-  const headerSize = headerLength({ roots: [fpCarHeaderBlock.cid] });
-  size += headerSize;
-  for (const { cid, bytes } of t.entries()) {
-    size += blockLength({ cid, bytes });
-  }
-  const buffer3 = new Uint8Array(size);
-  const writer = createWriter(buffer3, { headerSize });
-  writer.addRoot(fpCarHeaderBlock.cid);
-  for (const { cid, bytes } of t.entries()) {
-    writer.write({ cid, bytes });
-  }
-  writer.close();
-  return await encode3({ value: writer.bytes, hasher: sha256, codec: raw_exports });
-}
-async function parseCarFile(reader) {
-  const roots = await reader.getRoots();
-  const header = await reader.get(roots[0]);
-  if (!header)
-    throw new Error("missing header block");
-  const got = await decode5({ bytes: header.bytes, hasher: sha256, codec: src_exports });
-  const {
-    fp: { head, cars }
-  } = got.value;
-  return { head, cars };
-}
-export {
-  makeCarFile,
-  parseCarFile
-};
-//# sourceMappingURL=loader-helpers.esm.js.map