@fireproof/core 0.10.0-dev → 0.10.2-dev

package/dist/crdt-helpers.esm.js

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