@wovin/core 0.0.17 → 0.0.19

package/dist/chunk-SIIQEX77.min.js

@@ -0,0 +1,4122 @@
+import {
+  keepTruthy
+} from "./chunk-QPGEBDMJ.min.js";
+import {
+  lastWriteWins
+} from "./chunk-KVPEUWWR.min.js";
+import {
+  CID,
+  areCidsEqual,
+  decode,
+  encodeBlockOriginal,
+  ensureTsPvAndFinalizeApplog,
+  g,
+  getLogsFromThread,
+  prepareForPub,
+  rollingFilter,
+  src_exports,
+  wrapper_default
+} from "./chunk-UZBCM3UI.min.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-PHITDXZT.min.js";
+
+// ../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/encode.js
+var require_encode = __commonJS({
+  "../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/encode.js"(exports, module) {
+    "use strict";
+    module.exports = encode5;
+    var MSB2 = 128;
+    var REST2 = 127;
+    var MSBALL2 = ~REST2;
+    var INT2 = Math.pow(2, 31);
+    function encode5(num, out, offset) {
+      if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
+        encode5.bytes = 0;
+        throw new RangeError("Could not encode varint");
+      }
+      out = out || [];
+      offset = offset || 0;
+      var oldOffset = offset;
+      while (num >= INT2) {
+        out[offset++] = num & 255 | MSB2;
+        num /= 128;
+      }
+      while (num & MSBALL2) {
+        out[offset++] = num & 255 | MSB2;
+        num >>>= 7;
+      }
+      out[offset] = num | 0;
+      encode5.bytes = offset - oldOffset + 1;
+      return out;
+    }
+  }
+});
+
+// ../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/decode.js
+var require_decode = __commonJS({
+  "../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/decode.js"(exports, module) {
+    "use strict";
+    module.exports = read2;
+    var MSB2 = 128;
+    var REST2 = 127;
+    function read2(buf, offset) {
+      var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+      do {
+        if (counter >= l || shift > 49) {
+          read2.bytes = 0;
+          throw new RangeError("Could not decode varint");
+        }
+        b = buf[counter++];
+        res += shift < 28 ? (b & REST2) << shift : (b & REST2) * Math.pow(2, shift);
+        shift += 7;
+      } while (b >= MSB2);
+      read2.bytes = counter - offset;
+      return res;
+    }
+  }
+});
+
+// ../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/length.js
+var require_length = __commonJS({
+  "../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/length.js"(exports, module) {
+    "use strict";
+    var N12 = Math.pow(2, 7);
+    var N22 = Math.pow(2, 14);
+    var N32 = Math.pow(2, 21);
+    var N42 = Math.pow(2, 28);
+    var N52 = Math.pow(2, 35);
+    var N62 = Math.pow(2, 42);
+    var N72 = Math.pow(2, 49);
+    var N82 = Math.pow(2, 56);
+    var N92 = Math.pow(2, 63);
+    module.exports = function(value) {
+      return value < N12 ? 1 : value < N22 ? 2 : value < N32 ? 3 : value < N42 ? 4 : value < N52 ? 5 : value < N62 ? 6 : value < N72 ? 7 : value < N82 ? 8 : value < N92 ? 9 : 10;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/index.js
+var require_varint = __commonJS({
+  "../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/index.js"(exports, module) {
+    "use strict";
+    module.exports = {
+      encode: require_encode(),
+      decode: require_decode(),
+      encodingLength: require_length()
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/cborg@4.5.8/node_modules/cborg/lib/is.js
+var objectTypeNames = [
+  "Object",
+  // for Object.create(null) and other non-plain objects
+  "RegExp",
+  "Date",
+  "Error",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "DataView",
+  "Promise",
+  "URL",
+  "HTMLElement",
+  "Int8Array",
+  "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 (typeOf === "string" || typeOf === "number" || typeOf === "bigint" || typeOf === "symbol") {
+    return typeOf;
+  }
+  if (typeOf === "function") {
+    return "Function";
+  }
+  if (Array.isArray(value)) {
+    return "Array";
+  }
+  if (value instanceof Uint8Array) {
+    return "Uint8Array";
+  }
+  if (value.constructor === Object) {
+    return "Object";
+  }
+  const objectType = getObjectType(value);
+  if (objectType) {
+    return objectType;
+  }
+  return "Object";
+}
+function getObjectType(value) {
+  const objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
+  if (objectTypeNames.includes(objectTypeName)) {
+    return objectTypeName;
+  }
+  return void 0;
+}
+
+// ../../../node_modules/.pnpm/cborg@4.5.8/node_modules/cborg/lib/token.js
+var Type = class {
+  /**
+   * @param {number} major
+   * @param {string} name
+   * @param {boolean} terminal
+   */
+  constructor(major, name, terminal) {
+    this.major = major;
+    this.majorEncoded = major << 5;
+    this.name = name;
+    this.terminal = terminal;
+  }
+  /* c8 ignore next 3 */
+  toString() {
+    return `Type[${this.major}].${this.name}`;
+  }
+  /**
+   * @param {Type} typ
+   * @returns {number}
+   */
+  compare(typ) {
+    return this.major < typ.major ? -1 : this.major > typ.major ? 1 : 0;
+  }
+  /**
+   * Check equality between two Type instances. Safe to use across different
+   * copies of the Type class (e.g., when bundlers duplicate the module).
+   * (major, name) uniquely identifies a Type; terminal is implied by these.
+   * @param {Type} a
+   * @param {Type} b
+   * @returns {boolean}
+   */
+  static equals(a, b) {
+    return a === b || a.major === b.major && a.name === b.name;
+  }
+};
+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 {
+  /**
+   * @param {Type} type
+   * @param {any} [value]
+   * @param {number} [encodedLength]
+   */
+  constructor(type, value, encodedLength) {
+    this.type = type;
+    this.value = value;
+    this.encodedLength = encodedLength;
+    this.encodedBytes = void 0;
+    this.byteValue = void 0;
+  }
+  /* c8 ignore next 3 */
+  toString() {
+    return `Token[${this.type}].${this.value}`;
+  }
+};
+
+// ../../../node_modules/.pnpm/cborg@4.5.8/node_modules/cborg/lib/byte-utils.js
+var useBuffer = globalThis.process && // @ts-ignore
+!globalThis.process.browser && // @ts-ignore
+globalThis.Buffer && // @ts-ignore
+typeof globalThis.Buffer.isBuffer === "function";
+var textEncoder = new TextEncoder();
+function isBuffer(buf) {
+  return useBuffer && globalThis.Buffer.isBuffer(buf);
+}
+function asU8A(buf) {
+  if (!(buf instanceof Uint8Array)) {
+    return Uint8Array.from(buf);
+  }
+  return isBuffer(buf) ? new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength) : buf;
+}
+var FROM_STRING_THRESHOLD_BUFFER = 24;
+var FROM_STRING_THRESHOLD_TEXTENCODER = 200;
+var fromString = useBuffer ? (
+  // eslint-disable-line operator-linebreak
+  /**
+   * @param {string} string
+   */
+  (string) => {
+    return string.length >= FROM_STRING_THRESHOLD_BUFFER ? (
+      // eslint-disable-line operator-linebreak
+      // @ts-ignore
+      globalThis.Buffer.from(string)
+    ) : utf8ToBytes(string);
+  }
+) : (
+  // eslint-disable-line operator-linebreak
+  /**
+   * @param {string} string
+   */
+  (string) => {
+    return string.length >= FROM_STRING_THRESHOLD_TEXTENCODER ? textEncoder.encode(string) : utf8ToBytes(string);
+  }
+);
+var fromArray = (arr) => {
+  return Uint8Array.from(arr);
+};
+var slice = useBuffer ? (
+  // eslint-disable-line operator-linebreak
+  /**
+   * @param {Uint8Array} bytes
+   * @param {number} start
+   * @param {number} end
+   */
+  // Buffer.slice() returns a view, not a copy, so we need special handling
+  (bytes, start, end) => {
+    if (isBuffer(bytes)) {
+      return new Uint8Array(bytes.subarray(start, end));
+    }
+    return bytes.slice(start, end);
+  }
+) : (
+  // eslint-disable-line operator-linebreak
+  /**
+   * @param {Uint8Array} bytes
+   * @param {number} start
+   * @param {number} end
+   */
+  (bytes, start, end) => {
+    return bytes.slice(start, end);
+  }
+);
+var concat = useBuffer ? (
+  // eslint-disable-line operator-linebreak
+  /**
+   * @param {Uint8Array[]} chunks
+   * @param {number} length
+   * @returns {Uint8Array}
+   */
+  (chunks, length2) => {
+    chunks = chunks.map((c) => c instanceof Uint8Array ? c : (
+      // eslint-disable-line operator-linebreak
+      // @ts-ignore
+      globalThis.Buffer.from(c)
+    ));
+    return asU8A(globalThis.Buffer.concat(chunks, length2));
+  }
+) : (
+  // eslint-disable-line operator-linebreak
+  /**
+   * @param {Uint8Array[]} chunks
+   * @param {number} length
+   * @returns {Uint8Array}
+   */
+  (chunks, length2) => {
+    const out = new Uint8Array(length2);
+    let off = 0;
+    for (let b of chunks) {
+      if (off + b.length > out.length) {
+        b = b.subarray(0, out.length - off);
+      }
+      out.set(b, off);
+      off += b.length;
+    }
+    return out;
+  }
+);
+var alloc = useBuffer ? (
+  // eslint-disable-line operator-linebreak
+  /**
+   * @param {number} size
+   * @returns {Uint8Array}
+   */
+  (size) => {
+    return globalThis.Buffer.allocUnsafe(size);
+  }
+) : (
+  // eslint-disable-line operator-linebreak
+  /**
+   * @param {number} size
+   * @returns {Uint8Array}
+   */
+  (size) => {
+    return new Uint8Array(size);
+  }
+);
+function compare(b1, b2) {
+  if (isBuffer(b1) && isBuffer(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(str) {
+  const out = [];
+  let p = 0;
+  for (let i = 0; i < str.length; i++) {
+    let c = str.charCodeAt(i);
+    if (c < 128) {
+      out[p++] = c;
+    } else if (c < 2048) {
+      out[p++] = c >> 6 | 192;
+      out[p++] = c & 63 | 128;
+    } else if ((c & 64512) === 55296 && i + 1 < str.length && (str.charCodeAt(i + 1) & 64512) === 56320) {
+      c = 65536 + ((c & 1023) << 10) + (str.charCodeAt(++i) & 1023);
+      out[p++] = c >> 18 | 240;
+      out[p++] = c >> 12 & 63 | 128;
+      out[p++] = c >> 6 & 63 | 128;
+      out[p++] = c & 63 | 128;
+    } else {
+      if (c >= 55296 && c <= 57343) {
+        c = 65533;
+      }
+      out[p++] = c >> 12 | 224;
+      out[p++] = c >> 6 & 63 | 128;
+      out[p++] = c & 63 | 128;
+    }
+  }
+  return out;
+}
+
+// ../../../node_modules/.pnpm/cborg@4.5.8/node_modules/cborg/lib/bl.js
+var defaultChunkSize = 256;
+var Bl = class {
+  /**
+   * @param {number} [chunkSize]
+   */
+  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;
+    }
+  }
+  /**
+   * @param {Uint8Array|number[]} bytes
+   */
+  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;
+  }
+  /**
+   * @param {boolean} [reset]
+   * @returns {Uint8Array}
+   */
+  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;
+  }
+};
+var U8Bl = class {
+  /**
+   * @param {Uint8Array} dest
+   */
+  constructor(dest) {
+    this.dest = dest;
+    this.cursor = 0;
+    this.chunks = [dest];
+  }
+  reset() {
+    this.cursor = 0;
+  }
+  /**
+   * @param {Uint8Array|number[]} bytes
+   */
+  push(bytes) {
+    if (this.cursor + bytes.length > this.dest.length) {
+      throw new Error("write out of bounds, destination buffer is too small");
+    }
+    this.dest.set(bytes, this.cursor);
+    this.cursor += bytes.length;
+  }
+  /**
+   * @param {boolean} [reset]
+   * @returns {Uint8Array}
+   */
+  toBytes(reset = false) {
+    const byts = this.dest.subarray(0, this.cursor);
+    if (reset) {
+      this.reset();
+    }
+    return byts;
+  }
+};
+
+// ../../../node_modules/.pnpm/cborg@4.5.8/node_modules/cborg/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/.pnpm/cborg@4.5.8/node_modules/cborg/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(writer, token) {
+  return encodeUintValue(writer, 0, token.value);
+}
+function encodeUintValue(writer, major, uint) {
+  if (uint < uintBoundaries[0]) {
+    const nuint = Number(uint);
+    writer.push([major | nuint]);
+  } else if (uint < uintBoundaries[1]) {
+    const nuint = Number(uint);
+    writer.push([major | 24, nuint]);
+  } else if (uint < uintBoundaries[2]) {
+    const nuint = Number(uint);
+    writer.push([major | 25, nuint >>> 8, nuint & 255]);
+  } else if (uint < uintBoundaries[3]) {
+    const nuint = Number(uint);
+    writer.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;
+      writer.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 : (
+    /* c8 ignore next */
+    0
+  );
+};
+
+// ../../../node_modules/.pnpm/cborg@4.5.8/node_modules/cborg/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(writer, token) {
+  const negint = token.value;
+  const unsigned = typeof negint === "bigint" ? negint * neg1b - pos1b : negint * -1 - 1;
+  encodeUintValue(writer, 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 : (
+    /* c8 ignore next */
+    0
+  );
+};
+
+// ../../../node_modules/.pnpm/cborg@4.5.8/node_modules/cborg/lib/2bytes.js
+function toToken(data, pos, prefix, length2) {
+  assertEnoughData(data, pos, prefix + length2);
+  const buf = data.slice(pos + prefix, pos + prefix + length2);
+  return new Token(Type.bytes, buf, prefix + length2);
+}
+function decodeBytesCompact(data, pos, minor, _options) {
+  return toToken(data, pos, 1, minor);
+}
+function decodeBytes8(data, pos, _minor, options) {
+  return toToken(data, pos, 2, readUint8(data, pos + 1, options));
+}
+function decodeBytes16(data, pos, _minor, options) {
+  return toToken(data, pos, 3, readUint16(data, pos + 1, options));
+}
+function decodeBytes32(data, pos, _minor, options) {
+  return toToken(data, pos, 5, readUint32(data, pos + 1, options));
+}
+function decodeBytes64(data, pos, _minor, options) {
+  const l = readUint64(data, pos + 1, options);
+  if (typeof l === "bigint") {
+    throw new Error(`${decodeErrPrefix} 64-bit integer bytes lengths not supported`);
+  }
+  return toToken(data, pos, 9, l);
+}
+function tokenBytes(token) {
+  if (token.encodedBytes === void 0) {
+    token.encodedBytes = Type.equals(token.type, Type.string) ? fromString(token.value) : token.value;
+  }
+  return token.encodedBytes;
+}
+function encodeBytes(writer, token) {
+  const bytes = tokenBytes(token);
+  encodeUintValue(writer, token.type.majorEncoded, bytes.length);
+  writer.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/.pnpm/cborg@4.5.8/node_modules/cborg/lib/3string.js
+var textDecoder = new TextDecoder();
+var ASCII_THRESHOLD = 32;
+function toStr(bytes, start, end) {
+  const len = end - start;
+  if (len < ASCII_THRESHOLD) {
+    let str = "";
+    for (let i = start; i < end; i++) {
+      const c = bytes[i];
+      if (c & 128) {
+        return textDecoder.decode(bytes.subarray(start, end));
+      }
+      str += String.fromCharCode(c);
+    }
+    return str;
+  }
+  return textDecoder.decode(bytes.subarray(start, end));
+}
+function toToken2(data, pos, prefix, length2, options) {
+  const totLength = prefix + length2;
+  assertEnoughData(data, pos, totLength);
+  const tok = new Token(Type.string, toStr(data, pos + prefix, pos + totLength), totLength);
+  if (options.retainStringBytes === true) {
+    tok.byteValue = data.slice(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/.pnpm/cborg@4.5.8/node_modules/cborg/lib/4array.js
+function toToken3(_data, _pos, prefix, length2) {
+  return new Token(Type.array, length2, prefix);
+}
+function decodeArrayCompact(data, pos, minor, _options) {
+  return toToken3(data, pos, 1, minor);
+}
+function decodeArray8(data, pos, _minor, options) {
+  return toToken3(data, pos, 2, readUint8(data, pos + 1, options));
+}
+function decodeArray16(data, pos, _minor, options) {
+  return toToken3(data, pos, 3, readUint16(data, pos + 1, options));
+}
+function decodeArray32(data, pos, _minor, options) {
+  return toToken3(data, pos, 5, readUint32(data, pos + 1, options));
+}
+function decodeArray64(data, pos, _minor, options) {
+  const l = readUint64(data, pos + 1, options);
+  if (typeof l === "bigint") {
+    throw new Error(`${decodeErrPrefix} 64-bit integer array lengths not supported`);
+  }
+  return toToken3(data, pos, 9, l);
+}
+function decodeArrayIndefinite(data, pos, _minor, options) {
+  if (options.allowIndefinite === false) {
+    throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
+  }
+  return toToken3(data, pos, 1, Infinity);
+}
+function encodeArray(writer, token) {
+  encodeUintValue(writer, Type.array.majorEncoded, token.value);
+}
+encodeArray.compareTokens = encodeUint.compareTokens;
+encodeArray.encodedSize = function encodedSize5(token) {
+  return encodeUintValue.encodedSize(token.value);
+};
+
+// ../../../node_modules/.pnpm/cborg@4.5.8/node_modules/cborg/lib/5map.js
+function toToken4(_data, _pos, prefix, length2) {
+  return new Token(Type.map, length2, prefix);
+}
+function decodeMapCompact(data, pos, minor, _options) {
+  return toToken4(data, pos, 1, minor);
+}
+function decodeMap8(data, pos, _minor, options) {
+  return toToken4(data, pos, 2, readUint8(data, pos + 1, options));
+}
+function decodeMap16(data, pos, _minor, options) {
+  return toToken4(data, pos, 3, readUint16(data, pos + 1, options));
+}
+function decodeMap32(data, pos, _minor, options) {
+  return toToken4(data, pos, 5, readUint32(data, pos + 1, options));
+}
+function decodeMap64(data, pos, _minor, options) {
+  const l = readUint64(data, pos + 1, options);
+  if (typeof l === "bigint") {
+    throw new Error(`${decodeErrPrefix} 64-bit integer map lengths not supported`);
+  }
+  return toToken4(data, pos, 9, l);
+}
+function decodeMapIndefinite(data, pos, _minor, options) {
+  if (options.allowIndefinite === false) {
+    throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
+  }
+  return toToken4(data, pos, 1, Infinity);
+}
+function encodeMap(writer, token) {
+  encodeUintValue(writer, Type.map.majorEncoded, token.value);
+}
+encodeMap.compareTokens = encodeUint.compareTokens;
+encodeMap.encodedSize = function encodedSize6(token) {
+  return encodeUintValue.encodedSize(token.value);
+};
+
+// ../../../node_modules/.pnpm/cborg@4.5.8/node_modules/cborg/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(writer, token) {
+  encodeUintValue(writer, Type.tag.majorEncoded, token.value);
+}
+encodeTag.compareTokens = encodeUint.compareTokens;
+encodeTag.encodedSize = function encodedSize7(token) {
+  return encodeUintValue.encodedSize(token.value);
+};
+
+// ../../../node_modules/.pnpm/cborg@4.5.8/node_modules/cborg/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(writer, token, options) {
+  const float = token.value;
+  if (float === false) {
+    writer.push([Type.float.majorEncoded | MINOR_FALSE]);
+  } else if (float === true) {
+    writer.push([Type.float.majorEncoded | MINOR_TRUE]);
+  } else if (float === null) {
+    writer.push([Type.float.majorEncoded | MINOR_NULL]);
+  } else if (float === void 0) {
+    writer.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;
+        writer.push(ui8a.slice(0, 3));
+        success = true;
+      } else {
+        encodeFloat32(float);
+        decoded = readFloat32(ui8a, 1);
+        if (float === decoded) {
+          ui8a[0] = 250;
+          writer.push(ui8a.slice(0, 5));
+          success = true;
+        }
+      }
+    }
+    if (!success) {
+      encodeFloat64(float);
+      decoded = readFloat64(ui8a, 1);
+      ui8a[0] = 251;
+      writer.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 | /* sign bit */
+        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/.pnpm/cborg@4.5.8/node_modules/cborg/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/.pnpm/cborg@4.5.8/node_modules/cborg/lib/encode.js
+var defaultEncodeOptions = {
+  float64: false,
+  mapSorter,
+  quickEncodeToken
+};
+var rfc8949EncodeOptions = Object.freeze({
+  float64: true,
+  mapSorter: rfc8949MapSorter,
+  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 defaultWriter = new Bl();
+var Ref = class _Ref {
+  /**
+   * @param {object|any[]} obj
+   * @param {Reference|undefined} parent
+   */
+  constructor(obj, parent) {
+    this.obj = obj;
+    this.parent = parent;
+  }
+  /**
+   * @param {object|any[]} obj
+   * @returns {boolean}
+   */
+  includes(obj) {
+    let p = this;
+    do {
+      if (p.obj === obj) {
+        return true;
+      }
+    } while (p = p.parent);
+    return false;
+  }
+  /**
+   * @param {Reference|undefined} stack
+   * @param {object|any[]} obj
+   * @returns {Reference}
+   */
+  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 = {
+  /**
+   * @param {any} obj
+   * @param {string} _typ
+   * @param {EncodeOptions} _options
+   * @param {Reference} [_refStack]
+   * @returns {TokenOrNestedTokens}
+   */
+  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);
+    }
+  },
+  /**
+   * @param {any} obj
+   * @param {string} _typ
+   * @param {EncodeOptions} _options
+   * @param {Reference} [_refStack]
+   * @returns {TokenOrNestedTokens}
+   */
+  bigint(obj, _typ, _options, _refStack) {
+    if (obj >= BigInt(0)) {
+      return new Token(Type.uint, obj);
+    } else {
+      return new Token(Type.negint, obj);
+    }
+  },
+  /**
+   * @param {any} obj
+   * @param {string} _typ
+   * @param {EncodeOptions} _options
+   * @param {Reference} [_refStack]
+   * @returns {TokenOrNestedTokens}
+   */
+  Uint8Array(obj, _typ, _options, _refStack) {
+    return new Token(Type.bytes, obj);
+  },
+  /**
+   * @param {any} obj
+   * @param {string} _typ
+   * @param {EncodeOptions} _options
+   * @param {Reference} [_refStack]
+   * @returns {TokenOrNestedTokens}
+   */
+  string(obj, _typ, _options, _refStack) {
+    return new Token(Type.string, obj);
+  },
+  /**
+   * @param {any} obj
+   * @param {string} _typ
+   * @param {EncodeOptions} _options
+   * @param {Reference} [_refStack]
+   * @returns {TokenOrNestedTokens}
+   */
+  boolean(obj, _typ, _options, _refStack) {
+    return obj ? simpleTokens.true : simpleTokens.false;
+  },
+  /**
+   * @param {any} _obj
+   * @param {string} _typ
+   * @param {EncodeOptions} _options
+   * @param {Reference} [_refStack]
+   * @returns {TokenOrNestedTokens}
+   */
+  null(_obj, _typ, _options, _refStack) {
+    return simpleTokens.null;
+  },
+  /**
+   * @param {any} _obj
+   * @param {string} _typ
+   * @param {EncodeOptions} _options
+   * @param {Reference} [_refStack]
+   * @returns {TokenOrNestedTokens}
+   */
+  undefined(_obj, _typ, _options, _refStack) {
+    return simpleTokens.undefined;
+  },
+  /**
+   * @param {any} obj
+   * @param {string} _typ
+   * @param {EncodeOptions} _options
+   * @param {Reference} [_refStack]
+   * @returns {TokenOrNestedTokens}
+   */
+  ArrayBuffer(obj, _typ, _options, _refStack) {
+    return new Token(Type.bytes, new Uint8Array(obj));
+  },
+  /**
+   * @param {any} obj
+   * @param {string} _typ
+   * @param {EncodeOptions} _options
+   * @param {Reference} [_refStack]
+   * @returns {TokenOrNestedTokens}
+   */
+  DataView(obj, _typ, _options, _refStack) {
+    return new Token(Type.bytes, new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength));
+  },
+  /**
+   * @param {any} obj
+   * @param {string} _typ
+   * @param {EncodeOptions} options
+   * @param {Reference} [refStack]
+   * @returns {TokenOrNestedTokens}
+   */
+  Array(obj, _typ, options, refStack) {
+    if (!obj.length) {
+      if (options.addBreakTokens === true) {
+        return [simpleTokens.emptyArray, new Token(Type.break)];
+      }
+      return simpleTokens.emptyArray;
+    }
+    refStack = Ref.createCheck(refStack, obj);
+    const entries = [];
+    let i = 0;
+    for (const e of obj) {
+      entries[i++] = objectToTokens(e, options, refStack);
+    }
+    if (options.addBreakTokens) {
+      return [new Token(Type.array, obj.length), entries, new Token(Type.break)];
+    }
+    return [new Token(Type.array, obj.length), entries];
+  },
+  /**
+   * @param {any} obj
+   * @param {string} typ
+   * @param {EncodeOptions} options
+   * @param {Reference} [refStack]
+   * @returns {TokenOrNestedTokens}
+   */
+  Object(obj, typ, options, refStack) {
+    const isMap = typ !== "Object";
+    const keys = isMap ? obj.keys() : Object.keys(obj);
+    const maxLength = isMap ? obj.size : keys.length;
+    let entries;
+    if (maxLength) {
+      entries = new Array(maxLength);
+      refStack = Ref.createCheck(refStack, obj);
+      const skipUndefined = !isMap && options.ignoreUndefinedProperties;
+      let i = 0;
+      for (const key of keys) {
+        const value = isMap ? obj.get(key) : obj[key];
+        if (skipUndefined && value === void 0) {
+          continue;
+        }
+        entries[i++] = [
+          objectToTokens(key, options, refStack),
+          objectToTokens(value, options, refStack)
+        ];
+      }
+      if (i < maxLength) {
+        entries.length = i;
+      }
+    }
+    if (!entries?.length) {
+      if (options.addBreakTokens === true) {
+        return [simpleTokens.emptyMap, new Token(Type.break)];
+      }
+      return simpleTokens.emptyMap;
+    }
+    sortMapEntries(entries, options);
+    if (options.addBreakTokens) {
+      return [new Token(Type.map, entries.length), entries, new Token(Type.break)];
+    }
+    return [new Token(Type.map, entries.length), entries];
+  }
+};
+typeEncoders.Map = typeEncoders.Object;
+typeEncoders.Buffer = typeEncoders.Uint8Array;
+for (const typ of "Uint8Clamped Uint16 Uint32 Int8 Int16 Int32 BigUint64 BigInt64 Float32 Float64".split(" ")) {
+  typeEncoders[`${typ}Array`] = typeEncoders.DataView;
+}
+function objectToTokens(obj, options = {}, refStack) {
+  const typ = is(obj);
+  const customTypeEncoder = options && options.typeEncoders && /** @type {OptionalTypeEncoder} */
+  options.typeEncoders[typ] || typeEncoders[typ];
+  if (typeof customTypeEncoder === "function") {
+    const tokens = customTypeEncoder(obj, typ, options, refStack);
+    if (tokens != null) {
+      return tokens;
+    }
+  }
+  const typeEncoder = typeEncoders[typ];
+  if (!typeEncoder) {
+    throw new Error(`${encodeErrPrefix} unsupported type: ${typ}`);
+  }
+  return typeEncoder(obj, typ, options, refStack);
+}
+function sortMapEntries(entries, options) {
+  if (options.mapSorter) {
+    entries.sort(options.mapSorter);
+  }
+}
+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 rfc8949MapSorter(e1, e2) {
+  if (e1[0] instanceof Token && e2[0] instanceof Token) {
+    const t1 = (
+      /** @type {TokenEx} */
+      e1[0]
+    );
+    const t2 = (
+      /** @type {TokenEx} */
+      e2[0]
+    );
+    if (!t1._keyBytes) {
+      t1._keyBytes = encodeRfc8949(t1.value);
+    }
+    if (!t2._keyBytes) {
+      t2._keyBytes = encodeRfc8949(t2.value);
+    }
+    return compare(t1._keyBytes, t2._keyBytes);
+  }
+  throw new Error("rfc8949MapSorter: complex key types are not supported yet");
+}
+function encodeRfc8949(data) {
+  return encodeCustom(data, cborEncoders, rfc8949EncodeOptions);
+}
+function tokensToEncoded(writer, tokens, encoders, options) {
+  if (Array.isArray(tokens)) {
+    for (const token of tokens) {
+      tokensToEncoded(writer, token, encoders, options);
+    }
+  } else {
+    encoders[tokens.type.major](writer, tokens, options);
+  }
+}
+var MAJOR_UINT = Type.uint.majorEncoded;
+var MAJOR_NEGINT = Type.negint.majorEncoded;
+var MAJOR_BYTES = Type.bytes.majorEncoded;
+var MAJOR_STRING = Type.string.majorEncoded;
+var MAJOR_ARRAY = Type.array.majorEncoded;
+var SIMPLE_FALSE = Type.float.majorEncoded | MINOR_FALSE;
+var SIMPLE_TRUE = Type.float.majorEncoded | MINOR_TRUE;
+var SIMPLE_NULL = Type.float.majorEncoded | MINOR_NULL;
+var SIMPLE_UNDEFINED = Type.float.majorEncoded | MINOR_UNDEFINED;
+var neg1b2 = BigInt(-1);
+var pos1b2 = BigInt(1);
+function canDirectEncode(options) {
+  return options.addBreakTokens !== true;
+}
+function directEncode(writer, data, options, refStack) {
+  const typ = is(data);
+  const customEncoder = options.typeEncoders && options.typeEncoders[typ];
+  if (customEncoder) {
+    const tokens = customEncoder(data, typ, options, refStack);
+    if (tokens != null) {
+      tokensToEncoded(writer, tokens, cborEncoders, options);
+      return;
+    }
+  }
+  switch (typ) {
+    case "null":
+      writer.push([SIMPLE_NULL]);
+      return;
+    case "undefined":
+      writer.push([SIMPLE_UNDEFINED]);
+      return;
+    case "boolean":
+      writer.push([data ? SIMPLE_TRUE : SIMPLE_FALSE]);
+      return;
+    case "number":
+      if (!Number.isInteger(data) || !Number.isSafeInteger(data)) {
+        encodeFloat(writer, new Token(Type.float, data), options);
+      } else if (data >= 0) {
+        encodeUintValue(writer, MAJOR_UINT, data);
+      } else {
+        encodeUintValue(writer, MAJOR_NEGINT, data * -1 - 1);
+      }
+      return;
+    case "bigint":
+      if (data >= BigInt(0)) {
+        encodeUintValue(writer, MAJOR_UINT, data);
+      } else {
+        encodeUintValue(writer, MAJOR_NEGINT, data * neg1b2 - pos1b2);
+      }
+      return;
+    case "string": {
+      const bytes = fromString(data);
+      encodeUintValue(writer, MAJOR_STRING, bytes.length);
+      writer.push(bytes);
+      return;
+    }
+    case "Uint8Array":
+      encodeUintValue(writer, MAJOR_BYTES, data.length);
+      writer.push(data);
+      return;
+    case "Array":
+      if (!data.length) {
+        writer.push([MAJOR_ARRAY]);
+        return;
+      }
+      refStack = Ref.createCheck(refStack, data);
+      encodeUintValue(writer, MAJOR_ARRAY, data.length);
+      for (const elem of data) {
+        directEncode(writer, elem, options, refStack);
+      }
+      return;
+    case "Object":
+    case "Map":
+      {
+        const tokens = typeEncoders.Object(data, typ, options, refStack);
+        tokensToEncoded(writer, tokens, cborEncoders, options);
+      }
+      return;
+    default: {
+      const typeEncoder = typeEncoders[typ];
+      if (!typeEncoder) {
+        throw new Error(`${encodeErrPrefix} unsupported type: ${typ}`);
+      }
+      const tokens = typeEncoder(data, typ, options, refStack);
+      tokensToEncoded(writer, tokens, cborEncoders, options);
+    }
+  }
+}
+function encodeCustom(data, encoders, options, destination) {
+  const hasDest = destination instanceof Uint8Array;
+  let writeTo = hasDest ? new U8Bl(destination) : defaultWriter;
+  const tokens = objectToTokens(data, options);
+  if (!Array.isArray(tokens) && options.quickEncodeToken) {
+    const quickBytes = options.quickEncodeToken(tokens);
+    if (quickBytes) {
+      if (hasDest) {
+        writeTo.push(quickBytes);
+        return writeTo.toBytes();
+      }
+      return quickBytes;
+    }
+    const encoder = encoders[tokens.type.major];
+    if (encoder.encodedSize) {
+      const size = encoder.encodedSize(tokens, options);
+      if (!hasDest) {
+        writeTo = new Bl(size);
+      }
+      encoder(writeTo, tokens, options);
+      if (writeTo.chunks.length !== 1) {
+        throw new Error(`Unexpected error: pre-calculated length for ${tokens} was wrong`);
+      }
+      return hasDest ? writeTo.toBytes() : asU8A(writeTo.chunks[0]);
+    }
+  }
+  writeTo.reset();
+  tokensToEncoded(writeTo, tokens, encoders, options);
+  return writeTo.toBytes(true);
+}
+function encode(data, options) {
+  options = Object.assign({}, defaultEncodeOptions, options);
+  if (canDirectEncode(options)) {
+    defaultWriter.reset();
+    directEncode(defaultWriter, data, options, void 0);
+    return defaultWriter.toBytes(true);
+  }
+  return encodeCustom(data, cborEncoders, options);
+}
+
+// ../../../node_modules/.pnpm/cborg@4.5.8/node_modules/cborg/lib/decode.js
+var defaultDecodeOptions = {
+  strict: false,
+  allowIndefinite: true,
+  allowUndefined: true,
+  allowBigInt: true
+};
+var Tokeniser = class {
+  /**
+   * @param {Uint8Array} data
+   * @param {DecodeOptions} options
+   */
+  constructor(data, options = {}) {
+    this._pos = 0;
+    this.data = data;
+    this.options = options;
+  }
+  pos() {
+    return this._pos;
+  }
+  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 rejectDuplicateMapKeys = options.rejectDuplicateMapKeys === 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 && typeof key !== "string") {
+      throw new Error(`${decodeErrPrefix} non-string keys not supported (got ${typeof key})`);
+    }
+    if (rejectDuplicateMapKeys) {
+      if (useMaps && m.has(key) || !useMaps && Object.hasOwn(obj, key)) {
+        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 (Type.equals(token.type, Type.break)) {
+    return BREAK;
+  }
+  if (token.type.terminal) {
+    return token.value;
+  }
+  if (Type.equals(token.type, Type.array)) {
+    return tokenToArray(token, tokeniser, options);
+  }
+  if (Type.equals(token.type, Type.map)) {
+    return tokenToMap(token, tokeniser, options);
+  }
+  if (Type.equals(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 decodeFirst(data, options) {
+  if (!(data instanceof Uint8Array)) {
+    throw new Error(`${decodeErrPrefix} data to decode must be a Uint8Array`);
+  }
+  options = Object.assign({}, defaultDecodeOptions, options);
+  const u8aData = asU8A(data);
+  const tokeniser = options.tokenizer || new Tokeniser(u8aData, 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`);
+  }
+  return [decoded, data.subarray(tokeniser.pos())];
+}
+function decode2(data, options) {
+  const [decoded, remainder] = decodeFirst(data, options);
+  if (remainder.length > 0) {
+    throw new Error(`${decodeErrPrefix} too many terminals, data makes no sense`);
+  }
+  return decoded;
+}
+
+// ../../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bytes.js
+var empty = new Uint8Array(0);
+function equals(aa, bb) {
+  if (aa === bb) {
+    return true;
+  }
+  if (aa.byteLength !== bb.byteLength) {
+    return false;
+  }
+  for (let ii = 0; ii < aa.byteLength; ii++) {
+    if (aa[ii] !== bb[ii]) {
+      return false;
+    }
+  }
+  return true;
+}
+function coerce(o) {
+  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array") {
+    return o;
+  }
+  if (o instanceof ArrayBuffer) {
+    return new Uint8Array(o);
+  }
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+  }
+  throw new Error("Unknown type, must be binary type");
+}
+
+// ../../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/vendor/base-x.js
+function base(ALPHABET, name) {
+  if (ALPHABET.length >= 255) {
+    throw new TypeError("Alphabet too long");
+  }
+  var BASE_MAP = new Uint8Array(256);
+  for (var j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (var i = 0; i < ALPHABET.length; i++) {
+    var x = ALPHABET.charAt(i);
+    var xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) {
+      throw new TypeError(x + " is ambiguous");
+    }
+    BASE_MAP[xc] = i;
+  }
+  var BASE = ALPHABET.length;
+  var LEADER = ALPHABET.charAt(0);
+  var FACTOR = Math.log(BASE) / Math.log(256);
+  var iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode5(source) {
+    if (source instanceof Uint8Array)
+      ;
+    else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) {
+      throw new TypeError("Expected Uint8Array");
+    }
+    if (source.length === 0) {
+      return "";
+    }
+    var zeroes = 0;
+    var length2 = 0;
+    var pbegin = 0;
+    var pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    var b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      var carry = source[pbegin];
+      var i2 = 0;
+      for (var it1 = size - 1; (carry !== 0 || i2 < length2) && it1 !== -1; it1--, i2++) {
+        carry += 256 * b58[it1] >>> 0;
+        b58[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length2 = i2;
+      pbegin++;
+    }
+    var it2 = size - length2;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    var str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) {
+      str += ALPHABET.charAt(b58[it2]);
+    }
+    return str;
+  }
+  function decodeUnsafe(source) {
+    if (typeof source !== "string") {
+      throw new TypeError("Expected String");
+    }
+    if (source.length === 0) {
+      return new Uint8Array();
+    }
+    var psz = 0;
+    if (source[psz] === " ") {
+      return;
+    }
+    var zeroes = 0;
+    var length2 = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    var size = (source.length - psz) * FACTOR + 1 >>> 0;
+    var b256 = new Uint8Array(size);
+    while (source[psz]) {
+      var carry = BASE_MAP[source.charCodeAt(psz)];
+      if (carry === 255) {
+        return;
+      }
+      var i2 = 0;
+      for (var it3 = size - 1; (carry !== 0 || i2 < length2) && it3 !== -1; it3--, i2++) {
+        carry += BASE * b256[it3] >>> 0;
+        b256[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length2 = i2;
+      psz++;
+    }
+    if (source[psz] === " ") {
+      return;
+    }
+    var it4 = size - length2;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    var vch = new Uint8Array(zeroes + (size - it4));
+    var j2 = zeroes;
+    while (it4 !== size) {
+      vch[j2++] = b256[it4++];
+    }
+    return vch;
+  }
+  function decode8(string) {
+    var buffer2 = decodeUnsafe(string);
+    if (buffer2) {
+      return buffer2;
+    }
+    throw new Error(`Non-${name} character`);
+  }
+  return {
+    encode: encode5,
+    decodeUnsafe,
+    decode: decode8
+  };
+}
+var src = base;
+var _brrp__multiformats_scope_baseX = src;
+var base_x_default = _brrp__multiformats_scope_baseX;
+
+// ../../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base.js
+var Encoder = class {
+  name;
+  prefix;
+  baseEncode;
+  constructor(name, prefix, baseEncode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+  }
+  encode(bytes) {
+    if (bytes instanceof Uint8Array) {
+      return `${this.prefix}${this.baseEncode(bytes)}`;
+    } else {
+      throw Error("Unknown type, must be binary type");
+    }
+  }
+};
+var Decoder = class {
+  name;
+  prefix;
+  baseDecode;
+  prefixCodePoint;
+  constructor(name, prefix, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    const prefixCodePoint = prefix.codePointAt(0);
+    if (prefixCodePoint === void 0) {
+      throw new Error("Invalid prefix character");
+    }
+    this.prefixCodePoint = prefixCodePoint;
+    this.baseDecode = baseDecode;
+  }
+  decode(text) {
+    if (typeof text === "string") {
+      if (text.codePointAt(0) !== this.prefixCodePoint) {
+        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+      }
+      return this.baseDecode(text.slice(this.prefix.length));
+    } else {
+      throw Error("Can only multibase decode strings");
+    }
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+};
+var ComposedDecoder = class {
+  decoders;
+  constructor(decoders) {
+    this.decoders = decoders;
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+  decode(input) {
+    const prefix = input[0];
+    const decoder = this.decoders[prefix];
+    if (decoder != null) {
+      return decoder.decode(input);
+    } else {
+      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+    }
+  }
+};
+function or(left, right) {
+  return new ComposedDecoder({
+    ...left.decoders ?? { [left.prefix]: left },
+    ...right.decoders ?? { [right.prefix]: right }
+  });
+}
+var Codec = class {
+  name;
+  prefix;
+  baseEncode;
+  baseDecode;
+  encoder;
+  decoder;
+  constructor(name, prefix, baseEncode, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+    this.baseDecode = baseDecode;
+    this.encoder = new Encoder(name, prefix, baseEncode);
+    this.decoder = new Decoder(name, prefix, baseDecode);
+  }
+  encode(input) {
+    return this.encoder.encode(input);
+  }
+  decode(input) {
+    return this.decoder.decode(input);
+  }
+};
+function from({ name, prefix, encode: encode5, decode: decode8 }) {
+  return new Codec(name, prefix, encode5, decode8);
+}
+function baseX({ name, prefix, alphabet }) {
+  const { encode: encode5, decode: decode8 } = base_x_default(alphabet, name);
+  return from({
+    prefix,
+    name,
+    encode: encode5,
+    decode: (text) => coerce(decode8(text))
+  });
+}
+function decode3(string, alphabetIdx, bitsPerChar, name) {
+  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 = alphabetIdx[string[i]];
+    if (value === void 0) {
+      throw new SyntaxError(`Non-${name} character`);
+    }
+    buffer2 = buffer2 << bitsPerChar | value;
+    bits += bitsPerChar;
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 255 & buffer2 >> bits;
+    }
+  }
+  if (bits >= bitsPerChar || (255 & buffer2 << 8 - bits) !== 0) {
+    throw new SyntaxError("Unexpected end of data");
+  }
+  return out;
+}
+function 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 !== 0) {
+    out += alphabet[mask & buffer2 << bitsPerChar - bits];
+  }
+  if (pad) {
+    while ((out.length * bitsPerChar & 7) !== 0) {
+      out += "=";
+    }
+  }
+  return out;
+}
+function createAlphabetIdx(alphabet) {
+  const alphabetIdx = {};
+  for (let i = 0; i < alphabet.length; ++i) {
+    alphabetIdx[alphabet[i]] = i;
+  }
+  return alphabetIdx;
+}
+function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
+  const alphabetIdx = createAlphabetIdx(alphabet);
+  return from({
+    prefix,
+    name,
+    encode(input) {
+      return encode2(input, alphabet, bitsPerChar);
+    },
+    decode(input) {
+      return decode3(input, alphabetIdx, bitsPerChar, name);
+    }
+  });
+}
+
+// ../../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/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/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base36.js
+var base36 = baseX({
+  prefix: "k",
+  name: "base36",
+  alphabet: "0123456789abcdefghijklmnopqrstuvwxyz"
+});
+var base36upper = baseX({
+  prefix: "K",
+  name: "base36upper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+});
+
+// ../../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base58.js
+var base58btc = baseX({
+  name: "base58btc",
+  prefix: "z",
+  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+});
+var base58flickr = baseX({
+  name: "base58flickr",
+  prefix: "Z",
+  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+});
+
+// ../../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/vendor/varint.js
+var encode_1 = encode3;
+var MSB = 128;
+var REST = 127;
+var MSBALL = ~REST;
+var INT = Math.pow(2, 31);
+function encode3(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;
+  encode3.bytes = offset - oldOffset + 1;
+  return out;
+}
+var decode4 = read;
+var MSB$1 = 128;
+var REST$1 = 127;
+function read(buf, offset) {
+  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+  do {
+    if (counter >= l) {
+      read.bytes = 0;
+      throw new RangeError("Could not decode varint");
+    }
+    b = buf[counter++];
+    res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
+    shift += 7;
+  } while (b >= MSB$1);
+  read.bytes = counter - offset;
+  return res;
+}
+var 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: decode4,
+  encodingLength: length
+};
+var _brrp_varint = varint;
+var varint_default = _brrp_varint;
+
+// ../../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/varint.js
+function decode5(data, offset = 0) {
+  const code = varint_default.decode(data, offset);
+  return [code, varint_default.decode.bytes];
+}
+function encodeTo(int, target, offset = 0) {
+  varint_default.encode(int, target, offset);
+  return target;
+}
+function encodingLength(int) {
+  return varint_default.encodingLength(int);
+}
+
+// ../../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/hashes/digest.js
+function create(code, digest) {
+  const size = digest.byteLength;
+  const sizeOffset = encodingLength(code);
+  const digestOffset = sizeOffset + encodingLength(size);
+  const bytes = new Uint8Array(digestOffset + size);
+  encodeTo(code, bytes, 0);
+  encodeTo(size, bytes, sizeOffset);
+  bytes.set(digest, digestOffset);
+  return new Digest(code, size, digest, bytes);
+}
+function decode6(multihash) {
+  const bytes = coerce(multihash);
+  const [code, sizeOffset] = decode5(bytes);
+  const [size, digestOffset] = decode5(bytes.subarray(sizeOffset));
+  const digest = bytes.subarray(sizeOffset + digestOffset);
+  if (digest.byteLength !== size) {
+    throw new Error("Incorrect length");
+  }
+  return new Digest(code, size, digest, bytes);
+}
+function equals2(a, b) {
+  if (a === b) {
+    return true;
+  } else {
+    const data = b;
+    return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals(a.bytes, data.bytes);
+  }
+}
+var Digest = class {
+  code;
+  size;
+  digest;
+  bytes;
+  /**
+   * Creates a multihash digest.
+   */
+  constructor(code, size, digest, bytes) {
+    this.code = code;
+    this.size = size;
+    this.digest = digest;
+    this.bytes = bytes;
+  }
+};
+
+// ../../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/cid.js
+function format(link, base2) {
+  const { bytes, version } = link;
+  switch (version) {
+    case 0:
+      return toStringV0(bytes, baseCache(link), base2 ?? base58btc.encoder);
+    default:
+      return toStringV1(bytes, baseCache(link), base2 ?? base32.encoder);
+  }
+}
+var cache = /* @__PURE__ */ new WeakMap();
+function baseCache(cid) {
+  const baseCache2 = cache.get(cid);
+  if (baseCache2 == null) {
+    const baseCache3 = /* @__PURE__ */ new Map();
+    cache.set(cid, baseCache3);
+    return baseCache3;
+  }
+  return baseCache2;
+}
+var CID2 = class _CID {
+  code;
+  version;
+  multihash;
+  bytes;
+  "/";
+  /**
+   * @param version - Version of the CID
+   * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+   * @param multihash - (Multi)hash of the of the content.
+   */
+  constructor(version, code, multihash, bytes) {
+    this.code = code;
+    this.version = version;
+    this.multihash = multihash;
+    this.bytes = bytes;
+    this["/"] = bytes;
+  }
+  /**
+   * Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`
+   * please either use `CID.asCID(cid)` or switch to new signalling mechanism
+   *
+   * @deprecated
+   */
+  get asCID() {
+    return this;
+  }
+  // ArrayBufferView
+  get byteOffset() {
+    return this.bytes.byteOffset;
+  }
+  // ArrayBufferView
+  get byteLength() {
+    return this.bytes.byteLength;
+  }
+  toV0() {
+    switch (this.version) {
+      case 0: {
+        return this;
+      }
+      case 1: {
+        const { code, multihash } = this;
+        if (code !== DAG_PB_CODE) {
+          throw new Error("Cannot convert a non dag-pb CID to CIDv0");
+        }
+        if (multihash.code !== SHA_256_CODE) {
+          throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
+        }
+        return _CID.createV0(multihash);
+      }
+      default: {
+        throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
+      }
+    }
+  }
+  toV1() {
+    switch (this.version) {
+      case 0: {
+        const { code, digest } = this.multihash;
+        const multihash = create(code, digest);
+        return _CID.createV1(this.code, multihash);
+      }
+      case 1: {
+        return this;
+      }
+      default: {
+        throw Error(`Can not convert CID version ${this.version} to version 1. This is a bug please report`);
+      }
+    }
+  }
+  equals(other) {
+    return _CID.equals(this, other);
+  }
+  static equals(self, other) {
+    const unknown = other;
+    return unknown != null && self.code === unknown.code && self.version === unknown.version && equals2(self.multihash, unknown.multihash);
+  }
+  toString(base2) {
+    return format(this, base2);
+  }
+  toJSON() {
+    return { "/": format(this) };
+  }
+  link() {
+    return this;
+  }
+  [Symbol.toStringTag] = "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.
+   */
+  static asCID(input) {
+    if (input == null) {
+      return null;
+    }
+    const value = input;
+    if (value instanceof _CID) {
+      return value;
+    } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
+      const { version, code, multihash, bytes } = value;
+      return new _CID(version, code, multihash, bytes ?? encodeCID(version, code, multihash.bytes));
+    } else if (value[cidSymbol] === true) {
+      const { version, multihash, code } = value;
+      const digest = decode6(multihash);
+      return _CID.create(version, code, digest);
+    } else {
+      return null;
+    }
+  }
+  /**
+   * @param version - Version of the CID
+   * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+   * @param digest - (Multi)hash of the of the content.
+   */
+  static create(version, code, digest) {
+    if (typeof code !== "number") {
+      throw new Error("String codecs are no longer supported");
+    }
+    if (!(digest.bytes instanceof Uint8Array)) {
+      throw new Error("Invalid digest");
+    }
+    switch (version) {
+      case 0: {
+        if (code !== DAG_PB_CODE) {
+          throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`);
+        } else {
+          return new _CID(version, code, digest, digest.bytes);
+        }
+      }
+      case 1: {
+        const bytes = encodeCID(version, code, digest.bytes);
+        return new _CID(version, code, digest, bytes);
+      }
+      default: {
+        throw new Error("Invalid version");
+      }
+    }
+  }
+  /**
+   * Simplified version of `create` for CIDv0.
+   */
+  static createV0(digest) {
+    return _CID.create(0, DAG_PB_CODE, digest);
+  }
+  /**
+   * Simplified version of `create` for CIDv1.
+   *
+   * @param code - Content encoding format code.
+   * @param digest - Multihash of the content.
+   */
+  static createV1(code, digest) {
+    return _CID.create(1, code, digest);
+  }
+  /**
+   * Decoded a CID from its binary representation. The byte array must contain
+   * only the CID with no additional bytes.
+   *
+   * An error will be thrown if the bytes provided do not contain a valid
+   * binary representation of a CID.
+   */
+  static decode(bytes) {
+    const [cid, remainder] = _CID.decodeFirst(bytes);
+    if (remainder.length !== 0) {
+      throw new Error("Incorrect length");
+    }
+    return cid;
+  }
+  /**
+   * Decoded a CID from its binary representation at the beginning of a byte
+   * array.
+   *
+   * Returns an array with the first element containing the CID and the second
+   * element containing the remainder of the original byte array. The remainder
+   * will be a zero-length byte array if the provided bytes only contained a
+   * binary CID representation.
+   */
+  static decodeFirst(bytes) {
+    const specs = _CID.inspectBytes(bytes);
+    const prefixSize = specs.size - specs.multihashSize;
+    const multihashBytes = coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
+    if (multihashBytes.byteLength !== specs.multihashSize) {
+      throw new Error("Incorrect length");
+    }
+    const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
+    const digest = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
+    const cid = specs.version === 0 ? _CID.createV0(digest) : _CID.createV1(specs.codec, digest);
+    return [cid, bytes.subarray(specs.size)];
+  }
+  /**
+   * Inspect the initial bytes of a CID to determine its properties.
+   *
+   * Involves decoding up to 4 varints. Typically this will require only 4 to 6
+   * bytes but for larger multicodec code values and larger multihash digest
+   * lengths these varints can be quite large. It is recommended that at least
+   * 10 bytes be made available in the `initialBytes` argument for a complete
+   * inspection.
+   */
+  static inspectBytes(initialBytes) {
+    let offset = 0;
+    const next = () => {
+      const [i, length2] = decode5(initialBytes.subarray(offset));
+      offset += length2;
+      return i;
+    };
+    let version = next();
+    let codec = DAG_PB_CODE;
+    if (version === 18) {
+      version = 0;
+      offset = 0;
+    } else {
+      codec = next();
+    }
+    if (version !== 0 && version !== 1) {
+      throw new RangeError(`Invalid CID version ${version}`);
+    }
+    const prefixSize = offset;
+    const multihashCode = next();
+    const digestSize = next();
+    const size = offset + digestSize;
+    const multihashSize = size - prefixSize;
+    return { version, codec, multihashCode, digestSize, multihashSize, size };
+  }
+  /**
+   * Takes cid in a string representation and creates an instance. If `base`
+   * decoder is not provided will use a default from the configuration. It will
+   * throw an error if encoding of the CID is not compatible with supplied (or
+   * a default decoder).
+   */
+  static parse(source, base2) {
+    const [prefix, bytes] = parseCIDtoBytes(source, base2);
+    const cid = _CID.decode(bytes);
+    if (cid.version === 0 && source[0] !== "Q") {
+      throw Error("Version 0 CID string must not include multibase prefix");
+    }
+    baseCache(cid).set(prefix, source);
+    return cid;
+  }
+};
+function parseCIDtoBytes(source, base2) {
+  switch (source[0]) {
+    // CIDv0 is parsed differently
+    case "Q": {
+      const decoder = base2 ?? base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(`${base58btc.prefix}${source}`)
+      ];
+    }
+    case base58btc.prefix: {
+      const decoder = base2 ?? base58btc;
+      return [base58btc.prefix, decoder.decode(source)];
+    }
+    case base32.prefix: {
+      const decoder = base2 ?? base32;
+      return [base32.prefix, decoder.decode(source)];
+    }
+    case base36.prefix: {
+      const decoder = base2 ?? base36;
+      return [base36.prefix, decoder.decode(source)];
+    }
+    default: {
+      if (base2 == null) {
+        throw Error("To parse non base32, base36 or base58btc encoded CID multibase decoder must be provided");
+      }
+      return [source[0], base2.decode(source)];
+    }
+  }
+}
+function toStringV0(bytes, cache2, base2) {
+  const { prefix } = base2;
+  if (prefix !== base58btc.prefix) {
+    throw Error(`Cannot string encode V0 in ${base2.name} encoding`);
+  }
+  const cid = cache2.get(prefix);
+  if (cid == null) {
+    const cid2 = base2.encode(bytes).slice(1);
+    cache2.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+}
+function toStringV1(bytes, cache2, base2) {
+  const { prefix } = base2;
+  const cid = cache2.get(prefix);
+  if (cid == null) {
+    const cid2 = base2.encode(bytes);
+    cache2.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+}
+var DAG_PB_CODE = 112;
+var SHA_256_CODE = 18;
+function encodeCID(version, code, multihash) {
+  const codeOffset = encodingLength(version);
+  const hashOffset = codeOffset + encodingLength(code);
+  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+  encodeTo(version, bytes, 0);
+  encodeTo(code, bytes, codeOffset);
+  bytes.set(multihash, hashOffset);
+  return bytes;
+}
+var cidSymbol = Symbol.for("@ipld/js-cid/CID");
+
+// ../../../node_modules/.pnpm/@ipld+dag-cbor@9.2.5/node_modules/@ipld/dag-cbor/src/index.js
+var CID_CBOR_TAG = 42;
+function toByteView(buf) {
+  if (buf instanceof ArrayBuffer) {
+    return new Uint8Array(buf, 0, buf.byteLength);
+  }
+  return buf;
+}
+function cidEncoder(obj) {
+  if (obj.asCID !== obj && obj["/"] !== obj.bytes) {
+    return null;
+  }
+  const cid = CID2.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;
+}
+function mapEncoder(map) {
+  for (const key of map.keys()) {
+    if (typeof key !== "string" || key.length === 0) {
+      throw new Error("Non-string Map keys are not supported by the IPLD Data Model and cannot be encoded");
+    }
+  }
+  return null;
+}
+var _encodeOptions = {
+  float64: true,
+  typeEncoders: {
+    Map: mapEncoder,
+    Object: cidEncoder,
+    undefined: undefinedEncoder,
+    number: numberEncoder
+  }
+};
+var encodeOptions = {
+  ..._encodeOptions,
+  typeEncoders: {
+    ..._encodeOptions.typeEncoders
+  }
+};
+function cidDecoder(bytes) {
+  if (bytes[0] !== 0) {
+    throw new Error("Invalid CID for CBOR tag 42; expected leading 0x00");
+  }
+  return CID2.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 decodeOptions = {
+  ..._decodeOptions,
+  tags: _decodeOptions.tags.slice()
+};
+var encode4 = (node) => encode(node, _encodeOptions);
+var decode7 = (data) => decode2(toByteView(data), _decodeOptions);
+
+// ../../../node_modules/.pnpm/@ipld+car@5.4.2/node_modules/@ipld/car/src/decoder-common.js
+var import_varint2 = __toESM(require_varint(), 1);
+var CIDV0_BYTES = {
+  SHA2_256: 18,
+  LENGTH: 32,
+  DAG_PB: 112
+};
+var V2_HEADER_LENGTH = (
+  /* characteristics */
+  16 + 8 + 8 + 8
+);
+function decodeVarint(bytes, seeker) {
+  if (!bytes.length) {
+    throw new Error("Unexpected end of data");
+  }
+  const i = import_varint2.default.decode(bytes);
+  seeker.seek(
+    /** @type {number} */
+    import_varint2.default.decode.bytes
+  );
+  return i;
+}
+function decodeV2Header(bytes) {
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let offset = 0;
+  const header = {
+    version: 2,
+    /** @type {[bigint, bigint]} */
+    characteristics: [
+      dv.getBigUint64(offset, true),
+      dv.getBigUint64(offset += 8, true)
+    ],
+    dataOffset: Number(dv.getBigUint64(offset += 8, true)),
+    dataSize: Number(dv.getBigUint64(offset += 8, true)),
+    indexOffset: Number(dv.getBigUint64(offset += 8, true))
+  };
+  return header;
+}
+function getMultihashLength(bytes) {
+  import_varint2.default.decode(bytes);
+  const codeLength = (
+    /** @type {number} */
+    import_varint2.default.decode.bytes
+  );
+  const length2 = import_varint2.default.decode(bytes.subarray(import_varint2.default.decode.bytes));
+  const lengthLength = (
+    /** @type {number} */
+    import_varint2.default.decode.bytes
+  );
+  const mhLength = codeLength + lengthLength + length2;
+  return mhLength;
+}
+
+// ../../../node_modules/.pnpm/@ipld+car@5.4.2/node_modules/@ipld/car/src/header-validator.js
+var Kinds = {
+  Null: (
+    /**
+     * @param obj
+     * @returns {undefined|null}
+     */
+    (obj) => obj === null ? obj : void 0
+  ),
+  Int: (
+    /**
+     * @param obj
+     * @returns {undefined|number}
+     */
+    (obj) => Number.isInteger(obj) ? obj : void 0
+  ),
+  Float: (
+    /**
+     * @param obj
+     * @returns {undefined|number}
+     */
+    (obj) => typeof obj === "number" && Number.isFinite(obj) ? obj : void 0
+  ),
+  String: (
+    /**
+     * @param obj
+     * @returns {undefined|string}
+     */
+    (obj) => typeof obj === "string" ? obj : void 0
+  ),
+  Bool: (
+    /**
+     * @param obj
+     * @returns {undefined|boolean}
+     */
+    (obj) => typeof obj === "boolean" ? obj : void 0
+  ),
+  Bytes: (
+    /**
+     * @param obj
+     * @returns {undefined|Uint8Array}
+     */
+    (obj) => obj instanceof Uint8Array ? obj : void 0
+  ),
+  Link: (
+    /**
+     * @param obj
+     * @returns {undefined|object}
+     */
+    (obj) => obj !== null && typeof obj === "object" && obj.asCID === obj ? obj : void 0
+  ),
+  List: (
+    /**
+     * @param obj
+     * @returns {undefined|Array<any>}
+     */
+    (obj) => Array.isArray(obj) ? obj : void 0
+  ),
+  Map: (
+    /**
+     * @param obj
+     * @returns {undefined|object}
+     */
+    (obj) => obj !== null && typeof obj === "object" && obj.asCID !== obj && !Array.isArray(obj) && !(obj instanceof Uint8Array) ? obj : void 0
+  )
+};
+var Types = {
+  "CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)": Kinds.Link,
+  "CarV1HeaderOrV2Pragma > roots (anon)": (
+    /**
+     * @param obj
+     * @returns {undefined|any}
+     */
+    (obj) => {
+      if (Kinds.List(obj) === void 0) {
+        return void 0;
+      }
+      for (let i = 0; i < obj.length; i++) {
+        let v = obj[i];
+        v = Types["CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)"](v);
+        if (v === void 0) {
+          return void 0;
+        }
+        if (v !== obj[i]) {
+          const ret = obj.slice(0, i);
+          for (let j = i; j < obj.length; j++) {
+            let v2 = obj[j];
+            v2 = Types["CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)"](v2);
+            if (v2 === void 0) {
+              return void 0;
+            }
+            ret.push(v2);
+          }
+          return ret;
+        }
+      }
+      return obj;
+    }
+  ),
+  Int: Kinds.Int,
+  CarV1HeaderOrV2Pragma: (
+    /**
+     * @param obj
+     * @returns {undefined|any}
+     */
+    (obj) => {
+      if (Kinds.Map(obj) === void 0) {
+        return void 0;
+      }
+      const entries = Object.entries(obj);
+      let ret = obj;
+      let requiredCount = 1;
+      for (let i = 0; i < entries.length; i++) {
+        const [key, value] = entries[i];
+        switch (key) {
+          case "roots":
+            {
+              const v = Types["CarV1HeaderOrV2Pragma > roots (anon)"](obj[key]);
+              if (v === void 0) {
+                return void 0;
+              }
+              if (v !== value || ret !== obj) {
+                if (ret === obj) {
+                  ret = {};
+                  for (let j = 0; j < i; j++) {
+                    ret[entries[j][0]] = entries[j][1];
+                  }
+                }
+                ret.roots = v;
+              }
+            }
+            break;
+          case "version":
+            {
+              requiredCount--;
+              const v = Types.Int(obj[key]);
+              if (v === void 0) {
+                return void 0;
+              }
+              if (v !== value || ret !== obj) {
+                if (ret === obj) {
+                  ret = {};
+                  for (let j = 0; j < i; j++) {
+                    ret[entries[j][0]] = entries[j][1];
+                  }
+                }
+                ret.version = v;
+              }
+            }
+            break;
+          default:
+            return void 0;
+        }
+      }
+      if (requiredCount > 0) {
+        return void 0;
+      }
+      return ret;
+    }
+  )
+};
+var Reprs = {
+  "CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)": Kinds.Link,
+  "CarV1HeaderOrV2Pragma > roots (anon)": (
+    /**
+     * @param obj
+     * @returns {undefined|any}
+     */
+    (obj) => {
+      if (Kinds.List(obj) === void 0) {
+        return void 0;
+      }
+      for (let i = 0; i < obj.length; i++) {
+        let v = obj[i];
+        v = Reprs["CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)"](v);
+        if (v === void 0) {
+          return void 0;
+        }
+        if (v !== obj[i]) {
+          const ret = obj.slice(0, i);
+          for (let j = i; j < obj.length; j++) {
+            let v2 = obj[j];
+            v2 = Reprs["CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)"](v2);
+            if (v2 === void 0) {
+              return void 0;
+            }
+            ret.push(v2);
+          }
+          return ret;
+        }
+      }
+      return obj;
+    }
+  ),
+  Int: Kinds.Int,
+  CarV1HeaderOrV2Pragma: (
+    /**
+     * @param obj
+     * @returns {undefined|any}
+     */
+    (obj) => {
+      if (Kinds.Map(obj) === void 0) {
+        return void 0;
+      }
+      const entries = Object.entries(obj);
+      let ret = obj;
+      let requiredCount = 1;
+      for (let i = 0; i < entries.length; i++) {
+        const [key, value] = entries[i];
+        switch (key) {
+          case "roots":
+            {
+              const v = Reprs["CarV1HeaderOrV2Pragma > roots (anon)"](value);
+              if (v === void 0) {
+                return void 0;
+              }
+              if (v !== value || ret !== obj) {
+                if (ret === obj) {
+                  ret = {};
+                  for (let j = 0; j < i; j++) {
+                    ret[entries[j][0]] = entries[j][1];
+                  }
+                }
+                ret.roots = v;
+              }
+            }
+            break;
+          case "version":
+            {
+              requiredCount--;
+              const v = Reprs.Int(value);
+              if (v === void 0) {
+                return void 0;
+              }
+              if (v !== value || ret !== obj) {
+                if (ret === obj) {
+                  ret = {};
+                  for (let j = 0; j < i; j++) {
+                    ret[entries[j][0]] = entries[j][1];
+                  }
+                }
+                ret.version = v;
+              }
+            }
+            break;
+          default:
+            return void 0;
+        }
+      }
+      if (requiredCount > 0) {
+        return void 0;
+      }
+      return ret;
+    }
+  )
+};
+var CarV1HeaderOrV2Pragma = {
+  toTyped: Types.CarV1HeaderOrV2Pragma,
+  toRepresentation: Reprs.CarV1HeaderOrV2Pragma
+};
+
+// ../../../node_modules/.pnpm/cborg@4.5.8/node_modules/cborg/lib/length.js
+var cborEncoders2 = makeCborEncoders();
+
+// ../../../node_modules/.pnpm/@ipld+car@5.4.2/node_modules/@ipld/car/src/buffer-writer.js
+var import_varint3 = __toESM(require_varint(), 1);
+var headerPreludeTokens = [
+  new Token(Type.map, 2),
+  new Token(Type.string, "version"),
+  new Token(Type.uint, 1),
+  new Token(Type.string, "roots")
+];
+var CID_TAG = new Token(Type.tag, 42);
+
+// ../../../node_modules/.pnpm/@ipld+car@5.4.2/node_modules/@ipld/car/src/decoder.js
+async function readHeader(reader, strictVersion) {
+  const length2 = decodeVarint(await reader.upTo(8), reader);
+  if (length2 === 0) {
+    throw new Error("Invalid CAR header (zero length)");
+  }
+  const header = await reader.exactly(length2, true);
+  const block = decode7(header);
+  if (CarV1HeaderOrV2Pragma.toTyped(block) === void 0) {
+    throw new Error("Invalid CAR header format");
+  }
+  if (block.version !== 1 && block.version !== 2 || strictVersion !== void 0 && block.version !== strictVersion) {
+    throw new Error(`Invalid CAR version: ${block.version}${strictVersion !== void 0 ? ` (expected ${strictVersion})` : ""}`);
+  }
+  if (block.version === 1) {
+    if (!Array.isArray(block.roots)) {
+      throw new Error("Invalid CAR header format");
+    }
+    return block;
+  }
+  if (block.roots !== void 0) {
+    throw new Error("Invalid CAR header format");
+  }
+  const v2Header = decodeV2Header(await reader.exactly(V2_HEADER_LENGTH, true));
+  reader.seek(v2Header.dataOffset - reader.pos);
+  const v1Header = await readHeader(reader, 1);
+  return Object.assign(v1Header, v2Header);
+}
+async function readCid(reader) {
+  const first = await reader.exactly(2, false);
+  if (first[0] === CIDV0_BYTES.SHA2_256 && first[1] === CIDV0_BYTES.LENGTH) {
+    const bytes2 = await reader.exactly(34, true);
+    const multihash2 = decode6(bytes2);
+    return CID2.create(0, CIDV0_BYTES.DAG_PB, multihash2);
+  }
+  const version = decodeVarint(await reader.upTo(8), reader);
+  if (version !== 1) {
+    throw new Error(`Unexpected CID version (${version})`);
+  }
+  const codec = decodeVarint(await reader.upTo(8), reader);
+  const bytes = await reader.exactly(getMultihashLength(await reader.upTo(8)), true);
+  const multihash = decode6(bytes);
+  return CID2.create(version, codec, multihash);
+}
+async function readBlockHead(reader) {
+  const start = reader.pos;
+  let length2 = decodeVarint(await reader.upTo(8), reader);
+  if (length2 === 0) {
+    throw new Error("Invalid CAR section (zero length)");
+  }
+  length2 += reader.pos - start;
+  const cid = await readCid(reader);
+  const blockLength = length2 - Number(reader.pos - start);
+  return { cid, length: length2, blockLength };
+}
+async function readBlock(reader) {
+  const { cid, blockLength } = await readBlockHead(reader);
+  const bytes = await reader.exactly(blockLength, true);
+  return { bytes, cid };
+}
+async function readBlockIndex(reader) {
+  const offset = reader.pos;
+  const { cid, length: length2, blockLength } = await readBlockHead(reader);
+  const index = { cid, length: length2, blockLength, offset, blockOffset: reader.pos };
+  reader.seek(index.blockLength);
+  return index;
+}
+function createDecoder(reader) {
+  const headerPromise = (async () => {
+    const header = await readHeader(reader);
+    if (header.version === 2) {
+      const v1length = reader.pos - header.dataOffset;
+      reader = limitReader(reader, header.dataSize - v1length);
+    }
+    return header;
+  })();
+  return {
+    header: () => headerPromise,
+    async *blocks() {
+      await headerPromise;
+      while ((await reader.upTo(8)).length > 0) {
+        yield await readBlock(reader);
+      }
+    },
+    async *blocksIndex() {
+      await headerPromise;
+      while ((await reader.upTo(8)).length > 0) {
+        yield await readBlockIndex(reader);
+      }
+    }
+  };
+}
+function bytesReader(bytes) {
+  let pos = 0;
+  return {
+    async upTo(length2) {
+      const out = bytes.subarray(pos, pos + Math.min(length2, bytes.length - pos));
+      return out;
+    },
+    async exactly(length2, seek = false) {
+      if (length2 > bytes.length - pos) {
+        throw new Error("Unexpected end of data");
+      }
+      const out = bytes.subarray(pos, pos + length2);
+      if (seek) {
+        pos += length2;
+      }
+      return out;
+    },
+    seek(length2) {
+      pos += length2;
+    },
+    get pos() {
+      return pos;
+    }
+  };
+}
+function chunkReader(readChunk) {
+  let pos = 0;
+  let have = 0;
+  let offset = 0;
+  let currentChunk = new Uint8Array(0);
+  const read2 = async (length2) => {
+    have = currentChunk.length - offset;
+    const bufa = (
+      /** @type {Uint8Array<ArrayBufferLike>[]} */
+      [currentChunk.subarray(offset)]
+    );
+    while (have < length2) {
+      const chunk = await readChunk();
+      if (chunk == null) {
+        break;
+      }
+      if (have < 0) {
+        if (chunk.length > have) {
+          bufa.push(chunk.subarray(-have));
+        }
+      } else {
+        bufa.push(chunk);
+      }
+      have += chunk.length;
+    }
+    currentChunk = new Uint8Array(bufa.reduce((p, c) => p + c.length, 0));
+    let off = 0;
+    for (const b of bufa) {
+      currentChunk.set(b, off);
+      off += b.length;
+    }
+    offset = 0;
+  };
+  return {
+    async upTo(length2) {
+      if (currentChunk.length - offset < length2) {
+        await read2(length2);
+      }
+      return currentChunk.subarray(offset, offset + Math.min(currentChunk.length - offset, length2));
+    },
+    async exactly(length2, seek = false) {
+      if (currentChunk.length - offset < length2) {
+        await read2(length2);
+      }
+      if (currentChunk.length - offset < length2) {
+        throw new Error("Unexpected end of data");
+      }
+      const out = currentChunk.subarray(offset, offset + length2);
+      if (seek) {
+        pos += length2;
+        offset += length2;
+      }
+      return out;
+    },
+    seek(length2) {
+      pos += length2;
+      offset += length2;
+    },
+    get pos() {
+      return pos;
+    }
+  };
+}
+function asyncIterableReader(asyncIterable) {
+  const iterator = asyncIterable[Symbol.asyncIterator]();
+  async function readChunk() {
+    const next = await iterator.next();
+    if (next.done) {
+      return null;
+    }
+    return next.value;
+  }
+  return chunkReader(readChunk);
+}
+function limitReader(reader, byteLimit) {
+  let bytesRead = 0;
+  return {
+    async upTo(length2) {
+      let bytes = await reader.upTo(length2);
+      if (bytes.length + bytesRead > byteLimit) {
+        bytes = bytes.subarray(0, byteLimit - bytesRead);
+      }
+      return bytes;
+    },
+    async exactly(length2, seek = false) {
+      const bytes = await reader.exactly(length2, seek);
+      if (bytes.length + bytesRead > byteLimit) {
+        throw new Error("Unexpected end of data");
+      }
+      if (seek) {
+        bytesRead += length2;
+      }
+      return bytes;
+    },
+    seek(length2) {
+      bytesRead += length2;
+      reader.seek(length2);
+    },
+    get pos() {
+      return reader.pos;
+    }
+  };
+}
+
+// ../../../node_modules/.pnpm/@ipld+car@5.4.2/node_modules/@ipld/car/src/reader-browser.js
+var CarReader = class {
+  /**
+   * @constructs CarReader
+   * @param {CarHeader|CarV2Header} header
+   * @param {Block[]} blocks
+   */
+  constructor(header, blocks) {
+    this._header = header;
+    this._blocks = blocks;
+    this._keys = blocks.map((b) => b.cid.toString());
+  }
+  /**
+   * @property
+   * @memberof CarReader
+   * @instance
+   */
+  get version() {
+    return this._header.version;
+  }
+  /**
+   * Get the list of roots defined by the CAR referenced by this reader. May be
+   * zero or more `CID`s.
+   *
+   * @function
+   * @memberof CarReader
+   * @instance
+   * @async
+   * @returns {Promise<CID[]>}
+   */
+  async getRoots() {
+    return this._header.roots;
+  }
+  /**
+   * Check whether a given `CID` exists within the CAR referenced by this
+   * reader.
+   *
+   * @function
+   * @memberof CarReader
+   * @instance
+   * @async
+   * @param {CID} key
+   * @returns {Promise<boolean>}
+   */
+  async has(key) {
+    return this._keys.indexOf(key.toString()) > -1;
+  }
+  /**
+   * Fetch a `Block` (a `{ cid:CID, bytes:Uint8Array }` pair) from the CAR
+   * referenced by this reader matching the provided `CID`. In the case where
+   * the provided `CID` doesn't exist within the CAR, `undefined` will be
+   * returned.
+   *
+   * @function
+   * @memberof CarReader
+   * @instance
+   * @async
+   * @param {CID} key
+   * @returns {Promise<Block | undefined>}
+   */
+  async get(key) {
+    const index = this._keys.indexOf(key.toString());
+    return index > -1 ? this._blocks[index] : void 0;
+  }
+  /**
+   * Returns a `BlockIterator` (`AsyncIterable<Block>`) that iterates over all
+   * of the `Block`s (`{ cid:CID, bytes:Uint8Array }` pairs) contained within
+   * the CAR referenced by this reader.
+   *
+   * @function
+   * @memberof CarReader
+   * @instance
+   * @async
+   * @generator
+   * @returns {AsyncGenerator<Block>}
+   */
+  async *blocks() {
+    for (const block of this._blocks) {
+      yield block;
+    }
+  }
+  /**
+   * Returns a `CIDIterator` (`AsyncIterable<CID>`) that iterates over all of
+   * the `CID`s contained within the CAR referenced by this reader.
+   *
+   * @function
+   * @memberof CarReader
+   * @instance
+   * @async
+   * @generator
+   * @returns {AsyncGenerator<CID>}
+   */
+  async *cids() {
+    for (const block of this._blocks) {
+      yield block.cid;
+    }
+  }
+  /**
+   * Instantiate a {@link CarReader} from a `Uint8Array` blob. This performs a
+   * decode fully in memory and maintains the decoded state in memory for full
+   * access to the data via the `CarReader` API.
+   *
+   * @async
+   * @static
+   * @memberof CarReader
+   * @param {Uint8Array} bytes
+   * @returns {Promise<CarReader>}
+   */
+  static async fromBytes(bytes) {
+    if (!(bytes instanceof Uint8Array)) {
+      throw new TypeError("fromBytes() requires a Uint8Array");
+    }
+    return decodeReaderComplete(bytesReader(bytes));
+  }
+  /**
+   * Instantiate a {@link CarReader} from a `AsyncIterable<Uint8Array>`, such as
+   * a [modern Node.js stream](https://nodejs.org/api/stream.html#stream_streams_compatibility_with_async_generators_and_async_iterators).
+   * This performs a decode fully in memory and maintains the decoded state in
+   * memory for full access to the data via the `CarReader` API.
+   *
+   * Care should be taken for large archives; this API may not be appropriate
+   * where memory is a concern or the archive is potentially larger than the
+   * amount of memory that the runtime can handle.
+   *
+   * @async
+   * @static
+   * @memberof CarReader
+   * @param {AsyncIterable<Uint8Array>} asyncIterable
+   * @returns {Promise<CarReader>}
+   */
+  static async fromIterable(asyncIterable) {
+    if (!asyncIterable || !(typeof asyncIterable[Symbol.asyncIterator] === "function")) {
+      throw new TypeError("fromIterable() requires an async iterable");
+    }
+    return decodeReaderComplete(asyncIterableReader(asyncIterable));
+  }
+};
+async function decodeReaderComplete(reader) {
+  const decoder = createDecoder(reader);
+  const header = await decoder.header();
+  const blocks = [];
+  for await (const block of decoder.blocks()) {
+    blocks.push(block);
+  }
+  return new CarReader(header, blocks);
+}
+
+// ../../../node_modules/.pnpm/@ipld+car@5.4.2/node_modules/@ipld/car/src/encoder.js
+var import_varint4 = __toESM(require_varint(), 1);
+var CAR_V1_VERSION = 1;
+function createHeader(roots) {
+  const headerBytes = encode4({ version: CAR_V1_VERSION, roots });
+  const varintBytes = import_varint4.default.encode(headerBytes.length);
+  const header = new Uint8Array(varintBytes.length + headerBytes.length);
+  header.set(varintBytes, 0);
+  header.set(headerBytes, varintBytes.length);
+  return header;
+}
+function createEncoder(writer) {
+  return {
+    /**
+     * @param {CID[]} roots
+     * @returns {Promise<void>}
+     */
+    async setRoots(roots) {
+      const bytes = createHeader(roots);
+      await writer.write(bytes);
+    },
+    /**
+     * @param {Block} block
+     * @returns {Promise<void>}
+     */
+    async writeBlock(block) {
+      const { cid, bytes } = block;
+      await writer.write(new Uint8Array(import_varint4.default.encode(cid.bytes.length + bytes.length)));
+      await writer.write(cid.bytes);
+      if (bytes.length) {
+        await writer.write(bytes);
+      }
+    },
+    /**
+     * @returns {Promise<void>}
+     */
+    async close() {
+      await writer.end();
+    },
+    /**
+     * @returns {number}
+     */
+    version() {
+      return CAR_V1_VERSION;
+    }
+  };
+}
+
+// ../../../node_modules/.pnpm/@ipld+car@5.4.2/node_modules/@ipld/car/src/iterator-channel.js
+function noop() {
+}
+function create2() {
+  const chunkQueue = [];
+  let drainer = null;
+  let drainerResolver = noop;
+  let ended = false;
+  let outWait = null;
+  let outWaitResolver = noop;
+  const makeDrainer = () => {
+    if (!drainer) {
+      drainer = new Promise((resolve) => {
+        drainerResolver = () => {
+          drainer = null;
+          drainerResolver = noop;
+          resolve();
+        };
+      });
+    }
+    return drainer;
+  };
+  const writer = {
+    /**
+     * @param {T} chunk
+     * @returns {Promise<void>}
+     */
+    write(chunk) {
+      chunkQueue.push(chunk);
+      const drainer2 = makeDrainer();
+      outWaitResolver();
+      return drainer2;
+    },
+    async end() {
+      ended = true;
+      const drainer2 = makeDrainer();
+      outWaitResolver();
+      await drainer2;
+    }
+  };
+  const iterator = {
+    /** @returns {Promise<IteratorResult<T>>} */
+    async next() {
+      const chunk = chunkQueue.shift();
+      if (chunk) {
+        if (chunkQueue.length === 0) {
+          drainerResolver();
+        }
+        return { done: false, value: chunk };
+      }
+      if (ended) {
+        drainerResolver();
+        return { done: true, value: void 0 };
+      }
+      if (!outWait) {
+        outWait = new Promise((resolve) => {
+          outWaitResolver = () => {
+            outWait = null;
+            outWaitResolver = noop;
+            return resolve(iterator.next());
+          };
+        });
+      }
+      return outWait;
+    }
+  };
+  return { writer, iterator };
+}
+
+// ../../../node_modules/.pnpm/@ipld+car@5.4.2/node_modules/@ipld/car/src/writer-browser.js
+var CarWriter = class _CarWriter {
+  /**
+   * @param {CID[]} roots
+   * @param {CarEncoder} encoder
+   */
+  constructor(roots, encoder) {
+    this._encoder = encoder;
+    this._mutex = encoder.setRoots(roots);
+    this._ended = false;
+  }
+  /**
+   * Write a `Block` (a `{ cid:CID, bytes:Uint8Array }` pair) to the archive.
+   *
+   * @function
+   * @memberof CarWriter
+   * @instance
+   * @async
+   * @param {Block} block - A `{ cid:CID, bytes:Uint8Array }` pair.
+   * @returns {Promise<void>} The returned promise will only resolve once the
+   * bytes this block generates are written to the `out` iterable.
+   */
+  async put(block) {
+    if (!(block.bytes instanceof Uint8Array) || !block.cid) {
+      throw new TypeError("Can only write {cid, bytes} objects");
+    }
+    if (this._ended) {
+      throw new Error("Already closed");
+    }
+    const cid = CID2.asCID(block.cid);
+    if (!cid) {
+      throw new TypeError("Can only write {cid, bytes} objects");
+    }
+    this._mutex = this._mutex.then(() => this._encoder.writeBlock({ cid, bytes: block.bytes }));
+    return this._mutex;
+  }
+  /**
+   * Finalise the CAR archive and signal that the `out` iterable should end once
+   * any remaining bytes are written.
+   *
+   * @function
+   * @memberof CarWriter
+   * @instance
+   * @async
+   * @returns {Promise<void>}
+   */
+  async close() {
+    if (this._ended) {
+      throw new Error("Already closed");
+    }
+    await this._mutex;
+    this._ended = true;
+    return this._encoder.close();
+  }
+  /**
+   * Returns the version number of the CAR file being written
+   *
+   * @returns {number}
+   */
+  version() {
+    return this._encoder.version();
+  }
+  /**
+   * Create a new CAR writer "channel" which consists of a
+   * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }` pair.
+   *
+   * @async
+   * @static
+   * @memberof CarWriter
+   * @param {CID[] | CID | void} roots
+   * @returns {WriterChannel} The channel takes the form of
+   * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }`.
+   */
+  static create(roots) {
+    roots = toRoots(roots);
+    const { encoder, iterator } = encodeWriter();
+    const writer = new _CarWriter(roots, encoder);
+    const out = new CarWriterOut(iterator);
+    return { writer, out };
+  }
+  /**
+   * Create a new CAR appender "channel" which consists of a
+   * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }` pair.
+   * This appender does not consider roots and does not produce a CAR header.
+   * It is designed to append blocks to an _existing_ CAR archive. It is
+   * expected that `out` will be concatenated onto the end of an existing
+   * archive that already has a properly formatted header.
+   *
+   * @async
+   * @static
+   * @memberof CarWriter
+   * @returns {WriterChannel} The channel takes the form of
+   * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }`.
+   */
+  static createAppender() {
+    const { encoder, iterator } = encodeWriter();
+    encoder.setRoots = () => Promise.resolve();
+    const writer = new _CarWriter([], encoder);
+    const out = new CarWriterOut(iterator);
+    return { writer, out };
+  }
+  /**
+   * Update the list of roots in the header of an existing CAR as represented
+   * in a Uint8Array.
+   *
+   * This operation is an _overwrite_, the total length of the CAR will not be
+   * modified. A rejection will occur if the new header will not be the same
+   * length as the existing header, in which case the CAR will not be modified.
+   * It is the responsibility of the user to ensure that the roots being
+   * replaced encode as the same length as the new roots.
+   *
+   * The byte array passed in an argument will be modified and also returned
+   * upon successful modification.
+   *
+   * @async
+   * @static
+   * @memberof CarWriter
+   * @param {Uint8Array} bytes
+   * @param {CID[]} roots - A new list of roots to replace the existing list in
+   * the CAR header. The new header must take up the same number of bytes as the
+   * existing header, so the roots should collectively be the same byte length
+   * as the existing roots.
+   * @returns {Promise<Uint8Array>}
+   */
+  static async updateRootsInBytes(bytes, roots) {
+    const reader = bytesReader(bytes);
+    await readHeader(reader);
+    const newHeader = createHeader(roots);
+    if (Number(reader.pos) !== newHeader.length) {
+      throw new Error(`updateRoots() can only overwrite a header of the same length (old header is ${reader.pos} bytes, new header is ${newHeader.length} bytes)`);
+    }
+    bytes.set(newHeader, 0);
+    return bytes;
+  }
+};
+var CarWriterOut = class {
+  /**
+   * @param {AsyncIterator<Uint8Array>} iterator
+   */
+  constructor(iterator) {
+    this._iterator = iterator;
+  }
+  [Symbol.asyncIterator]() {
+    if (this._iterating) {
+      throw new Error("Multiple iterator not supported");
+    }
+    this._iterating = true;
+    return this._iterator;
+  }
+};
+function encodeWriter() {
+  const iw = create2();
+  const { writer, iterator } = iw;
+  const encoder = createEncoder(writer);
+  return { encoder, iterator };
+}
+function toRoots(roots) {
+  if (roots === void 0) {
+    return [];
+  }
+  if (!Array.isArray(roots)) {
+    const cid = CID2.asCID(roots);
+    if (!cid) {
+      throw new TypeError("roots must be a single CID or an array of CIDs");
+    }
+    return [cid];
+  }
+  const _roots = [];
+  for (const root of roots) {
+    const _root = CID2.asCID(root);
+    if (!_root) {
+      throw new TypeError("roots must be a single CID or an array of CIDs");
+    }
+    _roots.push(_root);
+  }
+  return _roots;
+}
+
+// src/ipfs/car.ts
+var { WARN, LOG, DEBUG, VERBOSE, ERROR } = g.setup(g.INFO);
+async function decodePubFromCar(car) {
+  const decoded = await getBlocksOfCar(car);
+  return await decodePubFromBlocks(decoded);
+}
+async function decodePubFromBlocks({ rootCID, blockStore }, _recursionTrace = [], stopAtCID) {
+  if (!rootCID || !blockStore) {
+    throw ERROR("Empty roots/blocks", { rootCID, blockStore });
+  }
+  let allApplogs = [];
+  let firstInfo = null;
+  let currentCID = rootCID;
+  const visited = /* @__PURE__ */ new Set();
+  let applogsCID = null;
+  while (currentCID) {
+    const cidStr = currentCID.toString();
+    if (visited.has(cidStr)) {
+      throw ERROR("[decodePubFromBlocks] pub chain has a loop", {
+        currentCID: cidStr,
+        visited: [...visited]
+      });
+    }
+    visited.add(cidStr);
+    const root = await getDecodedBlock(blockStore, currentCID);
+    VERBOSE(`[decodePubFromBlocks] root:`, cidStr, root, { blockStore });
+    if (!root) {
+      throw ERROR("[decodePubFromBlocks] root not found in blockStore", { blockStore, currentCID: cidStr });
+    }
+    let pubLogsArray;
+    if (root?.info) {
+      if (!applogsCID) applogsCID = root.applogs;
+      const applogsBlock = await getDecodedBlock(blockStore, root.applogs);
+      pubLogsArray = await unchunkApplogsBlock(applogsBlock, blockStore);
+      if (!firstInfo) {
+        firstInfo = await getDecodedBlock(blockStore, root.info);
+        DEBUG(`new format - infoLogs`, firstInfo.logs.map((l) => ({ [l.toString()]: l })));
+      }
+    } else {
+      pubLogsArray = root.applogs;
+    }
+    const resolveLogFromCidLink = async (cidOrLink) => {
+      const cid = cidOrLink;
+      const applog = await getDecodedBlock(blockStore, cid);
+      if (!applog) {
+        ERROR(`Could not find applog CID in pub blocks:`, cid.toString(), { cid, root, blockStore });
+        throw new Error(`Could not find applog CID in pub blocks: ${cid.toString()}`);
+      }
+      if (applog.pv instanceof CID) applog.pv = applog.pv.toV1().toString();
+      return {
+        ...applog,
+        cid: cid.toV1().toString()
+      };
+    };
+    const snapshotApplogs = await Promise.all(pubLogsArray.map(resolveLogFromCidLink));
+    allApplogs = allApplogs.concat(snapshotApplogs);
+    if (!root.prev) {
+      break;
+    }
+    if (stopAtCID && areCidsEqual(root.prev, stopAtCID)) {
+      DEBUG("[decodePubFromBlocks] stopping at stopAtCID:", stopAtCID.toString());
+      break;
+    }
+    const prevBytes = await blockStore.get(root.prev);
+    if (!prevBytes) {
+      throw ERROR("[decodePubFromBlocks] prev snapshot missing from blockStore", {
+        currentCID: cidStr,
+        prev: root.prev.toString(),
+        stopAtCID: stopAtCID?.toString(),
+        visited: [...visited]
+      });
+    }
+    currentCID = root.prev;
+  }
+  const result = {
+    cid: rootCID,
+    info: firstInfo ? {
+      ...firstInfo,
+      logs: await Promise.all(firstInfo.logs.map(async (cidOrLink) => {
+        const cid = cidOrLink;
+        const applog = await getDecodedBlock(blockStore, cid);
+        if (!applog) {
+          ERROR(`Could not find info log CID in pub blocks:`, cid.toString(), { cid, blockStore });
+          throw new Error(`Could not find info log CID in pub blocks: ${cid.toString()}`);
+        }
+        if (applog.pv instanceof CID) applog.pv = applog.pv.toV1().toString();
+        return {
+          ...applog,
+          cid: cid.toV1().toString()
+        };
+      }))
+    } : null,
+    applogsCID,
+    applogs: allApplogs
+  };
+  DEBUG("[decodePubFromBlocks] result:", result, { rootCID: rootCID.toString(), blockStore, applogs: allApplogs });
+  return result;
+}
+async function getBlocksOfCar(car) {
+  const rootsFromCar = await car.getRoots();
+  const roots = rootsFromCar.map((c) => (typeof c.toV1 === "function" ? c : CID.decode(c.bytes)).toV1().toString());
+  const blocks = /* @__PURE__ */ new Map();
+  for await (const { cid: cidFromCarblocks, bytes } of car.blocks()) {
+    const cid = typeof cidFromCarblocks.toV1 === "function" ? cidFromCarblocks : CID.decode(cidFromCarblocks.bytes);
+    VERBOSE({ cidFromCarblocks, cid });
+    blocks.set(cid.toV1().toString(), bytes);
+  }
+  if (roots.length !== 1) {
+    WARN("Unexpected roots count:", roots);
+  }
+  return {
+    rootCID: CID.parse(roots[0]),
+    blockStore: {
+      get: (cid) => blocks.get(cid.toV1().toString())
+    }
+  };
+}
+async function getDecodedBlock(blockStore, cid) {
+  try {
+    var blob = await blockStore.get(cid);
+    if (!blob) {
+      WARN("returning null");
+      return null;
+    }
+  } catch (err) {
+    if (err.message === "Not Found") return null;
+    throw err;
+  }
+  return decode(blob);
+}
+async function makeCarOut(roots, blocks) {
+  const { writer, out } = CarWriter.create(Array.isArray(roots) ? roots : [roots]);
+  VERBOSE(`Writing ${blocks.length} blocks to CAR`, { roots, blocks });
+  blocks.forEach((b) => writer.put(b));
+  writer.close();
+  return out;
+}
+async function makeCarBlob(roots, blocks) {
+  const carOut = await makeCarOut(roots, blocks);
+  const chunks = [];
+  for await (const chunk of carOut) {
+    chunks.push(chunk);
+  }
+  const blob = new Blob(chunks);
+  return blob;
+}
+async function carFromBlob(blob) {
+  return CarReader.fromBytes(new Uint8Array(await blob.arrayBuffer()));
+}
+function streamReaderToIterable(bodyReader) {
+  return (async function* () {
+    while (true) {
+      const { done, value } = await bodyReader.read();
+      VERBOSE(`[car] chunk`, { done, value });
+      if (done) {
+        break;
+      }
+      yield value;
+    }
+  })();
+}
+
+// src/pubsub/snap-push.ts
+var { WARN: WARN2, LOG: LOG2, DEBUG: DEBUG2, VERBOSE: VERBOSE2, ERROR: ERROR2 } = g.setup(g.INFO);
+async function prepareSnapshotForPush(agent, appThread, threadToPublish, share, prevSnapCID) {
+  let logsToPublish = getLogsFromThread(threadToPublish);
+  DEBUG2(`[preparePubForPush] Collected ${logsToPublish.length} logs :`, {
+    logsToPublish,
+    threadOrLogsCount: threadToPublish.nameAndSizeUntracked || `[${threadToPublish.length}]`
+  });
+  const { sharedAgents, sharedKeyMap, sharedKey, pubCounter } = share ?? {};
+  const getExistingOrNewLog = (thread, share2, ag, at, vl) => {
+    let logInQuestion = rollingFilter(lastWriteWins(thread), { en: share2.id, at }).latestLog;
+    if (!logInQuestion && vl !== void 0) {
+      logInQuestion = ensureTsPvAndFinalizeApplog({ ag, en: share2.id, at, vl }, thread);
+    }
+    return logInQuestion;
+  };
+  const shareNameLog = getExistingOrNewLog(appThread, share, agent.ag, "share/name", share.name);
+  const shareCounterLog = getExistingOrNewLog(appThread, share, agent.ag, "share/counter", `${agent.did}<::>${pubCounter}`);
+  const encryptApplog = async (applog, keyToUse) => {
+    const { log: eachLog, cid } = prepareForPub(applog);
+    const enc = new TextEncoder();
+    const stringified = wrapper_default(eachLog);
+    const stringifiedEncodedAppLogPayload = enc.encode(stringified);
+    VERBOSE2("[odd]", { eachLog, stringified, stringifiedEncodedAppLogPayload });
+    try {
+      const encPayload = await agent.crypto?.aes.encrypt(stringifiedEncodedAppLogPayload, keyToUse, "AES-GCM");
+      VERBOSE2("[odd] encrypted length:", stringifiedEncodedAppLogPayload.length, { encPayload });
+      return encPayload;
+    } catch (err) {
+      throw ERROR2("FAILED TO ENC payload length:", stringifiedEncodedAppLogPayload.length, { err });
+    }
+  };
+  let maybeEncryptedApplogs;
+  const encryptedApplogs = [];
+  const agentSharedKeyLogs = [];
+  if (sharedAgents) {
+    if (!sharedKey || !sharedKeyMap) {
+      throw ERROR2("sharedAgents but no Keys/Map", { sharedAgents, sharedKeyMap, sharedKey });
+    }
+    VERBOSE2("encrypting", { sharedAgents, sharedKeyMap });
+    for (const [eachAgent, eachEncKey] of Array.from(sharedKeyMap.entries())) {
+      VERBOSE2("adding key", { eachAgent, eachEncKey });
+      agentSharedKeyLogs.push({
+        ag: agent.ag,
+        en: eachAgent,
+        at: "share/sharedKey",
+        vl: eachEncKey
+        // these are encrypted with the derived key from the local agent private and remote agent public keys
+      });
+    }
+    const CIDlist = [];
+    const pubCIDmap = {};
+    for (const eachLog of logsToPublish) {
+      VERBOSE2("[crypto] encrypting ", { eachLog, sharedKey });
+      const encPayload = await encryptApplog(eachLog, sharedKey);
+      DEBUG2("[crypto] encrypted ", { eachLog, encPayload, sharedKey });
+      encryptedApplogs.push({ enc: encPayload });
+    }
+    maybeEncryptedApplogs = encryptedApplogs;
+  } else {
+    maybeEncryptedApplogs = logsToPublish;
+  }
+  DEBUG2("adding all agent info and shareAtoms", {
+    share,
+    agent,
+    logsToPublish,
+    // threadToPublish, - very verbose
+    agentSharedKeyLogs
+  });
+  const infoLogs = [
+    ...rollingFilter(lastWriteWins(appThread), {
+      // TODO: use static filter for performance
+      en: agent.ag,
+      at: ["agent/ecdh", "agent/jwkd", "agent/appAgent"]
+    }).applogs,
+    ...shareNameLog ? [shareNameLog] : [],
+    ...shareCounterLog ? [shareCounterLog] : [],
+    ...agentSharedKeyLogs
+  ];
+  DEBUG2(`[prepareSnapshotForPush] info logs:`, infoLogs);
+  if (!infoLogs.find(({ at }) => at === "agent/appAgent")) throw ERROR2(`[prepareSnapshotForPush] appThread missing agent/appAgent log`);
+  const applogsToEncode = keepTruthy(maybeEncryptedApplogs);
+  const infologsToEncode = keepTruthy(infoLogs);
+  if (!applogsToEncode.length) {
+    throw ERROR2("no valid applogs", { agent, maybeEncryptedApplogs, infoLogs, applogsToEncode, infologsToEncode, prevSnapCID });
+  }
+  if (!infologsToEncode.length) {
+    throw ERROR2("no valid infologs", { agent, maybeEncryptedApplogs, infoLogs, applogsToEncode, infologsToEncode, prevSnapCID });
+  }
+  const encodedSnapshot = await encodeSnapshotAsCar(agent, applogsToEncode, infologsToEncode, prevSnapCID);
+  DEBUG2("inPrepareSnapshotForPush", { encodedSnapshot });
+  return encodedSnapshot;
+}
+async function encodeSnapshotAsCar(agent, applogs, infoLogs, prevSnapCID) {
+  DEBUG2(`[encodeSnapshotAsCar] encoding`, { agent, applogs, infoLogs });
+  const { cids: infoLogCids, encodedApplogs: encodedInfoLogs } = await encodeApplogsAsIPLD(infoLogs);
+  const { cids: applogCids, encodedApplogs } = await encodeApplogsAsIPLD(applogs);
+  let blocks = encodedApplogs.concat(encodedInfoLogs);
+  const infoLogsWrap = await encodeBlockOriginal({ logs: infoLogCids });
+  blocks.push(infoLogsWrap);
+  const { rootCID: chunkRootCID, blocks: chunkBlocks } = await chunkApplogs(applogCids);
+  blocks = blocks.concat(chunkBlocks);
+  const infoSignature = await agent.sign(infoLogsWrap.cid.bytes);
+  const applogsSignature = await agent.sign(chunkRootCID.bytes);
+  const root = {
+    info: infoLogsWrap.cid,
+    applogs: chunkRootCID,
+    infoSignature,
+    applogsSignature,
+    prev: prevSnapCID
+  };
+  DEBUG2("[encodeSnapshotAsCar] encoding root", { root, logCids: applogCids, infoLogCids });
+  const encodedRoot = await encodeBlockOriginal(root);
+  blocks.push(encodedRoot);
+  DEBUG2("[encodeSnapshotAsCar] => root", { encodedRoot });
+  return {
+    cid: encodedRoot.cid,
+    blob: await makeCarBlob(encodedRoot.cid, blocks),
+    // TODO: create CarBuilder (incl .encodeAndAdd({...}))
+    blocks,
+    infoLogCids,
+    applogCids
+  };
+}
+async function chunkApplogs(applogCids, size = 1e4) {
+  if (!applogCids.length) throw ERROR2(`[chunkApplogs] called with empty array`);
+  const chunks = [];
+  for (let i = 0; i < applogCids.length; i += size) {
+    const chunk = await encodeBlockOriginal({ logs: applogCids.slice(i, Math.min(i + applogCids.length, i + size)) });
+    chunks.push(chunk);
+  }
+  if (chunks.length === 1) return { rootCID: chunks[0].cid, blocks: chunks };
+  const root = await encodeBlockOriginal({ chunks: chunks.map((chunk) => chunk.cid) });
+  const blocks = [root, ...chunks];
+  DEBUG2(`[chunkApplogs] ${applogCids.length} logs chunked into ${chunks.length}`, { applogCids, root, blocks, chunks, dagJson: src_exports });
+  return { rootCID: root.cid, blocks, chunks };
+}
+async function unchunkApplogsBlock(block, blockStore) {
+  if (isSnapBlockChunks(block)) {
+    return (await Promise.all(
+      block.chunks.map(async (chunkCid) => {
+        const block2 = await getDecodedBlock(blockStore, chunkCid);
+        if (!block2.logs) throw ERROR2(`Weird chunk`, block2);
+        return block2.logs;
+      })
+    )).flat();
+  } else {
+    return block.logs;
+  }
+}
+function isSnapBlockChunks(block) {
+  return block.chunks;
+}
+async function encodeSnapshotApplogsAsCar(applogs) {
+  const encoded = await encodeApplogsAsIPLD(applogs);
+  if (!encoded) throw ERROR2("invalid applogs cannot continue", { applogs, encoded });
+  const { cids, encodedApplogs } = encoded;
+  const root = { applogs: cids };
+  const encodedRoot = await encodeBlockOriginal(root);
+  DEBUG2("[encodeSnapshotApplogsAsCar] encoded root", { cids, encodedRoot });
+  return await makeCarBlob(encodedRoot.cid, [encodedRoot, ...encodedApplogs]);
+}
+async function encodeApplogsAsIPLD(applogs) {
+  DEBUG2({ applogs });
+  const validApplogs = applogs.filter((eachLog) => !!eachLog);
+  DEBUG2({ validApplogs });
+  if (!validApplogs.length) throw ERROR2("no valid applogs");
+  const preppedLogs = validApplogs.map((log) => prepareForPub(log).log);
+  const encodedApplogs = await Promise.all(preppedLogs.map(encodeBlockOriginal));
+  DEBUG2("[encodeApplogsAsIpld] encoded applogs", { preppedLogs, encodedApplogs });
+  const cids = encodedApplogs.map((b) => {
+    if (!b.cid) throw ERROR2(`[publish] no cid for encoded log:`, b);
+    return b.cid;
+  });
+  return { cids, encodedApplogs };
+}
+
+export {
+  prepareSnapshotForPush,
+  encodeSnapshotAsCar,
+  chunkApplogs,
+  unchunkApplogsBlock,
+  isSnapBlockChunks,
+  encodeSnapshotApplogsAsCar,
+  decodePubFromCar,
+  decodePubFromBlocks,
+  getBlocksOfCar,
+  getDecodedBlock,
+  makeCarOut,
+  makeCarBlob,
+  carFromBlob,
+  streamReaderToIterable
+};
+//# sourceMappingURL=chunk-SIIQEX77.min.js.map