@wovin/core 0.0.4 → 0.0.6

package/dist/chunk-WOD425XV.min.js

@@ -1,4401 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
-};
-var __copyProps = (to, from3, except, desc) => {
-  if (from3 && typeof from3 === "object" || typeof from3 === "function") {
-    for (let key of __getOwnPropNames(from3))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from3[key], enumerable: !(desc = __getOwnPropDesc(from3, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// ../../../node_modules/.pnpm/@ipld+dag-json@10.1.5/node_modules/@ipld/dag-json/src/index.js
-var src_exports = {};
-__export(src_exports, {
-  code: () => code,
-  decode: () => decode7,
-  encode: () => encode5,
-  format: () => format2,
-  name: () => name,
-  parse: () => parse,
-  stringify: () => format2
-});
-
-// ../../../node_modules/.pnpm/cborg@4.0.3/node_modules/cborg/lib/is.js
-var typeofs = [
-  "string",
-  "number",
-  "bigint",
-  "symbol"
-];
-var objectTypeNames = [
-  "Function",
-  "Generator",
-  "AsyncGenerator",
-  "GeneratorFunction",
-  "AsyncGeneratorFunction",
-  "AsyncFunction",
-  "Observable",
-  "Array",
-  "Buffer",
-  "Object",
-  "RegExp",
-  "Date",
-  "Error",
-  "Map",
-  "Set",
-  "WeakMap",
-  "WeakSet",
-  "ArrayBuffer",
-  "SharedArrayBuffer",
-  "DataView",
-  "Promise",
-  "URL",
-  "HTMLElement",
-  "Int8Array",
-  "Uint8Array",
-  "Uint8ClampedArray",
-  "Int16Array",
-  "Uint16Array",
-  "Int32Array",
-  "Uint32Array",
-  "Float32Array",
-  "Float64Array",
-  "BigInt64Array",
-  "BigUint64Array"
-];
-function is(value) {
-  if (value === null) {
-    return "null";
-  }
-  if (value === void 0) {
-    return "undefined";
-  }
-  if (value === true || value === false) {
-    return "boolean";
-  }
-  const typeOf = typeof value;
-  if (typeofs.includes(typeOf)) {
-    return typeOf;
-  }
-  if (typeOf === "function") {
-    return "Function";
-  }
-  if (Array.isArray(value)) {
-    return "Array";
-  }
-  if (isBuffer(value)) {
-    return "Buffer";
-  }
-  const objectType = getObjectType(value);
-  if (objectType) {
-    return objectType;
-  }
-  return "Object";
-}
-function isBuffer(value) {
-  return value && value.constructor && value.constructor.isBuffer && value.constructor.isBuffer.call(null, value);
-}
-function getObjectType(value) {
-  const objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
-  if (objectTypeNames.includes(objectTypeName)) {
-    return objectTypeName;
-  }
-  return void 0;
-}
-
-// ../../../node_modules/.pnpm/cborg@4.0.3/node_modules/cborg/lib/token.js
-var Type = class {
-  /**
-   * @param {number} major
-   * @param {string} name
-   * @param {boolean} terminal
-   */
-  constructor(major, name2, terminal) {
-    this.major = major;
-    this.majorEncoded = major << 5;
-    this.name = name2;
-    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;
-  }
-};
-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.0.3/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 textDecoder = new TextDecoder();
-var textEncoder = new TextEncoder();
-function isBuffer2(buf2) {
-  return useBuffer && globalThis.Buffer.isBuffer(buf2);
-}
-function asU8A(buf2) {
-  if (!(buf2 instanceof Uint8Array)) {
-    return Uint8Array.from(buf2);
-  }
-  return isBuffer2(buf2) ? new Uint8Array(buf2.buffer, buf2.byteOffset, buf2.byteLength) : buf2;
-}
-var toString = useBuffer ? (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {Uint8Array} bytes
-   * @param {number} start
-   * @param {number} end
-   */
-  (bytes2, start, end) => {
-    return end - start > 64 ? (
-      // eslint-disable-line operator-linebreak
-      // @ts-ignore
-      globalThis.Buffer.from(bytes2.subarray(start, end)).toString("utf8")
-    ) : utf8Slice(bytes2, start, end);
-  }
-) : (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {Uint8Array} bytes
-   * @param {number} start
-   * @param {number} end
-   */
-  (bytes2, start, end) => {
-    return end - start > 64 ? textDecoder.decode(bytes2.subarray(start, end)) : utf8Slice(bytes2, start, end);
-  }
-);
-var fromString = useBuffer ? (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {string} string
-   */
-  (string) => {
-    return string.length > 64 ? (
-      // 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 > 64 ? 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
-   */
-  (bytes2, start, end) => {
-    if (isBuffer2(bytes2)) {
-      return new Uint8Array(bytes2.subarray(start, end));
-    }
-    return bytes2.slice(start, end);
-  }
-) : (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {Uint8Array} bytes
-   * @param {number} start
-   * @param {number} end
-   */
-  (bytes2, start, end) => {
-    return bytes2.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 (isBuffer2(b1) && isBuffer2(b2)) {
-    return b1.compare(b2);
-  }
-  for (let i = 0; i < b1.length; i++) {
-    if (b1[i] === b2[i]) {
-      continue;
-    }
-    return b1[i] < b2[i] ? -1 : 1;
-  }
-  return 0;
-}
-function utf8ToBytes(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 {
-      out[p++] = c >> 12 | 224;
-      out[p++] = c >> 6 & 63 | 128;
-      out[p++] = c & 63 | 128;
-    }
-  }
-  return out;
-}
-function utf8Slice(buf2, offset, end) {
-  const res = [];
-  while (offset < end) {
-    const firstByte = buf2[offset];
-    let codePoint = null;
-    let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
-    if (offset + bytesPerSequence <= end) {
-      let secondByte, thirdByte, fourthByte, tempCodePoint;
-      switch (bytesPerSequence) {
-        case 1:
-          if (firstByte < 128) {
-            codePoint = firstByte;
-          }
-          break;
-        case 2:
-          secondByte = buf2[offset + 1];
-          if ((secondByte & 192) === 128) {
-            tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
-            if (tempCodePoint > 127) {
-              codePoint = tempCodePoint;
-            }
-          }
-          break;
-        case 3:
-          secondByte = buf2[offset + 1];
-          thirdByte = buf2[offset + 2];
-          if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
-            tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
-            if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
-              codePoint = tempCodePoint;
-            }
-          }
-          break;
-        case 4:
-          secondByte = buf2[offset + 1];
-          thirdByte = buf2[offset + 2];
-          fourthByte = buf2[offset + 3];
-          if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
-            tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
-            if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
-              codePoint = tempCodePoint;
-            }
-          }
-      }
-    }
-    if (codePoint === null) {
-      codePoint = 65533;
-      bytesPerSequence = 1;
-    } else if (codePoint > 65535) {
-      codePoint -= 65536;
-      res.push(codePoint >>> 10 & 1023 | 55296);
-      codePoint = 56320 | codePoint & 1023;
-    }
-    res.push(codePoint);
-    offset += bytesPerSequence;
-  }
-  return decodeCodePointsArray(res);
-}
-var MAX_ARGUMENTS_LENGTH = 4096;
-function decodeCodePointsArray(codePoints) {
-  const len = codePoints.length;
-  if (len <= MAX_ARGUMENTS_LENGTH) {
-    return String.fromCharCode.apply(String, codePoints);
-  }
-  let res = "";
-  let i = 0;
-  while (i < len) {
-    res += String.fromCharCode.apply(
-      String,
-      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
-    );
-  }
-  return res;
-}
-
-// ../../../node_modules/.pnpm/cborg@4.0.3/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(bytes2) {
-    let topChunk = this.chunks[this.chunks.length - 1];
-    const newMax = this.cursor + bytes2.length;
-    if (newMax <= this.maxCursor + 1) {
-      const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
-      topChunk.set(bytes2, 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 (bytes2.length < 64 && bytes2.length < this.chunkSize) {
-        topChunk = alloc(this.chunkSize);
-        this.chunks.push(topChunk);
-        this.maxCursor += topChunk.length;
-        if (this._initReuseChunk === null) {
-          this._initReuseChunk = topChunk;
-        }
-        topChunk.set(bytes2, 0);
-      } else {
-        this.chunks.push(bytes2);
-        this.maxCursor += bytes2.length;
-      }
-    }
-    this.cursor += bytes2.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;
-  }
-};
-
-// ../../../node_modules/.pnpm/cborg@4.0.3/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.0.3/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(buf2, token) {
-  return encodeUintValue(buf2, 0, token.value);
-}
-function encodeUintValue(buf2, major, uint) {
-  if (uint < uintBoundaries[0]) {
-    const nuint = Number(uint);
-    buf2.push([major | nuint]);
-  } else if (uint < uintBoundaries[1]) {
-    const nuint = Number(uint);
-    buf2.push([major | 24, nuint]);
-  } else if (uint < uintBoundaries[2]) {
-    const nuint = Number(uint);
-    buf2.push([major | 25, nuint >>> 8, nuint & 255]);
-  } else if (uint < uintBoundaries[3]) {
-    const nuint = Number(uint);
-    buf2.push([major | 26, nuint >>> 24 & 255, nuint >>> 16 & 255, nuint >>> 8 & 255, nuint & 255]);
-  } else {
-    const buint = BigInt(uint);
-    if (buint < uintBoundaries[4]) {
-      const set = [major | 27, 0, 0, 0, 0, 0, 0, 0];
-      let lo = Number(buint & BigInt(4294967295));
-      let hi = Number(buint >> BigInt(32) & BigInt(4294967295));
-      set[8] = lo & 255;
-      lo = lo >> 8;
-      set[7] = lo & 255;
-      lo = lo >> 8;
-      set[6] = lo & 255;
-      lo = lo >> 8;
-      set[5] = lo & 255;
-      set[4] = hi & 255;
-      hi = hi >> 8;
-      set[3] = hi & 255;
-      hi = hi >> 8;
-      set[2] = hi & 255;
-      hi = hi >> 8;
-      set[1] = hi & 255;
-      buf2.push(set);
-    } else {
-      throw new Error(`${decodeErrPrefix} encountered BigInt larger than allowable range`);
-    }
-  }
-}
-encodeUint.encodedSize = function encodedSize(token) {
-  return encodeUintValue.encodedSize(token.value);
-};
-encodeUintValue.encodedSize = function encodedSize2(uint) {
-  if (uint < uintBoundaries[0]) {
-    return 1;
-  }
-  if (uint < uintBoundaries[1]) {
-    return 2;
-  }
-  if (uint < uintBoundaries[2]) {
-    return 3;
-  }
-  if (uint < uintBoundaries[3]) {
-    return 5;
-  }
-  return 9;
-};
-encodeUint.compareTokens = function compareTokens(tok1, tok2) {
-  return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : (
-    /* c8 ignore next */
-    0
-  );
-};
-
-// ../../../node_modules/.pnpm/cborg@4.0.3/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(buf2, token) {
-  const negint = token.value;
-  const unsigned = typeof negint === "bigint" ? negint * neg1b - pos1b : negint * -1 - 1;
-  encodeUintValue(buf2, token.type.majorEncoded, unsigned);
-}
-encodeNegint.encodedSize = function encodedSize3(token) {
-  const negint = token.value;
-  const unsigned = typeof negint === "bigint" ? negint * neg1b - pos1b : negint * -1 - 1;
-  if (unsigned < uintBoundaries[0]) {
-    return 1;
-  }
-  if (unsigned < uintBoundaries[1]) {
-    return 2;
-  }
-  if (unsigned < uintBoundaries[2]) {
-    return 3;
-  }
-  if (unsigned < uintBoundaries[3]) {
-    return 5;
-  }
-  return 9;
-};
-encodeNegint.compareTokens = function compareTokens2(tok1, tok2) {
-  return tok1.value < tok2.value ? 1 : tok1.value > tok2.value ? -1 : (
-    /* c8 ignore next */
-    0
-  );
-};
-
-// ../../../node_modules/.pnpm/cborg@4.0.3/node_modules/cborg/lib/2bytes.js
-function toToken(data, pos, prefix, length2) {
-  assertEnoughData(data, pos, prefix + length2);
-  const buf2 = slice(data, pos + prefix, pos + prefix + length2);
-  return new Token(Type.bytes, buf2, prefix + length2);
-}
-function decodeBytesCompact(data, pos, minor, _options) {
-  return toToken(data, pos, 1, minor);
-}
-function decodeBytes8(data, pos, _minor, options) {
-  return toToken(data, pos, 2, readUint8(data, pos + 1, options));
-}
-function decodeBytes16(data, pos, _minor, options) {
-  return toToken(data, pos, 3, readUint16(data, pos + 1, options));
-}
-function decodeBytes32(data, pos, _minor, options) {
-  return toToken(data, pos, 5, readUint32(data, pos + 1, options));
-}
-function decodeBytes64(data, pos, _minor, options) {
-  const l = readUint64(data, pos + 1, options);
-  if (typeof l === "bigint") {
-    throw new Error(`${decodeErrPrefix} 64-bit integer bytes lengths not supported`);
-  }
-  return toToken(data, pos, 9, l);
-}
-function tokenBytes(token) {
-  if (token.encodedBytes === void 0) {
-    token.encodedBytes = token.type === Type.string ? fromString(token.value) : token.value;
-  }
-  return token.encodedBytes;
-}
-function encodeBytes(buf2, token) {
-  const bytes2 = tokenBytes(token);
-  encodeUintValue(buf2, token.type.majorEncoded, bytes2.length);
-  buf2.push(bytes2);
-}
-encodeBytes.encodedSize = function encodedSize4(token) {
-  const bytes2 = tokenBytes(token);
-  return encodeUintValue.encodedSize(bytes2.length) + bytes2.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.0.3/node_modules/cborg/lib/3string.js
-function toToken2(data, pos, prefix, length2, options) {
-  const totLength = prefix + length2;
-  assertEnoughData(data, pos, totLength);
-  const tok = new Token(Type.string, toString(data, pos + prefix, pos + totLength), totLength);
-  if (options.retainStringBytes === true) {
-    tok.byteValue = slice(data, pos + prefix, pos + totLength);
-  }
-  return tok;
-}
-function decodeStringCompact(data, pos, minor, options) {
-  return toToken2(data, pos, 1, minor, options);
-}
-function decodeString8(data, pos, _minor, options) {
-  return toToken2(data, pos, 2, readUint8(data, pos + 1, options), options);
-}
-function decodeString16(data, pos, _minor, options) {
-  return toToken2(data, pos, 3, readUint16(data, pos + 1, options), options);
-}
-function decodeString32(data, pos, _minor, options) {
-  return toToken2(data, pos, 5, readUint32(data, pos + 1, options), options);
-}
-function decodeString64(data, pos, _minor, options) {
-  const l = readUint64(data, pos + 1, options);
-  if (typeof l === "bigint") {
-    throw new Error(`${decodeErrPrefix} 64-bit integer string lengths not supported`);
-  }
-  return toToken2(data, pos, 9, l, options);
-}
-var encodeString = encodeBytes;
-
-// ../../../node_modules/.pnpm/cborg@4.0.3/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(buf2, token) {
-  encodeUintValue(buf2, Type.array.majorEncoded, token.value);
-}
-encodeArray.compareTokens = encodeUint.compareTokens;
-encodeArray.encodedSize = function encodedSize5(token) {
-  return encodeUintValue.encodedSize(token.value);
-};
-
-// ../../../node_modules/.pnpm/cborg@4.0.3/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(buf2, token) {
-  encodeUintValue(buf2, Type.map.majorEncoded, token.value);
-}
-encodeMap.compareTokens = encodeUint.compareTokens;
-encodeMap.encodedSize = function encodedSize6(token) {
-  return encodeUintValue.encodedSize(token.value);
-};
-
-// ../../../node_modules/.pnpm/cborg@4.0.3/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(buf2, token) {
-  encodeUintValue(buf2, Type.tag.majorEncoded, token.value);
-}
-encodeTag.compareTokens = encodeUint.compareTokens;
-encodeTag.encodedSize = function encodedSize7(token) {
-  return encodeUintValue.encodedSize(token.value);
-};
-
-// ../../../node_modules/.pnpm/cborg@4.0.3/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, bytes2, 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, bytes2);
-}
-function decodeFloat16(data, pos, _minor, options) {
-  return createToken(readFloat16(data, pos + 1), 3, options);
-}
-function decodeFloat32(data, pos, _minor, options) {
-  return createToken(readFloat32(data, pos + 1), 5, options);
-}
-function decodeFloat64(data, pos, _minor, options) {
-  return createToken(readFloat64(data, pos + 1), 9, options);
-}
-function encodeFloat(buf2, token, options) {
-  const float = token.value;
-  if (float === false) {
-    buf2.push([Type.float.majorEncoded | MINOR_FALSE]);
-  } else if (float === true) {
-    buf2.push([Type.float.majorEncoded | MINOR_TRUE]);
-  } else if (float === null) {
-    buf2.push([Type.float.majorEncoded | MINOR_NULL]);
-  } else if (float === void 0) {
-    buf2.push([Type.float.majorEncoded | MINOR_UNDEFINED]);
-  } else {
-    let decoded;
-    let success = false;
-    if (!options || options.float64 !== true) {
-      encodeFloat16(float);
-      decoded = readFloat16(ui8a, 1);
-      if (float === decoded || Number.isNaN(float)) {
-        ui8a[0] = 249;
-        buf2.push(ui8a.slice(0, 3));
-        success = true;
-      } else {
-        encodeFloat32(float);
-        decoded = readFloat32(ui8a, 1);
-        if (float === decoded) {
-          ui8a[0] = 250;
-          buf2.push(ui8a.slice(0, 5));
-          success = true;
-        }
-      }
-    }
-    if (!success) {
-      encodeFloat64(float);
-      decoded = readFloat64(ui8a, 1);
-      ui8a[0] = 251;
-      buf2.push(ui8a.slice(0, 9));
-    }
-  }
-}
-encodeFloat.encodedSize = function encodedSize8(token, options) {
-  const float = token.value;
-  if (float === false || float === true || float === null || float === void 0) {
-    return 1;
-  }
-  if (!options || options.float64 !== true) {
-    encodeFloat16(float);
-    let decoded = readFloat16(ui8a, 1);
-    if (float === decoded || Number.isNaN(float)) {
-      return 3;
-    }
-    encodeFloat32(float);
-    decoded = readFloat32(ui8a, 1);
-    if (float === decoded) {
-      return 5;
-    }
-  }
-  return 9;
-};
-var buffer = new ArrayBuffer(9);
-var dataView = new DataView(buffer, 1);
-var ui8a = new Uint8Array(buffer, 0);
-function encodeFloat16(inp) {
-  if (inp === Infinity) {
-    dataView.setUint16(0, 31744, false);
-  } else if (inp === -Infinity) {
-    dataView.setUint16(0, 64512, false);
-  } else if (Number.isNaN(inp)) {
-    dataView.setUint16(0, 32256, false);
-  } else {
-    dataView.setFloat32(0, inp);
-    const valu32 = dataView.getUint32(0);
-    const exponent = (valu32 & 2139095040) >> 23;
-    const mantissa = valu32 & 8388607;
-    if (exponent === 255) {
-      dataView.setUint16(0, 31744, false);
-    } else if (exponent === 0) {
-      dataView.setUint16(0, (inp & 2147483648) >> 16 | mantissa >> 13, false);
-    } else {
-      const logicalExponent = exponent - 127;
-      if (logicalExponent < -24) {
-        dataView.setUint16(0, 0);
-      } else if (logicalExponent < -14) {
-        dataView.setUint16(0, (valu32 & 2147483648) >> 16 | /* 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.0.3/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.0.3/node_modules/cborg/lib/encode.js
-var defaultEncodeOptions = {
-  float64: false,
-  mapSorter,
-  quickEncodeToken
-};
-function makeCborEncoders() {
-  const encoders = [];
-  encoders[Type.uint.major] = encodeUint;
-  encoders[Type.negint.major] = encodeNegint;
-  encoders[Type.bytes.major] = encodeBytes;
-  encoders[Type.string.major] = encodeString;
-  encoders[Type.array.major] = encodeArray;
-  encoders[Type.map.major] = encodeMap;
-  encoders[Type.tag.major] = encodeTag;
-  encoders[Type.float.major] = encodeFloat;
-  return encoders;
-}
-var cborEncoders = makeCborEncoders();
-var buf = new Bl();
-var Ref = class _Ref {
-  /**
-   * @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 length2 = isMap ? obj.size : keys.length;
-    if (!length2) {
-      if (options.addBreakTokens === true) {
-        return [simpleTokens.emptyMap, new Token(Type.break)];
-      }
-      return simpleTokens.emptyMap;
-    }
-    refStack = Ref.createCheck(refStack, obj);
-    const entries = [];
-    let i = 0;
-    for (const key of keys) {
-      entries[i++] = [
-        objectToTokens(key, options, refStack),
-        objectToTokens(isMap ? obj.get(key) : obj[key], options, refStack)
-      ];
-    }
-    sortMapEntries(entries, options);
-    if (options.addBreakTokens) {
-      return [new Token(Type.map, length2), entries, new Token(Type.break)];
-    }
-    return [new Token(Type.map, length2), entries];
-  }
-};
-typeEncoders.Map = typeEncoders.Object;
-typeEncoders.Buffer = typeEncoders.Uint8Array;
-for (const typ of "Uint8Clamped Uint16 Uint32 Int8 Int16 Int32 BigUint64 BigInt64 Float32 Float64".split(" ")) {
-  typeEncoders[`${typ}Array`] = typeEncoders.DataView;
-}
-function objectToTokens(obj, options = {}, refStack) {
-  const typ = is(obj);
-  const customTypeEncoder = options && options.typeEncoders && /** @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 tokensToEncoded(buf2, tokens, encoders, options) {
-  if (Array.isArray(tokens)) {
-    for (const token of tokens) {
-      tokensToEncoded(buf2, token, encoders, options);
-    }
-  } else {
-    encoders[tokens.type.major](buf2, tokens, options);
-  }
-}
-function encodeCustom(data, encoders, options) {
-  const tokens = objectToTokens(data, options);
-  if (!Array.isArray(tokens) && options.quickEncodeToken) {
-    const quickBytes = options.quickEncodeToken(tokens);
-    if (quickBytes) {
-      return quickBytes;
-    }
-    const encoder = encoders[tokens.type.major];
-    if (encoder.encodedSize) {
-      const size = encoder.encodedSize(tokens, options);
-      const buf2 = new Bl(size);
-      encoder(buf2, tokens, options);
-      if (buf2.chunks.length !== 1) {
-        throw new Error(`Unexpected error: pre-calculated length for ${tokens} was wrong`);
-      }
-      return asU8A(buf2.chunks[0]);
-    }
-  }
-  buf.reset();
-  tokensToEncoded(buf, tokens, encoders, options);
-  return buf.toBytes(true);
-}
-function encode(data, options) {
-  options = Object.assign({}, defaultEncodeOptions, options);
-  return encodeCustom(data, cborEncoders, options);
-}
-
-// ../../../node_modules/.pnpm/cborg@4.0.3/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 obj = useMaps ? void 0 : {};
-  const m = useMaps ? /* @__PURE__ */ new Map() : void 0;
-  for (let i = 0; i < token.value; i++) {
-    const key = tokensToObject(tokeniser, options);
-    if (key === BREAK) {
-      if (token.value === Infinity) {
-        break;
-      }
-      throw new Error(`${decodeErrPrefix} got unexpected break to lengthed map`);
-    }
-    if (key === DONE) {
-      throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no key], expected ${token.value})`);
-    }
-    if (useMaps !== true && typeof key !== "string") {
-      throw new Error(`${decodeErrPrefix} non-string keys not supported (got ${typeof key})`);
-    }
-    if (options.rejectDuplicateMapKeys === true) {
-      if (useMaps && m.has(key) || !useMaps && key in obj) {
-        throw new Error(`${decodeErrPrefix} found repeat map key "${key}"`);
-      }
-    }
-    const value = tokensToObject(tokeniser, options);
-    if (value === DONE) {
-      throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no value], expected ${token.value})`);
-    }
-    if (useMaps) {
-      m.set(key, value);
-    } else {
-      obj[key] = value;
-    }
-  }
-  return useMaps ? m : obj;
-}
-function tokensToObject(tokeniser, options) {
-  if (tokeniser.done()) {
-    return DONE;
-  }
-  const token = tokeniser.next();
-  if (token.type === Type.break) {
-    return BREAK;
-  }
-  if (token.type.terminal) {
-    return token.value;
-  }
-  if (token.type === Type.array) {
-    return tokenToArray(token, tokeniser, options);
-  }
-  if (token.type === Type.map) {
-    return tokenToMap(token, tokeniser, options);
-  }
-  if (token.type === Type.tag) {
-    if (options.tags && typeof options.tags[token.value] === "function") {
-      const tagged = tokensToObject(tokeniser, options);
-      return options.tags[token.value](tagged);
-    }
-    throw new Error(`${decodeErrPrefix} tag not supported (${token.value})`);
-  }
-  throw new Error("unsupported");
-}
-function decodeFirst(data, options) {
-  if (!(data instanceof Uint8Array)) {
-    throw new Error(`${decodeErrPrefix} data to decode must be a Uint8Array`);
-  }
-  options = Object.assign({}, defaultDecodeOptions, options);
-  const tokeniser = options.tokenizer || new Tokeniser(data, options);
-  const decoded = tokensToObject(tokeniser, options);
-  if (decoded === DONE) {
-    throw new Error(`${decodeErrPrefix} did not find any content to decode`);
-  }
-  if (decoded === BREAK) {
-    throw new Error(`${decodeErrPrefix} got unexpected break`);
-  }
-  return [decoded, data.subarray(tokeniser.pos())];
-}
-function decode(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/cborg@4.0.3/node_modules/cborg/lib/json/encode.js
-var JSONEncoder = class extends Array {
-  constructor() {
-    super();
-    this.inRecursive = [];
-  }
-  /**
-   * @param {Bl} buf
-   */
-  prefix(buf2) {
-    const recurs = this.inRecursive[this.inRecursive.length - 1];
-    if (recurs) {
-      if (recurs.type === Type.array) {
-        recurs.elements++;
-        if (recurs.elements !== 1) {
-          buf2.push([44]);
-        }
-      }
-      if (recurs.type === Type.map) {
-        recurs.elements++;
-        if (recurs.elements !== 1) {
-          if (recurs.elements % 2 === 1) {
-            buf2.push([44]);
-          } else {
-            buf2.push([58]);
-          }
-        }
-      }
-    }
-  }
-  /**
-   * @param {Bl} buf
-   * @param {Token} token
-   */
-  [Type.uint.major](buf2, token) {
-    this.prefix(buf2);
-    const is2 = String(token.value);
-    const isa = [];
-    for (let i = 0; i < is2.length; i++) {
-      isa[i] = is2.charCodeAt(i);
-    }
-    buf2.push(isa);
-  }
-  /**
-   * @param {Bl} buf
-   * @param {Token} token
-   */
-  [Type.negint.major](buf2, token) {
-    this[Type.uint.major](buf2, token);
-  }
-  /**
-   * @param {Bl} _buf
-   * @param {Token} _token
-   */
-  [Type.bytes.major](_buf, _token) {
-    throw new Error(`${encodeErrPrefix} unsupported type: Uint8Array`);
-  }
-  /**
-   * @param {Bl} buf
-   * @param {Token} token
-   */
-  [Type.string.major](buf2, token) {
-    this.prefix(buf2);
-    const byts = fromString(JSON.stringify(token.value));
-    buf2.push(byts.length > 32 ? asU8A(byts) : byts);
-  }
-  /**
-   * @param {Bl} buf
-   * @param {Token} _token
-   */
-  [Type.array.major](buf2, _token) {
-    this.prefix(buf2);
-    this.inRecursive.push({ type: Type.array, elements: 0 });
-    buf2.push([91]);
-  }
-  /**
-   * @param {Bl} buf
-   * @param {Token} _token
-   */
-  [Type.map.major](buf2, _token) {
-    this.prefix(buf2);
-    this.inRecursive.push({ type: Type.map, elements: 0 });
-    buf2.push([123]);
-  }
-  /**
-   * @param {Bl} _buf
-   * @param {Token} _token
-   */
-  [Type.tag.major](_buf, _token) {
-  }
-  /**
-   * @param {Bl} buf
-   * @param {Token} token
-   */
-  [Type.float.major](buf2, token) {
-    if (token.type.name === "break") {
-      const recurs = this.inRecursive.pop();
-      if (recurs) {
-        if (recurs.type === Type.array) {
-          buf2.push([93]);
-        } else if (recurs.type === Type.map) {
-          buf2.push([125]);
-        } else {
-          throw new Error("Unexpected recursive type; this should not happen!");
-        }
-        return;
-      }
-      throw new Error("Unexpected break; this should not happen!");
-    }
-    if (token.value === void 0) {
-      throw new Error(`${encodeErrPrefix} unsupported type: undefined`);
-    }
-    this.prefix(buf2);
-    if (token.type.name === "true") {
-      buf2.push([116, 114, 117, 101]);
-      return;
-    } else if (token.type.name === "false") {
-      buf2.push([102, 97, 108, 115, 101]);
-      return;
-    } else if (token.type.name === "null") {
-      buf2.push([110, 117, 108, 108]);
-      return;
-    }
-    const is2 = String(token.value);
-    const isa = [];
-    let dp = false;
-    for (let i = 0; i < is2.length; i++) {
-      isa[i] = is2.charCodeAt(i);
-      if (!dp && (isa[i] === 46 || isa[i] === 101 || isa[i] === 69)) {
-        dp = true;
-      }
-    }
-    if (!dp) {
-      isa.push(46);
-      isa.push(48);
-    }
-    buf2.push(isa);
-  }
-};
-function mapSorter2(e1, e2) {
-  if (Array.isArray(e1[0]) || Array.isArray(e2[0])) {
-    throw new Error(`${encodeErrPrefix} complex map keys are not supported`);
-  }
-  const keyToken1 = e1[0];
-  const keyToken2 = e2[0];
-  if (keyToken1.type !== Type.string || keyToken2.type !== Type.string) {
-    throw new Error(`${encodeErrPrefix} non-string map keys are not supported`);
-  }
-  if (keyToken1 < keyToken2) {
-    return -1;
-  }
-  if (keyToken1 > keyToken2) {
-    return 1;
-  }
-  throw new Error(`${encodeErrPrefix} unexpected duplicate map keys, this is not supported`);
-}
-var defaultEncodeOptions2 = { addBreakTokens: true, mapSorter: mapSorter2 };
-function encode2(data, options) {
-  options = Object.assign({}, defaultEncodeOptions2, options);
-  return encodeCustom(data, new JSONEncoder(), options);
-}
-
-// ../../../node_modules/.pnpm/cborg@4.0.3/node_modules/cborg/lib/json/decode.js
-var Tokenizer = class {
-  /**
-   * @param {Uint8Array} data
-   * @param {DecodeOptions} options
-   */
-  constructor(data, options = {}) {
-    this._pos = 0;
-    this.data = data;
-    this.options = options;
-    this.modeStack = ["value"];
-    this.lastToken = "";
-  }
-  pos() {
-    return this._pos;
-  }
-  /**
-   * @returns {boolean}
-   */
-  done() {
-    return this._pos >= this.data.length;
-  }
-  /**
-   * @returns {number}
-   */
-  ch() {
-    return this.data[this._pos];
-  }
-  /**
-   * @returns {string}
-   */
-  currentMode() {
-    return this.modeStack[this.modeStack.length - 1];
-  }
-  skipWhitespace() {
-    let c = this.ch();
-    while (c === 32 || c === 9 || c === 13 || c === 10) {
-      c = this.data[++this._pos];
-    }
-  }
-  /**
-   * @param {number[]} str
-   */
-  expect(str) {
-    if (this.data.length - this._pos < str.length) {
-      throw new Error(`${decodeErrPrefix} unexpected end of input at position ${this._pos}`);
-    }
-    for (let i = 0; i < str.length; i++) {
-      if (this.data[this._pos++] !== str[i]) {
-        throw new Error(`${decodeErrPrefix} unexpected token at position ${this._pos}, expected to find '${String.fromCharCode(...str)}'`);
-      }
-    }
-  }
-  parseNumber() {
-    const startPos = this._pos;
-    let negative = false;
-    let float = false;
-    const swallow = (chars) => {
-      while (!this.done()) {
-        const ch = this.ch();
-        if (chars.includes(ch)) {
-          this._pos++;
-        } else {
-          break;
-        }
-      }
-    };
-    if (this.ch() === 45) {
-      negative = true;
-      this._pos++;
-    }
-    if (this.ch() === 48) {
-      this._pos++;
-      if (this.ch() === 46) {
-        this._pos++;
-        float = true;
-      } else {
-        return new Token(Type.uint, 0, this._pos - startPos);
-      }
-    }
-    swallow([48, 49, 50, 51, 52, 53, 54, 55, 56, 57]);
-    if (negative && this._pos === startPos + 1) {
-      throw new Error(`${decodeErrPrefix} unexpected token at position ${this._pos}`);
-    }
-    if (!this.done() && this.ch() === 46) {
-      if (float) {
-        throw new Error(`${decodeErrPrefix} unexpected token at position ${this._pos}`);
-      }
-      float = true;
-      this._pos++;
-      swallow([48, 49, 50, 51, 52, 53, 54, 55, 56, 57]);
-    }
-    if (!this.done() && (this.ch() === 101 || this.ch() === 69)) {
-      float = true;
-      this._pos++;
-      if (!this.done() && (this.ch() === 43 || this.ch() === 45)) {
-        this._pos++;
-      }
-      swallow([48, 49, 50, 51, 52, 53, 54, 55, 56, 57]);
-    }
-    const numStr = String.fromCharCode.apply(null, this.data.subarray(startPos, this._pos));
-    const num = parseFloat(numStr);
-    if (float) {
-      return new Token(Type.float, num, this._pos - startPos);
-    }
-    if (this.options.allowBigInt !== true || Number.isSafeInteger(num)) {
-      return new Token(num >= 0 ? Type.uint : Type.negint, num, this._pos - startPos);
-    }
-    return new Token(num >= 0 ? Type.uint : Type.negint, BigInt(numStr), this._pos - startPos);
-  }
-  /**
-   * @returns {Token}
-   */
-  parseString() {
-    if (this.ch() !== 34) {
-      throw new Error(`${decodeErrPrefix} unexpected character at position ${this._pos}; this shouldn't happen`);
-    }
-    this._pos++;
-    for (let i = this._pos, l = 0; i < this.data.length && l < 65536; i++, l++) {
-      const ch = this.data[i];
-      if (ch === 92 || ch < 32 || ch >= 128) {
-        break;
-      }
-      if (ch === 34) {
-        const str = String.fromCharCode.apply(null, this.data.subarray(this._pos, i));
-        this._pos = i + 1;
-        return new Token(Type.string, str, l);
-      }
-    }
-    const startPos = this._pos;
-    const chars = [];
-    const readu4 = () => {
-      if (this._pos + 4 >= this.data.length) {
-        throw new Error(`${decodeErrPrefix} unexpected end of unicode escape sequence at position ${this._pos}`);
-      }
-      let u4 = 0;
-      for (let i = 0; i < 4; i++) {
-        let ch = this.ch();
-        if (ch >= 48 && ch <= 57) {
-          ch -= 48;
-        } else if (ch >= 97 && ch <= 102) {
-          ch = ch - 97 + 10;
-        } else if (ch >= 65 && ch <= 70) {
-          ch = ch - 65 + 10;
-        } else {
-          throw new Error(`${decodeErrPrefix} unexpected unicode escape character at position ${this._pos}`);
-        }
-        u4 = u4 * 16 + ch;
-        this._pos++;
-      }
-      return u4;
-    };
-    const readUtf8Char = () => {
-      const firstByte = this.ch();
-      let codePoint = null;
-      let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
-      if (this._pos + bytesPerSequence > this.data.length) {
-        throw new Error(`${decodeErrPrefix} unexpected unicode sequence at position ${this._pos}`);
-      }
-      let secondByte, thirdByte, fourthByte, tempCodePoint;
-      switch (bytesPerSequence) {
-        case 1:
-          if (firstByte < 128) {
-            codePoint = firstByte;
-          }
-          break;
-        case 2:
-          secondByte = this.data[this._pos + 1];
-          if ((secondByte & 192) === 128) {
-            tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
-            if (tempCodePoint > 127) {
-              codePoint = tempCodePoint;
-            }
-          }
-          break;
-        case 3:
-          secondByte = this.data[this._pos + 1];
-          thirdByte = this.data[this._pos + 2];
-          if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
-            tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
-            if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
-              codePoint = tempCodePoint;
-            }
-          }
-          break;
-        case 4:
-          secondByte = this.data[this._pos + 1];
-          thirdByte = this.data[this._pos + 2];
-          fourthByte = this.data[this._pos + 3];
-          if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
-            tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
-            if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
-              codePoint = tempCodePoint;
-            }
-          }
-      }
-      if (codePoint === null) {
-        codePoint = 65533;
-        bytesPerSequence = 1;
-      } else if (codePoint > 65535) {
-        codePoint -= 65536;
-        chars.push(codePoint >>> 10 & 1023 | 55296);
-        codePoint = 56320 | codePoint & 1023;
-      }
-      chars.push(codePoint);
-      this._pos += bytesPerSequence;
-    };
-    while (!this.done()) {
-      const ch = this.ch();
-      let ch1;
-      switch (ch) {
-        case 92:
-          this._pos++;
-          if (this.done()) {
-            throw new Error(`${decodeErrPrefix} unexpected string termination at position ${this._pos}`);
-          }
-          ch1 = this.ch();
-          this._pos++;
-          switch (ch1) {
-            case 34:
-            case 39:
-            case 92:
-            case 47:
-              chars.push(ch1);
-              break;
-            case 98:
-              chars.push(8);
-              break;
-            case 116:
-              chars.push(9);
-              break;
-            case 110:
-              chars.push(10);
-              break;
-            case 102:
-              chars.push(12);
-              break;
-            case 114:
-              chars.push(13);
-              break;
-            case 117:
-              chars.push(readu4());
-              break;
-            default:
-              throw new Error(`${decodeErrPrefix} unexpected string escape character at position ${this._pos}`);
-          }
-          break;
-        case 34:
-          this._pos++;
-          return new Token(Type.string, decodeCodePointsArray(chars), this._pos - startPos);
-        default:
-          if (ch < 32) {
-            throw new Error(`${decodeErrPrefix} invalid control character at position ${this._pos}`);
-          } else if (ch < 128) {
-            chars.push(ch);
-            this._pos++;
-          } else {
-            readUtf8Char();
-          }
-      }
-    }
-    throw new Error(`${decodeErrPrefix} unexpected end of string at position ${this._pos}`);
-  }
-  /**
-   * @returns {Token}
-   */
-  parseValue() {
-    switch (this.ch()) {
-      case 123:
-        this.modeStack.push("obj-start");
-        this._pos++;
-        return new Token(Type.map, Infinity, 1);
-      case 91:
-        this.modeStack.push("array-start");
-        this._pos++;
-        return new Token(Type.array, Infinity, 1);
-      case 34: {
-        return this.parseString();
-      }
-      case 110:
-        this.expect([110, 117, 108, 108]);
-        return new Token(Type.null, null, 4);
-      case 102:
-        this.expect([102, 97, 108, 115, 101]);
-        return new Token(Type.false, false, 5);
-      case 116:
-        this.expect([116, 114, 117, 101]);
-        return new Token(Type.true, true, 4);
-      case 45:
-      case 48:
-      case 49:
-      case 50:
-      case 51:
-      case 52:
-      case 53:
-      case 54:
-      case 55:
-      case 56:
-      case 57:
-        return this.parseNumber();
-      default:
-        throw new Error(`${decodeErrPrefix} unexpected character at position ${this._pos}`);
-    }
-  }
-  /**
-   * @returns {Token}
-   */
-  next() {
-    this.skipWhitespace();
-    switch (this.currentMode()) {
-      case "value":
-        this.modeStack.pop();
-        return this.parseValue();
-      case "array-value": {
-        this.modeStack.pop();
-        if (this.ch() === 93) {
-          this._pos++;
-          this.skipWhitespace();
-          return new Token(Type.break, void 0, 1);
-        }
-        if (this.ch() !== 44) {
-          throw new Error(`${decodeErrPrefix} unexpected character at position ${this._pos}, was expecting array delimiter but found '${String.fromCharCode(this.ch())}'`);
-        }
-        this._pos++;
-        this.modeStack.push("array-value");
-        this.skipWhitespace();
-        return this.parseValue();
-      }
-      case "array-start": {
-        this.modeStack.pop();
-        if (this.ch() === 93) {
-          this._pos++;
-          this.skipWhitespace();
-          return new Token(Type.break, void 0, 1);
-        }
-        this.modeStack.push("array-value");
-        this.skipWhitespace();
-        return this.parseValue();
-      }
-      case "obj-key":
-        if (this.ch() === 125) {
-          this.modeStack.pop();
-          this._pos++;
-          this.skipWhitespace();
-          return new Token(Type.break, void 0, 1);
-        }
-        if (this.ch() !== 44) {
-          throw new Error(`${decodeErrPrefix} unexpected character at position ${this._pos}, was expecting object delimiter but found '${String.fromCharCode(this.ch())}'`);
-        }
-        this._pos++;
-        this.skipWhitespace();
-      case "obj-start": {
-        this.modeStack.pop();
-        if (this.ch() === 125) {
-          this._pos++;
-          this.skipWhitespace();
-          return new Token(Type.break, void 0, 1);
-        }
-        const token = this.parseString();
-        this.skipWhitespace();
-        if (this.ch() !== 58) {
-          throw new Error(`${decodeErrPrefix} unexpected character at position ${this._pos}, was expecting key/value delimiter ':' but found '${String.fromCharCode(this.ch())}'`);
-        }
-        this._pos++;
-        this.modeStack.push("obj-value");
-        return token;
-      }
-      case "obj-value": {
-        this.modeStack.pop();
-        this.modeStack.push("obj-key");
-        this.skipWhitespace();
-        return this.parseValue();
-      }
-      default:
-        throw new Error(`${decodeErrPrefix} unexpected parse state at position ${this._pos}; this shouldn't happen`);
-    }
-  }
-};
-function decode2(data, options) {
-  options = Object.assign({ tokenizer: new Tokenizer(data, options) }, options);
-  return decode(data, options);
-}
-
-// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/bytes.js
-var empty = new Uint8Array(0);
-var equals = (aa, bb) => {
-  if (aa === bb)
-    return true;
-  if (aa.byteLength !== bb.byteLength) {
-    return false;
-  }
-  for (let ii = 0; ii < aa.byteLength; ii++) {
-    if (aa[ii] !== bb[ii]) {
-      return false;
-    }
-  }
-  return true;
-};
-var coerce = (o) => {
-  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array")
-    return o;
-  if (o instanceof ArrayBuffer)
-    return new Uint8Array(o);
-  if (ArrayBuffer.isView(o)) {
-    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
-  }
-  throw new Error("Unknown type, must be binary type");
-};
-
-// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/vendor/base-x.js
-function base(ALPHABET, name2) {
-  if (ALPHABET.length >= 255) {
-    throw new TypeError("Alphabet too long");
-  }
-  var BASE_MAP = new Uint8Array(256);
-  for (var j = 0; j < BASE_MAP.length; j++) {
-    BASE_MAP[j] = 255;
-  }
-  for (var i = 0; i < ALPHABET.length; i++) {
-    var x = ALPHABET.charAt(i);
-    var xc = x.charCodeAt(0);
-    if (BASE_MAP[xc] !== 255) {
-      throw new TypeError(x + " is ambiguous");
-    }
-    BASE_MAP[xc] = i;
-  }
-  var BASE = ALPHABET.length;
-  var LEADER = ALPHABET.charAt(0);
-  var FACTOR = Math.log(BASE) / Math.log(256);
-  var iFACTOR = Math.log(256) / Math.log(BASE);
-  function encode7(source) {
-    if (source instanceof Uint8Array)
-      ;
-    else if (ArrayBuffer.isView(source)) {
-      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-    } else if (Array.isArray(source)) {
-      source = Uint8Array.from(source);
-    }
-    if (!(source instanceof Uint8Array)) {
-      throw new TypeError("Expected Uint8Array");
-    }
-    if (source.length === 0) {
-      return "";
-    }
-    var zeroes = 0;
-    var length2 = 0;
-    var pbegin = 0;
-    var pend = source.length;
-    while (pbegin !== pend && source[pbegin] === 0) {
-      pbegin++;
-      zeroes++;
-    }
-    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
-    var b58 = new Uint8Array(size);
-    while (pbegin !== pend) {
-      var carry = source[pbegin];
-      var i2 = 0;
-      for (var it1 = size - 1; (carry !== 0 || i2 < length2) && it1 !== -1; it1--, i2++) {
-        carry += 256 * b58[it1] >>> 0;
-        b58[it1] = carry % BASE >>> 0;
-        carry = carry / BASE >>> 0;
-      }
-      if (carry !== 0) {
-        throw new Error("Non-zero carry");
-      }
-      length2 = i2;
-      pbegin++;
-    }
-    var it2 = size - length2;
-    while (it2 !== size && b58[it2] === 0) {
-      it2++;
-    }
-    var str = LEADER.repeat(zeroes);
-    for (; it2 < size; ++it2) {
-      str += ALPHABET.charAt(b58[it2]);
-    }
-    return str;
-  }
-  function decodeUnsafe(source) {
-    if (typeof source !== "string") {
-      throw new TypeError("Expected String");
-    }
-    if (source.length === 0) {
-      return new Uint8Array();
-    }
-    var psz = 0;
-    if (source[psz] === " ") {
-      return;
-    }
-    var zeroes = 0;
-    var length2 = 0;
-    while (source[psz] === LEADER) {
-      zeroes++;
-      psz++;
-    }
-    var size = (source.length - psz) * FACTOR + 1 >>> 0;
-    var b256 = new Uint8Array(size);
-    while (source[psz]) {
-      var carry = BASE_MAP[source.charCodeAt(psz)];
-      if (carry === 255) {
-        return;
-      }
-      var i2 = 0;
-      for (var it3 = size - 1; (carry !== 0 || i2 < length2) && it3 !== -1; it3--, i2++) {
-        carry += BASE * b256[it3] >>> 0;
-        b256[it3] = carry % 256 >>> 0;
-        carry = carry / 256 >>> 0;
-      }
-      if (carry !== 0) {
-        throw new Error("Non-zero carry");
-      }
-      length2 = i2;
-      psz++;
-    }
-    if (source[psz] === " ") {
-      return;
-    }
-    var it4 = size - length2;
-    while (it4 !== size && b256[it4] === 0) {
-      it4++;
-    }
-    var vch = new Uint8Array(zeroes + (size - it4));
-    var j2 = zeroes;
-    while (it4 !== size) {
-      vch[j2++] = b256[it4++];
-    }
-    return vch;
-  }
-  function decode8(string) {
-    var buffer2 = decodeUnsafe(string);
-    if (buffer2) {
-      return buffer2;
-    }
-    throw new Error(`Non-${name2} character`);
-  }
-  return {
-    encode: encode7,
-    decodeUnsafe,
-    decode: decode8
-  };
-}
-var src = base;
-var _brrp__multiformats_scope_baseX = src;
-var base_x_default = _brrp__multiformats_scope_baseX;
-
-// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/bases/base.js
-var Encoder = class {
-  /**
-   * @param {Base} name
-   * @param {Prefix} prefix
-   * @param {(bytes:Uint8Array) => string} baseEncode
-   */
-  constructor(name2, prefix, baseEncode) {
-    this.name = name2;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-  }
-  /**
-   * @param {Uint8Array} bytes
-   * @returns {API.Multibase<Prefix>}
-   */
-  encode(bytes2) {
-    if (bytes2 instanceof Uint8Array) {
-      return `${this.prefix}${this.baseEncode(bytes2)}`;
-    } else {
-      throw Error("Unknown type, must be binary type");
-    }
-  }
-};
-var Decoder = class {
-  /**
-   * @param {Base} name
-   * @param {Prefix} prefix
-   * @param {(text:string) => Uint8Array} baseDecode
-   */
-  constructor(name2, prefix, baseDecode) {
-    this.name = name2;
-    this.prefix = prefix;
-    if (prefix.codePointAt(0) === void 0) {
-      throw new Error("Invalid prefix character");
-    }
-    this.prefixCodePoint = /** @type {number} */
-    prefix.codePointAt(0);
-    this.baseDecode = baseDecode;
-  }
-  /**
-   * @param {string} text
-   */
-  decode(text) {
-    if (typeof text === "string") {
-      if (text.codePointAt(0) !== this.prefixCodePoint) {
-        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
-      }
-      return this.baseDecode(text.slice(this.prefix.length));
-    } else {
-      throw Error("Can only multibase decode strings");
-    }
-  }
-  /**
-   * @template {string} OtherPrefix
-   * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
-   * @returns {ComposedDecoder<Prefix|OtherPrefix>}
-   */
-  or(decoder) {
-    return or(this, decoder);
-  }
-};
-var ComposedDecoder = class {
-  /**
-   * @param {Decoders<Prefix>} decoders
-   */
-  constructor(decoders) {
-    this.decoders = decoders;
-  }
-  /**
-   * @template {string} OtherPrefix
-   * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
-   * @returns {ComposedDecoder<Prefix|OtherPrefix>}
-   */
-  or(decoder) {
-    return or(this, decoder);
-  }
-  /**
-   * @param {string} input
-   * @returns {Uint8Array}
-   */
-  decode(input) {
-    const prefix = (
-      /** @type {Prefix} */
-      input[0]
-    );
-    const decoder = this.decoders[prefix];
-    if (decoder) {
-      return decoder.decode(input);
-    } else {
-      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
-    }
-  }
-};
-var or = (left, right) => new ComposedDecoder(
-  /** @type {Decoders<L|R>} */
-  {
-    ...left.decoders || { [
-      /** @type API.UnibaseDecoder<L> */
-      left.prefix
-    ]: left },
-    ...right.decoders || { [
-      /** @type API.UnibaseDecoder<R> */
-      right.prefix
-    ]: right }
-  }
-);
-var Codec = class {
-  /**
-   * @param {Base} name
-   * @param {Prefix} prefix
-   * @param {(bytes:Uint8Array) => string} baseEncode
-   * @param {(text:string) => Uint8Array} baseDecode
-   */
-  constructor(name2, prefix, baseEncode, baseDecode) {
-    this.name = name2;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-    this.baseDecode = baseDecode;
-    this.encoder = new Encoder(name2, prefix, baseEncode);
-    this.decoder = new Decoder(name2, prefix, baseDecode);
-  }
-  /**
-   * @param {Uint8Array} input
-   */
-  encode(input) {
-    return this.encoder.encode(input);
-  }
-  /**
-   * @param {string} input
-   */
-  decode(input) {
-    return this.decoder.decode(input);
-  }
-};
-var from = ({ name: name2, prefix, encode: encode7, decode: decode8 }) => new Codec(name2, prefix, encode7, decode8);
-var baseX = ({ prefix, name: name2, alphabet }) => {
-  const { encode: encode7, decode: decode8 } = base_x_default(alphabet, name2);
-  return from({
-    prefix,
-    name: name2,
-    encode: encode7,
-    /**
-     * @param {string} text
-     */
-    decode: (text) => coerce(decode8(text))
-  });
-};
-var decode3 = (string, alphabet, bitsPerChar, name2) => {
-  const codes = {};
-  for (let i = 0; i < alphabet.length; ++i) {
-    codes[alphabet[i]] = i;
-  }
-  let end = string.length;
-  while (string[end - 1] === "=") {
-    --end;
-  }
-  const out = new Uint8Array(end * bitsPerChar / 8 | 0);
-  let bits = 0;
-  let buffer2 = 0;
-  let written = 0;
-  for (let i = 0; i < end; ++i) {
-    const value = codes[string[i]];
-    if (value === void 0) {
-      throw new SyntaxError(`Non-${name2} character`);
-    }
-    buffer2 = buffer2 << bitsPerChar | value;
-    bits += bitsPerChar;
-    if (bits >= 8) {
-      bits -= 8;
-      out[written++] = 255 & buffer2 >> bits;
-    }
-  }
-  if (bits >= bitsPerChar || 255 & buffer2 << 8 - bits) {
-    throw new SyntaxError("Unexpected end of data");
-  }
-  return out;
-};
-var encode3 = (data, alphabet, bitsPerChar) => {
-  const pad = alphabet[alphabet.length - 1] === "=";
-  const mask = (1 << bitsPerChar) - 1;
-  let out = "";
-  let bits = 0;
-  let buffer2 = 0;
-  for (let i = 0; i < data.length; ++i) {
-    buffer2 = buffer2 << 8 | data[i];
-    bits += 8;
-    while (bits > bitsPerChar) {
-      bits -= bitsPerChar;
-      out += alphabet[mask & buffer2 >> bits];
-    }
-  }
-  if (bits) {
-    out += alphabet[mask & buffer2 << bitsPerChar - bits];
-  }
-  if (pad) {
-    while (out.length * bitsPerChar & 7) {
-      out += "=";
-    }
-  }
-  return out;
-};
-var rfc4648 = ({ name: name2, prefix, bitsPerChar, alphabet }) => {
-  return from({
-    prefix,
-    name: name2,
-    encode(input) {
-      return encode3(input, alphabet, bitsPerChar);
-    },
-    decode(input) {
-      return decode3(input, alphabet, bitsPerChar, name2);
-    }
-  });
-};
-
-// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/bases/base32.js
-var base32 = rfc4648({
-  prefix: "b",
-  name: "base32",
-  alphabet: "abcdefghijklmnopqrstuvwxyz234567",
-  bitsPerChar: 5
-});
-var base32upper = rfc4648({
-  prefix: "B",
-  name: "base32upper",
-  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
-  bitsPerChar: 5
-});
-var base32pad = rfc4648({
-  prefix: "c",
-  name: "base32pad",
-  alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
-  bitsPerChar: 5
-});
-var base32padupper = rfc4648({
-  prefix: "C",
-  name: "base32padupper",
-  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
-  bitsPerChar: 5
-});
-var base32hex = rfc4648({
-  prefix: "v",
-  name: "base32hex",
-  alphabet: "0123456789abcdefghijklmnopqrstuv",
-  bitsPerChar: 5
-});
-var base32hexupper = rfc4648({
-  prefix: "V",
-  name: "base32hexupper",
-  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
-  bitsPerChar: 5
-});
-var base32hexpad = rfc4648({
-  prefix: "t",
-  name: "base32hexpad",
-  alphabet: "0123456789abcdefghijklmnopqrstuv=",
-  bitsPerChar: 5
-});
-var base32hexpadupper = rfc4648({
-  prefix: "T",
-  name: "base32hexpadupper",
-  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
-  bitsPerChar: 5
-});
-var base32z = rfc4648({
-  prefix: "h",
-  name: "base32z",
-  alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
-  bitsPerChar: 5
-});
-
-// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/bases/base58.js
-var base58btc = baseX({
-  name: "base58btc",
-  prefix: "z",
-  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-});
-var base58flickr = baseX({
-  name: "base58flickr",
-  prefix: "Z",
-  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
-});
-
-// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/hashes/digest.js
-var digest_exports = {};
-__export(digest_exports, {
-  Digest: () => Digest,
-  create: () => create,
-  decode: () => decode6,
-  equals: () => equals2
-});
-
-// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/vendor/varint.js
-var encode_1 = encode4;
-var MSB = 128;
-var REST = 127;
-var MSBALL = ~REST;
-var INT = Math.pow(2, 31);
-function encode4(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;
-  encode4.bytes = offset - oldOffset + 1;
-  return out;
-}
-var decode4 = read;
-var MSB$1 = 128;
-var REST$1 = 127;
-function read(buf2, offset) {
-  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf2.length;
-  do {
-    if (counter >= l) {
-      read.bytes = 0;
-      throw new RangeError("Could not decode varint");
-    }
-    b = buf2[counter++];
-    res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
-    shift += 7;
-  } while (b >= MSB$1);
-  read.bytes = counter - offset;
-  return res;
-}
-var N1 = Math.pow(2, 7);
-var N2 = Math.pow(2, 14);
-var N3 = Math.pow(2, 21);
-var N4 = Math.pow(2, 28);
-var N5 = Math.pow(2, 35);
-var N6 = Math.pow(2, 42);
-var N7 = Math.pow(2, 49);
-var N8 = Math.pow(2, 56);
-var N9 = Math.pow(2, 63);
-var length = function(value) {
-  return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
-};
-var varint = {
-  encode: encode_1,
-  decode: decode4,
-  encodingLength: length
-};
-var _brrp_varint = varint;
-var varint_default = _brrp_varint;
-
-// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/varint.js
-var decode5 = (data, offset = 0) => {
-  const code2 = varint_default.decode(data, offset);
-  return [code2, varint_default.decode.bytes];
-};
-var encodeTo = (int, target, offset = 0) => {
-  varint_default.encode(int, target, offset);
-  return target;
-};
-var encodingLength = (int) => {
-  return varint_default.encodingLength(int);
-};
-
-// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/hashes/digest.js
-var create = (code2, digest) => {
-  const size = digest.byteLength;
-  const sizeOffset = encodingLength(code2);
-  const digestOffset = sizeOffset + encodingLength(size);
-  const bytes2 = new Uint8Array(digestOffset + size);
-  encodeTo(code2, bytes2, 0);
-  encodeTo(size, bytes2, sizeOffset);
-  bytes2.set(digest, digestOffset);
-  return new Digest(code2, size, digest, bytes2);
-};
-var decode6 = (multihash) => {
-  const bytes2 = coerce(multihash);
-  const [code2, sizeOffset] = decode5(bytes2);
-  const [size, digestOffset] = decode5(bytes2.subarray(sizeOffset));
-  const digest = bytes2.subarray(sizeOffset + digestOffset);
-  if (digest.byteLength !== size) {
-    throw new Error("Incorrect length");
-  }
-  return new Digest(code2, size, digest, bytes2);
-};
-var equals2 = (a, b) => {
-  if (a === b) {
-    return true;
-  } else {
-    const data = (
-      /** @type {{code?:unknown, size?:unknown, bytes?:unknown}} */
-      b
-    );
-    return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals(a.bytes, data.bytes);
-  }
-};
-var Digest = class {
-  /**
-   * Creates a multihash digest.
-   *
-   * @param {Code} code
-   * @param {Size} size
-   * @param {Uint8Array} digest
-   * @param {Uint8Array} bytes
-   */
-  constructor(code2, size, digest, bytes2) {
-    this.code = code2;
-    this.size = size;
-    this.digest = digest;
-    this.bytes = bytes2;
-  }
-};
-
-// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/cid.js
-var format = (link, base2) => {
-  const { bytes: bytes2, version } = link;
-  switch (version) {
-    case 0:
-      return toStringV0(
-        bytes2,
-        baseCache(link),
-        /** @type {API.MultibaseEncoder<"z">} */
-        base2 || base58btc.encoder
-      );
-    default:
-      return toStringV1(
-        bytes2,
-        baseCache(link),
-        /** @type {API.MultibaseEncoder<Prefix>} */
-        base2 || base32.encoder
-      );
-  }
-};
-var cache = /* @__PURE__ */ new WeakMap();
-var baseCache = (cid) => {
-  const baseCache2 = cache.get(cid);
-  if (baseCache2 == null) {
-    const baseCache3 = /* @__PURE__ */ new Map();
-    cache.set(cid, baseCache3);
-    return baseCache3;
-  }
-  return baseCache2;
-};
-var CID = class _CID {
-  /**
-   * @param {Version} version - Version of the CID
-   * @param {Format} code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
-   * @param {API.MultihashDigest<Alg>} multihash - (Multi)hash of the of the content.
-   * @param {Uint8Array} bytes
-   */
-  constructor(version, code2, multihash, bytes2) {
-    this.code = code2;
-    this.version = version;
-    this.multihash = multihash;
-    this.bytes = bytes2;
-    this["/"] = bytes2;
-  }
-  /**
-   * Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`
-   * please either use `CID.asCID(cid)` or switch to new signalling mechanism
-   *
-   * @deprecated
-   */
-  get asCID() {
-    return this;
-  }
-  // ArrayBufferView
-  get byteOffset() {
-    return this.bytes.byteOffset;
-  }
-  // ArrayBufferView
-  get byteLength() {
-    return this.bytes.byteLength;
-  }
-  /**
-   * @returns {CID<Data, API.DAG_PB, API.SHA_256, 0>}
-   */
-  toV0() {
-    switch (this.version) {
-      case 0: {
-        return (
-          /** @type {CID<Data, API.DAG_PB, API.SHA_256, 0>} */
-          this
-        );
-      }
-      case 1: {
-        const { code: code2, multihash } = this;
-        if (code2 !== DAG_PB_CODE) {
-          throw new Error("Cannot convert a non dag-pb CID to CIDv0");
-        }
-        if (multihash.code !== SHA_256_CODE) {
-          throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
-        }
-        return (
-          /** @type {CID<Data, API.DAG_PB, API.SHA_256, 0>} */
-          _CID.createV0(
-            /** @type {API.MultihashDigest<API.SHA_256>} */
-            multihash
-          )
-        );
-      }
-      default: {
-        throw Error(
-          `Can not convert CID version ${this.version} to version 0. This is a bug please report`
-        );
-      }
-    }
-  }
-  /**
-   * @returns {CID<Data, Format, Alg, 1>}
-   */
-  toV1() {
-    switch (this.version) {
-      case 0: {
-        const { code: code2, digest } = this.multihash;
-        const multihash = create(code2, digest);
-        return (
-          /** @type {CID<Data, Format, Alg, 1>} */
-          _CID.createV1(this.code, multihash)
-        );
-      }
-      case 1: {
-        return (
-          /** @type {CID<Data, Format, Alg, 1>} */
-          this
-        );
-      }
-      default: {
-        throw Error(
-          `Can not convert CID version ${this.version} to version 1. This is a bug please report`
-        );
-      }
-    }
-  }
-  /**
-   * @param {unknown} other
-   * @returns {other is CID<Data, Format, Alg, Version>}
-   */
-  equals(other) {
-    return _CID.equals(this, other);
-  }
-  /**
-   * @template {unknown} Data
-   * @template {number} Format
-   * @template {number} Alg
-   * @template {API.Version} Version
-   * @param {API.Link<Data, Format, Alg, Version>} self
-   * @param {unknown} other
-   * @returns {other is CID}
-   */
-  static equals(self2, other) {
-    const unknown = (
-      /** @type {{code?:unknown, version?:unknown, multihash?:unknown}} */
-      other
-    );
-    return unknown && self2.code === unknown.code && self2.version === unknown.version && equals2(self2.multihash, unknown.multihash);
-  }
-  /**
-   * @param {API.MultibaseEncoder<string>} [base]
-   * @returns {string}
-   */
-  toString(base2) {
-    return format(this, base2);
-  }
-  /**
-   * @returns {API.LinkJSON<this>}
-   */
-  toJSON() {
-    return { "/": format(this) };
-  }
-  link() {
-    return this;
-  }
-  get [Symbol.toStringTag]() {
-    return "CID";
-  }
-  // Legacy
-  [Symbol.for("nodejs.util.inspect.custom")]() {
-    return `CID(${this.toString()})`;
-  }
-  /**
-   * Takes any input `value` and returns a `CID` instance if it was
-   * a `CID` otherwise returns `null`. If `value` is instanceof `CID`
-   * it will return value back. If `value` is not instance of this CID
-   * class, but is compatible CID it will return new instance of this
-   * `CID` class. Otherwise returns null.
-   *
-   * This allows two different incompatible versions of CID library to
-   * co-exist and interop as long as binary interface is compatible.
-   *
-   * @template {unknown} Data
-   * @template {number} Format
-   * @template {number} Alg
-   * @template {API.Version} Version
-   * @template {unknown} U
-   * @param {API.Link<Data, Format, Alg, Version>|U} input
-   * @returns {CID<Data, Format, Alg, Version>|null}
-   */
-  static asCID(input) {
-    if (input == null) {
-      return null;
-    }
-    const value = (
-      /** @type {any} */
-      input
-    );
-    if (value instanceof _CID) {
-      return value;
-    } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
-      const { version, code: code2, multihash, bytes: bytes2 } = value;
-      return new _CID(
-        version,
-        code2,
-        /** @type {API.MultihashDigest<Alg>} */
-        multihash,
-        bytes2 || encodeCID(version, code2, multihash.bytes)
-      );
-    } else if (value[cidSymbol] === true) {
-      const { version, multihash, code: code2 } = value;
-      const digest = (
-        /** @type {API.MultihashDigest<Alg>} */
-        decode6(multihash)
-      );
-      return _CID.create(version, code2, digest);
-    } else {
-      return null;
-    }
-  }
-  /**
-   *
-   * @template {unknown} Data
-   * @template {number} Format
-   * @template {number} Alg
-   * @template {API.Version} Version
-   * @param {Version} version - Version of the CID
-   * @param {Format} code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
-   * @param {API.MultihashDigest<Alg>} digest - (Multi)hash of the of the content.
-   * @returns {CID<Data, Format, Alg, Version>}
-   */
-  static create(version, code2, digest) {
-    if (typeof code2 !== "number") {
-      throw new Error("String codecs are no longer supported");
-    }
-    if (!(digest.bytes instanceof Uint8Array)) {
-      throw new Error("Invalid digest");
-    }
-    switch (version) {
-      case 0: {
-        if (code2 !== DAG_PB_CODE) {
-          throw new Error(
-            `Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`
-          );
-        } else {
-          return new _CID(version, code2, digest, digest.bytes);
-        }
-      }
-      case 1: {
-        const bytes2 = encodeCID(version, code2, digest.bytes);
-        return new _CID(version, code2, digest, bytes2);
-      }
-      default: {
-        throw new Error("Invalid version");
-      }
-    }
-  }
-  /**
-   * Simplified version of `create` for CIDv0.
-   *
-   * @template {unknown} [T=unknown]
-   * @param {API.MultihashDigest<typeof SHA_256_CODE>} digest - Multihash.
-   * @returns {CID<T, typeof DAG_PB_CODE, typeof SHA_256_CODE, 0>}
-   */
-  static createV0(digest) {
-    return _CID.create(0, DAG_PB_CODE, digest);
-  }
-  /**
-   * Simplified version of `create` for CIDv1.
-   *
-   * @template {unknown} Data
-   * @template {number} Code
-   * @template {number} Alg
-   * @param {Code} code - Content encoding format code.
-   * @param {API.MultihashDigest<Alg>} digest - Miltihash of the content.
-   * @returns {CID<Data, Code, Alg, 1>}
-   */
-  static createV1(code2, digest) {
-    return _CID.create(1, code2, digest);
-  }
-  /**
-   * Decoded a CID from its binary representation. The byte array must contain
-   * only the CID with no additional bytes.
-   *
-   * An error will be thrown if the bytes provided do not contain a valid
-   * binary representation of a CID.
-   *
-   * @template {unknown} Data
-   * @template {number} Code
-   * @template {number} Alg
-   * @template {API.Version} Ver
-   * @param {API.ByteView<API.Link<Data, Code, Alg, Ver>>} bytes
-   * @returns {CID<Data, Code, Alg, Ver>}
-   */
-  static decode(bytes2) {
-    const [cid, remainder] = _CID.decodeFirst(bytes2);
-    if (remainder.length) {
-      throw new Error("Incorrect length");
-    }
-    return cid;
-  }
-  /**
-   * Decoded a CID from its binary representation at the beginning of a byte
-   * array.
-   *
-   * Returns an array with the first element containing the CID and the second
-   * element containing the remainder of the original byte array. The remainder
-   * will be a zero-length byte array if the provided bytes only contained a
-   * binary CID representation.
-   *
-   * @template {unknown} T
-   * @template {number} C
-   * @template {number} A
-   * @template {API.Version} V
-   * @param {API.ByteView<API.Link<T, C, A, V>>} bytes
-   * @returns {[CID<T, C, A, V>, Uint8Array]}
-   */
-  static decodeFirst(bytes2) {
-    const specs = _CID.inspectBytes(bytes2);
-    const prefixSize = specs.size - specs.multihashSize;
-    const multihashBytes = coerce(
-      bytes2.subarray(prefixSize, prefixSize + specs.multihashSize)
-    );
-    if (multihashBytes.byteLength !== specs.multihashSize) {
-      throw new Error("Incorrect length");
-    }
-    const digestBytes = multihashBytes.subarray(
-      specs.multihashSize - specs.digestSize
-    );
-    const digest = new Digest(
-      specs.multihashCode,
-      specs.digestSize,
-      digestBytes,
-      multihashBytes
-    );
-    const cid = specs.version === 0 ? _CID.createV0(
-      /** @type {API.MultihashDigest<API.SHA_256>} */
-      digest
-    ) : _CID.createV1(specs.codec, digest);
-    return [
-      /** @type {CID<T, C, A, V>} */
-      cid,
-      bytes2.subarray(specs.size)
-    ];
-  }
-  /**
-   * Inspect the initial bytes of a CID to determine its properties.
-   *
-   * Involves decoding up to 4 varints. Typically this will require only 4 to 6
-   * bytes but for larger multicodec code values and larger multihash digest
-   * lengths these varints can be quite large. It is recommended that at least
-   * 10 bytes be made available in the `initialBytes` argument for a complete
-   * inspection.
-   *
-   * @template {unknown} T
-   * @template {number} C
-   * @template {number} A
-   * @template {API.Version} V
-   * @param {API.ByteView<API.Link<T, C, A, V>>} initialBytes
-   * @returns {{ version:V, codec:C, multihashCode:A, digestSize:number, multihashSize:number, size:number }}
-   */
-  static inspectBytes(initialBytes) {
-    let offset = 0;
-    const next = () => {
-      const [i, length2] = decode5(initialBytes.subarray(offset));
-      offset += length2;
-      return i;
-    };
-    let version = (
-      /** @type {V} */
-      next()
-    );
-    let codec = (
-      /** @type {C} */
-      DAG_PB_CODE
-    );
-    if (
-      /** @type {number} */
-      version === 18
-    ) {
-      version = /** @type {V} */
-      0;
-      offset = 0;
-    } else {
-      codec = /** @type {C} */
-      next();
-    }
-    if (version !== 0 && version !== 1) {
-      throw new RangeError(`Invalid CID version ${version}`);
-    }
-    const prefixSize = offset;
-    const multihashCode = (
-      /** @type {A} */
-      next()
-    );
-    const digestSize = next();
-    const size = offset + digestSize;
-    const multihashSize = size - prefixSize;
-    return { version, codec, multihashCode, digestSize, multihashSize, size };
-  }
-  /**
-   * Takes cid in a string representation and creates an instance. If `base`
-   * decoder is not provided will use a default from the configuration. It will
-   * throw an error if encoding of the CID is not compatible with supplied (or
-   * a default decoder).
-   *
-   * @template {string} Prefix
-   * @template {unknown} Data
-   * @template {number} Code
-   * @template {number} Alg
-   * @template {API.Version} Ver
-   * @param {API.ToString<API.Link<Data, Code, Alg, Ver>, Prefix>} source
-   * @param {API.MultibaseDecoder<Prefix>} [base]
-   * @returns {CID<Data, Code, Alg, Ver>}
-   */
-  static parse(source, base2) {
-    const [prefix, bytes2] = parseCIDtoBytes(source, base2);
-    const cid = _CID.decode(bytes2);
-    if (cid.version === 0 && source[0] !== "Q") {
-      throw Error("Version 0 CID string must not include multibase prefix");
-    }
-    baseCache(cid).set(prefix, source);
-    return cid;
-  }
-};
-var parseCIDtoBytes = (source, base2) => {
-  switch (source[0]) {
-    case "Q": {
-      const decoder = base2 || base58btc;
-      return [
-        /** @type {Prefix} */
-        base58btc.prefix,
-        decoder.decode(`${base58btc.prefix}${source}`)
-      ];
-    }
-    case base58btc.prefix: {
-      const decoder = base2 || base58btc;
-      return [
-        /** @type {Prefix} */
-        base58btc.prefix,
-        decoder.decode(source)
-      ];
-    }
-    case base32.prefix: {
-      const decoder = base2 || base32;
-      return [
-        /** @type {Prefix} */
-        base32.prefix,
-        decoder.decode(source)
-      ];
-    }
-    default: {
-      if (base2 == null) {
-        throw Error(
-          "To parse non base32 or base58btc encoded CID multibase decoder must be provided"
-        );
-      }
-      return [
-        /** @type {Prefix} */
-        source[0],
-        base2.decode(source)
-      ];
-    }
-  }
-};
-var toStringV0 = (bytes2, 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(bytes2).slice(1);
-    cache2.set(prefix, cid2);
-    return cid2;
-  } else {
-    return cid;
-  }
-};
-var toStringV1 = (bytes2, cache2, base2) => {
-  const { prefix } = base2;
-  const cid = cache2.get(prefix);
-  if (cid == null) {
-    const cid2 = base2.encode(bytes2);
-    cache2.set(prefix, cid2);
-    return cid2;
-  } else {
-    return cid;
-  }
-};
-var DAG_PB_CODE = 112;
-var SHA_256_CODE = 18;
-var encodeCID = (version, code2, multihash) => {
-  const codeOffset = encodingLength(version);
-  const hashOffset = codeOffset + encodingLength(code2);
-  const bytes2 = new Uint8Array(hashOffset + multihash.byteLength);
-  encodeTo(version, bytes2, 0);
-  encodeTo(code2, bytes2, codeOffset);
-  bytes2.set(multihash, hashOffset);
-  return bytes2;
-};
-var cidSymbol = Symbol.for("@ipld/js-cid/CID");
-
-// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/hashes/hasher.js
-var from2 = ({ name: name2, code: code2, encode: encode7 }) => new Hasher(name2, code2, encode7);
-var Hasher = class {
-  /**
-   *
-   * @param {Name} name
-   * @param {Code} code
-   * @param {(input: Uint8Array) => Await<Uint8Array>} encode
-   */
-  constructor(name2, code2, encode7) {
-    this.name = name2;
-    this.code = code2;
-    this.encode = encode7;
-  }
-  /**
-   * @param {Uint8Array} input
-   * @returns {Await<Digest.Digest<Code, number>>}
-   */
-  digest(input) {
-    if (input instanceof Uint8Array) {
-      const result = this.encode(input);
-      return result instanceof Uint8Array ? create(this.code, result) : result.then((digest) => create(this.code, digest));
-    } else {
-      throw Error("Unknown type, must be binary type");
-    }
-  }
-};
-
-// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/bases/base64.js
-var base64 = rfc4648({
-  prefix: "m",
-  name: "base64",
-  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
-  bitsPerChar: 6
-});
-var base64pad = rfc4648({
-  prefix: "M",
-  name: "base64pad",
-  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
-  bitsPerChar: 6
-});
-var base64url = rfc4648({
-  prefix: "u",
-  name: "base64url",
-  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
-  bitsPerChar: 6
-});
-var base64urlpad = rfc4648({
-  prefix: "U",
-  name: "base64urlpad",
-  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=",
-  bitsPerChar: 6
-});
-
-// ../../../node_modules/.pnpm/@ipld+dag-json@10.1.5/node_modules/@ipld/dag-json/src/index.js
-function cidEncoder(obj) {
-  if (obj.asCID !== obj && obj["/"] !== obj.bytes) {
-    return null;
-  }
-  const cid = CID.asCID(obj);
-  if (!cid) {
-    return null;
-  }
-  const cidString = cid.toString();
-  return [
-    new Token(Type.map, Infinity, 1),
-    new Token(Type.string, "/", 1),
-    // key
-    new Token(Type.string, cidString, cidString.length),
-    // value
-    new Token(Type.break, void 0, 1)
-  ];
-}
-function bytesEncoder(bytes2) {
-  const bytesString = base64.encode(bytes2).slice(1);
-  return [
-    new Token(Type.map, Infinity, 1),
-    new Token(Type.string, "/", 1),
-    // key
-    new Token(Type.map, Infinity, 1),
-    // value
-    new Token(Type.string, "bytes", 5),
-    // inner key
-    new Token(Type.string, bytesString, bytesString.length),
-    // inner value
-    new Token(Type.break, void 0, 1),
-    new Token(Type.break, void 0, 1)
-  ];
-}
-function taBytesEncoder(obj) {
-  return bytesEncoder(new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength));
-}
-function abBytesEncoder(ab) {
-  return bytesEncoder(new Uint8Array(ab));
-}
-function undefinedEncoder() {
-  throw new Error("`undefined` is not supported by the IPLD Data Model and cannot be encoded");
-}
-function numberEncoder(num) {
-  if (Number.isNaN(num)) {
-    throw new Error("`NaN` is not supported by the IPLD Data Model and cannot be encoded");
-  }
-  if (num === Infinity || num === -Infinity) {
-    throw new Error("`Infinity` and `-Infinity` is not supported by the IPLD Data Model and cannot be encoded");
-  }
-  return null;
-}
-var encodeOptions = {
-  typeEncoders: {
-    Object: cidEncoder,
-    Buffer: bytesEncoder,
-    Uint8Array: bytesEncoder,
-    Int8Array: taBytesEncoder,
-    Uint16Array: taBytesEncoder,
-    Int16Array: taBytesEncoder,
-    Uint32Array: taBytesEncoder,
-    Int32Array: taBytesEncoder,
-    Float32Array: taBytesEncoder,
-    Float64Array: taBytesEncoder,
-    Uint8ClampedArray: taBytesEncoder,
-    BigInt64Array: taBytesEncoder,
-    BigUint64Array: taBytesEncoder,
-    DataView: taBytesEncoder,
-    ArrayBuffer: abBytesEncoder,
-    undefined: undefinedEncoder,
-    number: numberEncoder
-  }
-};
-var DagJsonTokenizer = class extends Tokenizer {
-  /**
-   * @param {Uint8Array} data
-   * @param {object} [options]
-   */
-  constructor(data, options) {
-    super(data, options);
-    this.tokenBuffer = [];
-  }
-  /**
-   * @returns {boolean}
-   */
-  done() {
-    return this.tokenBuffer.length === 0 && super.done();
-  }
-  /**
-   * @returns {Token}
-   */
-  _next() {
-    if (this.tokenBuffer.length > 0) {
-      return this.tokenBuffer.pop();
-    }
-    return super.next();
-  }
-  /**
-   * Implements rules outlined in https://github.com/ipld/specs/pull/356
-   *
-   * @returns {Token}
-   */
-  next() {
-    const token = this._next();
-    if (token.type === Type.map) {
-      const keyToken = this._next();
-      if (keyToken.type === Type.string && keyToken.value === "/") {
-        const valueToken = this._next();
-        if (valueToken.type === Type.string) {
-          const breakToken = this._next();
-          if (breakToken.type !== Type.break) {
-            throw new Error("Invalid encoded CID form");
-          }
-          this.tokenBuffer.push(valueToken);
-          return new Token(Type.tag, 42, 0);
-        }
-        if (valueToken.type === Type.map) {
-          const innerKeyToken = this._next();
-          if (innerKeyToken.type === Type.string && innerKeyToken.value === "bytes") {
-            const innerValueToken = this._next();
-            if (innerValueToken.type === Type.string) {
-              for (let i = 0; i < 2; i++) {
-                const breakToken = this._next();
-                if (breakToken.type !== Type.break) {
-                  throw new Error("Invalid encoded Bytes form");
-                }
-              }
-              const bytes2 = base64.decode(`m${innerValueToken.value}`);
-              return new Token(Type.bytes, bytes2, innerValueToken.value.length);
-            }
-            this.tokenBuffer.push(innerValueToken);
-          }
-          this.tokenBuffer.push(innerKeyToken);
-        }
-        this.tokenBuffer.push(valueToken);
-      }
-      this.tokenBuffer.push(keyToken);
-    }
-    return token;
-  }
-};
-var decodeOptions = {
-  allowIndefinite: false,
-  allowUndefined: false,
-  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[42] = CID.parse;
-var name = "dag-json";
-var code = 297;
-var encode5 = (node) => encode2(node, encodeOptions);
-var decode7 = (data) => {
-  const options = Object.assign(decodeOptions, { tokenizer: new DagJsonTokenizer(data, decodeOptions) });
-  return decode2(data, options);
-};
-var format2 = (node) => utf8Decoder.decode(encode5(node));
-var utf8Decoder = new TextDecoder();
-var parse = (data) => decode7(utf8Encoder.encode(data));
-var utf8Encoder = new TextEncoder();
-
-// ../../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/_assert.js
-function bytes(b, ...lengths) {
-  if (!(b instanceof Uint8Array))
-    throw new Error("Expected Uint8Array");
-  if (lengths.length > 0 && !lengths.includes(b.length))
-    throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
-}
-function exists(instance, checkFinished = true) {
-  if (instance.destroyed)
-    throw new Error("Hash instance has been destroyed");
-  if (checkFinished && instance.finished)
-    throw new Error("Hash#digest() has already been called");
-}
-function output(out, instance) {
-  bytes(out);
-  const min = instance.outputLen;
-  if (out.length < min) {
-    throw new Error(`digestInto() expects output buffer of length at least ${min}`);
-  }
-}
-
-// ../../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/utils.js
-var u8a = (a) => a instanceof Uint8Array;
-var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-var rotr = (word, shift) => word << 32 - shift | word >>> shift;
-var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
-if (!isLE)
-  throw new Error("Non little-endian hardware is not supported");
-function utf8ToBytes2(str) {
-  if (typeof str !== "string")
-    throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
-  return new Uint8Array(new TextEncoder().encode(str));
-}
-function toBytes(data) {
-  if (typeof data === "string")
-    data = utf8ToBytes2(data);
-  if (!u8a(data))
-    throw new Error(`expected Uint8Array, got ${typeof data}`);
-  return data;
-}
-var Hash = class {
-  // Safe version that clones internal state
-  clone() {
-    return this._cloneInto();
-  }
-};
-var toStr = {}.toString;
-function wrapConstructor(hashCons) {
-  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
-  const tmp = hashCons();
-  hashC.outputLen = tmp.outputLen;
-  hashC.blockLen = tmp.blockLen;
-  hashC.create = () => hashCons();
-  return hashC;
-}
-
-// ../../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/_sha2.js
-function setBigUint64(view, byteOffset, value, isLE2) {
-  if (typeof view.setBigUint64 === "function")
-    return view.setBigUint64(byteOffset, value, isLE2);
-  const _32n = BigInt(32);
-  const _u32_max = BigInt(4294967295);
-  const wh = Number(value >> _32n & _u32_max);
-  const wl = Number(value & _u32_max);
-  const h = isLE2 ? 4 : 0;
-  const l = isLE2 ? 0 : 4;
-  view.setUint32(byteOffset + h, wh, isLE2);
-  view.setUint32(byteOffset + l, wl, isLE2);
-}
-var SHA2 = class extends Hash {
-  constructor(blockLen, outputLen, padOffset, isLE2) {
-    super();
-    this.blockLen = blockLen;
-    this.outputLen = outputLen;
-    this.padOffset = padOffset;
-    this.isLE = isLE2;
-    this.finished = false;
-    this.length = 0;
-    this.pos = 0;
-    this.destroyed = false;
-    this.buffer = new Uint8Array(blockLen);
-    this.view = createView(this.buffer);
-  }
-  update(data) {
-    exists(this);
-    const { view, buffer: buffer2, blockLen } = this;
-    data = toBytes(data);
-    const len = data.length;
-    for (let pos = 0; pos < len; ) {
-      const take = Math.min(blockLen - this.pos, len - pos);
-      if (take === blockLen) {
-        const dataView2 = createView(data);
-        for (; blockLen <= len - pos; pos += blockLen)
-          this.process(dataView2, pos);
-        continue;
-      }
-      buffer2.set(data.subarray(pos, pos + take), this.pos);
-      this.pos += take;
-      pos += take;
-      if (this.pos === blockLen) {
-        this.process(view, 0);
-        this.pos = 0;
-      }
-    }
-    this.length += data.length;
-    this.roundClean();
-    return this;
-  }
-  digestInto(out) {
-    exists(this);
-    output(out, this);
-    this.finished = true;
-    const { buffer: buffer2, view, blockLen, isLE: isLE2 } = this;
-    let { pos } = this;
-    buffer2[pos++] = 128;
-    this.buffer.subarray(pos).fill(0);
-    if (this.padOffset > blockLen - pos) {
-      this.process(view, 0);
-      pos = 0;
-    }
-    for (let i = pos; i < blockLen; i++)
-      buffer2[i] = 0;
-    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
-    this.process(view, 0);
-    const oview = createView(out);
-    const len = this.outputLen;
-    if (len % 4)
-      throw new Error("_sha2: outputLen should be aligned to 32bit");
-    const outLen = len / 4;
-    const state = this.get();
-    if (outLen > state.length)
-      throw new Error("_sha2: outputLen bigger than state");
-    for (let i = 0; i < outLen; i++)
-      oview.setUint32(4 * i, state[i], isLE2);
-  }
-  digest() {
-    const { buffer: buffer2, outputLen } = this;
-    this.digestInto(buffer2);
-    const res = buffer2.slice(0, outputLen);
-    this.destroy();
-    return res;
-  }
-  _cloneInto(to) {
-    to || (to = new this.constructor());
-    to.set(...this.get());
-    const { blockLen, buffer: buffer2, length: length2, finished, destroyed, pos } = this;
-    to.length = length2;
-    to.pos = pos;
-    to.finished = finished;
-    to.destroyed = destroyed;
-    if (length2 % blockLen)
-      to.buffer.set(buffer2);
-    return to;
-  }
-};
-
-// ../../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/sha256.js
-var Chi = (a, b, c) => a & b ^ ~a & c;
-var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
-var SHA256_K = /* @__PURE__ */ new Uint32Array([
-  1116352408,
-  1899447441,
-  3049323471,
-  3921009573,
-  961987163,
-  1508970993,
-  2453635748,
-  2870763221,
-  3624381080,
-  310598401,
-  607225278,
-  1426881987,
-  1925078388,
-  2162078206,
-  2614888103,
-  3248222580,
-  3835390401,
-  4022224774,
-  264347078,
-  604807628,
-  770255983,
-  1249150122,
-  1555081692,
-  1996064986,
-  2554220882,
-  2821834349,
-  2952996808,
-  3210313671,
-  3336571891,
-  3584528711,
-  113926993,
-  338241895,
-  666307205,
-  773529912,
-  1294757372,
-  1396182291,
-  1695183700,
-  1986661051,
-  2177026350,
-  2456956037,
-  2730485921,
-  2820302411,
-  3259730800,
-  3345764771,
-  3516065817,
-  3600352804,
-  4094571909,
-  275423344,
-  430227734,
-  506948616,
-  659060556,
-  883997877,
-  958139571,
-  1322822218,
-  1537002063,
-  1747873779,
-  1955562222,
-  2024104815,
-  2227730452,
-  2361852424,
-  2428436474,
-  2756734187,
-  3204031479,
-  3329325298
-]);
-var IV = /* @__PURE__ */ new Uint32Array([
-  1779033703,
-  3144134277,
-  1013904242,
-  2773480762,
-  1359893119,
-  2600822924,
-  528734635,
-  1541459225
-]);
-var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-var SHA256 = class extends SHA2 {
-  constructor() {
-    super(64, 32, 8, false);
-    this.A = IV[0] | 0;
-    this.B = IV[1] | 0;
-    this.C = IV[2] | 0;
-    this.D = IV[3] | 0;
-    this.E = IV[4] | 0;
-    this.F = IV[5] | 0;
-    this.G = IV[6] | 0;
-    this.H = IV[7] | 0;
-  }
-  get() {
-    const { A, B, C, D, E, F, G, H } = this;
-    return [A, B, C, D, E, F, G, H];
-  }
-  // prettier-ignore
-  set(A, B, C, D, E, F, G, H) {
-    this.A = A | 0;
-    this.B = B | 0;
-    this.C = C | 0;
-    this.D = D | 0;
-    this.E = E | 0;
-    this.F = F | 0;
-    this.G = G | 0;
-    this.H = H | 0;
-  }
-  process(view, offset) {
-    for (let i = 0; i < 16; i++, offset += 4)
-      SHA256_W[i] = view.getUint32(offset, false);
-    for (let i = 16; i < 64; i++) {
-      const W15 = SHA256_W[i - 15];
-      const W2 = SHA256_W[i - 2];
-      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
-      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
-      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
-    }
-    let { A, B, C, D, E, F, G, H } = this;
-    for (let i = 0; i < 64; i++) {
-      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
-      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
-      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
-      const T2 = sigma0 + Maj(A, B, C) | 0;
-      H = G;
-      G = F;
-      F = E;
-      E = D + T1 | 0;
-      D = C;
-      C = B;
-      B = A;
-      A = T1 + T2 | 0;
-    }
-    A = A + this.A | 0;
-    B = B + this.B | 0;
-    C = C + this.C | 0;
-    D = D + this.D | 0;
-    E = E + this.E | 0;
-    F = F + this.F | 0;
-    G = G + this.G | 0;
-    H = H + this.H | 0;
-    this.set(A, B, C, D, E, F, G, H);
-  }
-  roundClean() {
-    SHA256_W.fill(0);
-  }
-  destroy() {
-    this.set(0, 0, 0, 0, 0, 0, 0, 0);
-    this.buffer.fill(0);
-  }
-};
-var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
-
-// ../../../node_modules/.pnpm/besonders-logger@1.0.0-RC11_3myifxmc6j23mthq5k5h6wvx4a/node_modules/besonders-logger/dist/src/index.mjs
-var __create2 = Object.create;
-var __defProp2 = Object.defineProperty;
-var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames2 = Object.getOwnPropertyNames;
-var __getProtoOf2 = Object.getPrototypeOf;
-var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __commonJS2 = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps2 = (to, from3, except, desc) => {
-  if (from3 && typeof from3 === "object" || typeof from3 === "function") {
-    for (let key of __getOwnPropNames2(from3))
-      if (!__hasOwnProp2.call(to, key) && key !== except)
-        __defProp2(to, key, { get: () => from3[key], enumerable: !(desc = __getOwnPropDesc2(from3, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-var require_lib = __commonJS2({
-  "../../node_modules/.pnpm/browser-or-node@2.1.1/node_modules/browser-or-node/lib/index.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
-      return typeof obj;
-    } : function(obj) {
-      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-    };
-    var isBrowser2 = typeof window !== "undefined" && typeof window.document !== "undefined";
-    var isNode2 = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-    var isWebWorker = (typeof self === "undefined" ? "undefined" : _typeof(self)) === "object" && self.constructor && self.constructor.name === "DedicatedWorkerGlobalScope";
-    var isJsDom = typeof window !== "undefined" && window.name === "nodejs" || typeof navigator !== "undefined" && (navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom"));
-    var isDeno = typeof Deno !== "undefined" && typeof Deno.version !== "undefined" && typeof Deno.version.deno !== "undefined";
-    exports.isBrowser = isBrowser2;
-    exports.isWebWorker = isWebWorker;
-    exports.isNode = isNode2;
-    exports.isJsDom = isJsDom;
-    exports.isDeno = isDeno;
-  }
-});
-var require_fast_json_stable_stringify = __commonJS2({
-  "../../node_modules/.pnpm/fast-json-stable-stringify@2.1.0/node_modules/fast-json-stable-stringify/index.js"(exports, module) {
-    "use strict";
-    module.exports = function(data, opts) {
-      if (!opts)
-        opts = {};
-      if (typeof opts === "function")
-        opts = { cmp: opts };
-      var cycles = typeof opts.cycles === "boolean" ? opts.cycles : false;
-      var cmp = opts.cmp && /* @__PURE__ */ function(f) {
-        return function(node) {
-          return function(a, b) {
-            var aobj = { key: a, value: node[a] };
-            var bobj = { key: b, value: node[b] };
-            return f(aobj, bobj);
-          };
-        };
-      }(opts.cmp);
-      var seen = [];
-      return function stringify2(node) {
-        if (node && node.toJSON && typeof node.toJSON === "function") {
-          node = node.toJSON();
-        }
-        if (node === void 0)
-          return;
-        if (typeof node == "number")
-          return isFinite(node) ? "" + node : "null";
-        if (typeof node !== "object")
-          return JSON.stringify(node);
-        var i, out;
-        if (Array.isArray(node)) {
-          out = "[";
-          for (i = 0; i < node.length; i++) {
-            if (i)
-              out += ",";
-            out += stringify2(node[i]) || "null";
-          }
-          return out + "]";
-        }
-        if (node === null)
-          return "null";
-        if (seen.indexOf(node) !== -1) {
-          if (cycles)
-            return JSON.stringify("__cycle__");
-          throw new TypeError("Converting circular structure to JSON");
-        }
-        var seenIndex = seen.push(node) - 1;
-        var keys = Object.keys(node).sort(cmp && cmp(node));
-        out = "";
-        for (i = 0; i < keys.length; i++) {
-          var key = keys[i];
-          var value = stringify2(node[key]);
-          if (!value)
-            continue;
-          if (out)
-            out += ",";
-          out += JSON.stringify(key) + ":" + value;
-        }
-        seen.splice(seenIndex, 1);
-        return "{" + out + "}";
-      }(data);
-    };
-  }
-});
-var import_browser_or_node = __toESM2(require_lib(), 1);
-var import_fast_json_stable_stringify = __toESM2(require_fast_json_stable_stringify(), 1);
-var TIME_PREFIX_ENABLED = false;
-var PERFORMANCE_PREFIX_ENABLED = false;
-if (import_browser_or_node.isNode) {
-  if (process?.env?.LOGGER_TIME_PREFIX)
-    TIME_PREFIX_ENABLED = process?.env?.LOGGER_TIME_PREFIX === "true";
-  if (process?.env?.LOGGER_PERF_PREFIX)
-    PERFORMANCE_PREFIX_ENABLED = process?.env?.LOGGER_PERF_PREFIX === "true";
-}
-var DEFAULT_CONFIG = Object.freeze({
-  prefix: void 0,
-  time: TIME_PREFIX_ENABLED,
-  delta: PERFORMANCE_PREFIX_ENABLED,
-  dimDebugOnServer: true,
-  printOriginOnServer: true,
-  serverInspectOptions: {},
-  customFormattersOnServer: true,
-  // Depth of stacktrace to show on server
-  // - integer saying how many lines
-  // - false to disable, true for all
-  printStackLinesOnServer: false,
-  dim: true
-});
-var StringFormatters = [
-  // Format to string (Client console - currently not on server)
-  // {
-  //   match: obj => obj instanceof Model,
-  //   format: m => {
-  //     const { displayName } = m
-  //     return `${m.constructor.name}#${m.ID}${displayName ? `{${displayName}}` : ''}`
-  //   },
-  // },
-];
-var LoggerTime = class {
-  sinceFirst = 0;
-  sinceLast = 0;
-  time = false;
-  delta = false;
-  constructor(sinceFirst, sinceLast, time, delta) {
-    Object.assign(this, { sinceFirst, sinceLast, time, delta });
-  }
-  toString() {
-    const sinceFirstNum = this.sinceFirst * 1e-3;
-    const sinceFirst = sinceFirstNum.toFixed(sinceFirstNum < 5 ? 2 : 1);
-    const sinceLast = this.sinceLast < 1e3 ? `${this.sinceLast.toFixed(0)}`.padStart(5, " ") : `${`${(this.sinceLast * 1e-3).toFixed(this.sinceLast < 1e4 ? 1 : 0)}`.padStart(4, " ")}s`;
-    return `[${[this.time ? sinceFirst : null, this.delta ? sinceLast : null].join(",")}]`;
-  }
-};
-var Style = class {
-  constructor(style, string) {
-    Object.assign(this, { style, string });
-  }
-};
-var formattersEnabled = false;
-var _Logger = class {
-  /**
-   * This is a clever way to log without the extra check on each log line.
-   * Use it like this:
-   * ```
-   * const { WARN, LOG, DEBUG, VERBOSE } = Logger.setup(Logger.INFO); // eslint-disable-line no-unused-vars
-   * LOG('message', data);
-   * DEBUG(this.collectionName, '...')
-   * if (!VERBOSE.isDisabled) {
-   *   const verboseStuff = generateVerboseStuff(); // computationally intensive
-   *   VERBOSE('Here it is:', verboseStuff)
-   * }
-   * ```
-   *
-   * @ param {number} level See {@link LVs}
-   * @ param {object} config see DEFAULT_CONFIG
-   * @ typedef {Function & {isDisabled: boolean, isEnabled: boolean, ...}} LogFunc
-   * @ returns {{LOG: LogFunc, VERBOSE: LogFunc, DEBUG: LogFunc, WARN: LogFunc, ERROR: LogFunc}}
-   */
-  static setup(level = _Logger.INFO, config = {}) {
-    config = Object.assign({}, DEFAULT_CONFIG, config);
-    if (level > 10)
-      console.debug("setup logger", { config });
-    const debugLogForStub = this.wrapLog(console.debug, { ...config, dim: config.dimDebugOnServer });
-    const stub = (...args) => {
-      if (window?.FORCE_DISABLE_LOGLEVEL)
-        debugLogForStub(...args);
-    };
-    stub.isDisabled = true;
-    stub.isEnabled = false;
-    const groupCollapsed = this.wrapLog(console.groupCollapsed, config);
-    const addExtraFxs = (enabled, func) => {
-      function group(...args) {
-        const functionToWrap = args[args.length - 1];
-        if (functionToWrap === stub)
-          return functionToWrap();
-        groupCollapsed(...args.slice(0, -1));
-        const asyncWrapper = async () => {
-          try {
-            const result = functionToWrap();
-            return result instanceof Promise ? await result : result;
-          } finally {
-            console.groupEnd();
-          }
-        };
-        return asyncWrapper();
-      }
-      const realFunc = Object.assign(
-        func.bind({}),
-        // clone function - https://stackoverflow.com/a/6772648
-        {
-          isEnabled: enabled,
-          isDisabled: !enabled,
-          group,
-          force: func
-        }
-      );
-      if (enabled) {
-        return realFunc;
-      } else {
-        return Object.assign(
-          stub.bind({}),
-          // clone stub function - https://stackoverflow.com/a/6772648
-          {
-            isEnabled: enabled,
-            isDisabled: !enabled,
-            group,
-            force: realFunc
-          }
-        );
-      }
-    };
-    const ERRFX = addExtraFxs(level >= _Logger.ERROR, this.wrapLog(console.error, config));
-    const ERROR2 = (...params) => {
-      ERRFX(...params);
-      return new Error((0, import_fast_json_stable_stringify.default)(params));
-    };
-    return {
-      ERROR: ERROR2,
-      WARN: addExtraFxs(level >= _Logger.WARN, this.wrapLog(console.warn, config)),
-      LOG: addExtraFxs(level >= _Logger.INFO, this.wrapLog(console.log, config)),
-      DEBUG: addExtraFxs(level >= _Logger.DEBUG, this.wrapLog(console.log, { ...config, dim: config.dimDebugOnServer })),
-      // not using console.debug as that requires dev tools verbose to be enabled
-      VERBOSE: addExtraFxs(level >= _Logger.VERBOSE, this.wrapLog(console.debug, { ...config, dim: config.dimDebugOnServer }))
-    };
-  }
-  static wrapLog(logFunc, config) {
-    if (!import_browser_or_node.isNode) {
-      const fixedArgs = [];
-      if (config.time || config.delta) {
-        const isChrome = import_browser_or_node.isBrowser && navigator.userAgent.includes("Chrome");
-        const p = isChrome ? ["", _Logger.timeStr(!!config.time, !!config.delta)] : [];
-        fixedArgs.push(...p);
-      }
-      if (config.prefix) {
-        if (formattersEnabled)
-          fixedArgs.push(new Style("dim", config.prefix));
-        else
-          fixedArgs.push(config.prefix);
-      }
-      return logFunc.bind(console, ...fixedArgs);
-    } else {
-      return logFunc.bind(console);
-    }
-  }
-  // static log(msg, logPerformance = true) {
-  //   const p = this.perf();
-  //   return logPerformance ? `${p} ${msg}` : msg;
-  // }
-  static timeStr(time, delta, returnAsString = 0) {
-    if (!performance.now)
-      return void 0;
-    const now = performance.now();
-    if (!_Logger.firstLog) {
-      _Logger.firstLog = now;
-      _Logger.lastLog = now;
-    }
-    const p = new LoggerTime(now - _Logger.firstLog, now - _Logger.lastLog, time, delta);
-    _Logger.lastLog = now;
-    return returnAsString ? p.toString() : p;
-  }
-  // (for nodejs) ~ https://stackoverflow.com/a/47296370/1633985
-  static getOriginFromStack(stack) {
-    let skippedFirst = false;
-    for (const line of stack.split("\n")) {
-      const matches = line.match(/^\s+at\s+(.*)/);
-      if (matches) {
-        if (skippedFirst) {
-          return matches[1].trim().replace(__dirname, "");
-        }
-        skippedFirst = true;
-      }
-    }
-  }
-};
-var Logger = _Logger;
-__publicField(Logger, "ERROR", 2);
-__publicField(Logger, "WARN", 4);
-__publicField(Logger, "INFO", 6);
-__publicField(Logger, "LOG", 6);
-__publicField(Logger, "DEBUG", 8);
-__publicField(Logger, "VERBOSE", 10);
-__publicField(Logger, "firstLog", 0);
-__publicField(Logger, "lastLog", 0);
-if (import_browser_or_node.isBrowser) {
-  window.devtoolsFormatters = window.devtoolsFormatters ?? [];
-  window.devtoolsFormatters.push(
-    {
-      // Custom formatters
-      header: (obj) => {
-        if (StringFormatters && StringFormatters.length) {
-          for (const formatter of StringFormatters) {
-            if (formatter.match(obj))
-              return ["span", {}, formatter.format(obj)];
-          }
-        }
-        return null;
-      },
-      hasBody: () => true
-    },
-    {
-      // Performance object //
-      // This is a sneaky way to show performance info withouth any extra calls when logging:
-      // LOG(`...`)
-      // it would work without this if we would have some way to intercept the call:
-      // L.INFO('...') - a getter on L that adds the current time as prefix
-      // LOG('...')() - returns the log function with all argumends bound
-      // But instead we are adding a custom formatter that replaced the placeholder object of class P with the performance info
-      header: (obj) => {
-        if (!(obj instanceof LoggerTime))
-          return null;
-        if (!formattersEnabled)
-          formattersEnabled = true;
-        const p = Logger.timeStr(obj.time, obj.delta);
-        return [
-          "span",
-          { style: "font-weight: light; color: grey" },
-          p?.toString()
-          // ['a', { href: 'vscodium://file/home/manu/dev/tamera/bookr/imports/lib/utils/Logger.js' }, 'WOW'],
-        ];
-      },
-      hasBody: () => false
-    },
-    {
-      // Style object
-      header: (obj) => {
-        if (!(obj instanceof Style))
-          return null;
-        if (!formattersEnabled)
-          formattersEnabled = true;
-        return ["span", {
-          style: "font-weight: light; color: grey; "
-          /* font-style: italic; */
-        }, obj.string];
-      },
-      hasBody: () => false
-    }
-  );
-} else if (import_browser_or_node.isNode) {
-}
-
-// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/block.js
-function readonly({ enumerable = true, configurable = false } = {}) {
-  return { enumerable, configurable, writable: false };
-}
-function* linksWithin(path, value) {
-  if (value != null && typeof value === "object") {
-    if (Array.isArray(value)) {
-      for (const [index, element] of value.entries()) {
-        const elementPath = [...path, index];
-        const cid = CID.asCID(element);
-        if (cid) {
-          yield [elementPath.join("/"), cid];
-        } else if (typeof element === "object") {
-          yield* links(element, elementPath);
-        }
-      }
-    } else {
-      const cid = CID.asCID(value);
-      if (cid) {
-        yield [path.join("/"), cid];
-      } else {
-        yield* links(value, path);
-      }
-    }
-  }
-}
-function* links(source, base2) {
-  if (source == null || source instanceof Uint8Array) {
-    return;
-  }
-  const cid = CID.asCID(source);
-  if (cid) {
-    yield [base2.join("/"), cid];
-  }
-  for (const [key, value] of Object.entries(source)) {
-    const path = (
-      /** @type {[string|number, string]} */
-      [...base2, key]
-    );
-    yield* linksWithin(path, value);
-  }
-}
-function* treeWithin(path, value) {
-  if (Array.isArray(value)) {
-    for (const [index, element] of value.entries()) {
-      const elementPath = [...path, index];
-      yield elementPath.join("/");
-      if (typeof element === "object" && !CID.asCID(element)) {
-        yield* tree(element, elementPath);
-      }
-    }
-  } else {
-    yield* tree(value, path);
-  }
-}
-function* tree(source, base2) {
-  if (source == null || typeof source !== "object") {
-    return;
-  }
-  for (const [key, value] of Object.entries(source)) {
-    const path = (
-      /** @type {[string|number, string]} */
-      [...base2, key]
-    );
-    yield path.join("/");
-    if (value != null && !(value instanceof Uint8Array) && typeof value === "object" && !CID.asCID(value)) {
-      yield* treeWithin(path, value);
-    }
-  }
-}
-function get(source, path) {
-  let node = (
-    /** @type {Record<string, any>} */
-    source
-  );
-  for (const [index, key] of path.entries()) {
-    node = node[key];
-    if (node == null) {
-      throw new Error(`Object has no property at ${path.slice(0, index + 1).map((part) => `[${JSON.stringify(part)}]`).join("")}`);
-    }
-    const cid = CID.asCID(node);
-    if (cid) {
-      return { value: cid, remaining: path.slice(index + 1).join("/") };
-    }
-  }
-  return { value: node };
-}
-var Block = class {
-  /**
-   * @param {object} options
-   * @param {CID<T, C, A, V>} options.cid
-   * @param {API.ByteView<T>} options.bytes
-   * @param {T} options.value
-   */
-  constructor({ cid, bytes: bytes2, value }) {
-    if (!cid || !bytes2 || typeof value === "undefined") {
-      throw new Error("Missing required argument");
-    }
-    this.cid = cid;
-    this.bytes = bytes2;
-    this.value = value;
-    this.asBlock = this;
-    Object.defineProperties(this, {
-      cid: readonly(),
-      bytes: readonly(),
-      value: readonly(),
-      asBlock: readonly()
-    });
-  }
-  links() {
-    return links(this.value, []);
-  }
-  tree() {
-    return tree(this.value, []);
-  }
-  /**
-   *
-   * @param {string} [path]
-   * @returns {API.BlockCursorView<unknown>}
-   */
-  get(path = "/") {
-    return get(this.value, path.split("/").filter(Boolean));
-  }
-};
-async function encode6({ value, codec, hasher }) {
-  if (typeof value === "undefined")
-    throw new Error('Missing required argument "value"');
-  if (!codec || !hasher)
-    throw new Error("Missing required argument: codec or hasher");
-  const bytes2 = codec.encode(value);
-  const hash = await hasher.digest(bytes2);
-  const cid = CID.create(
-    1,
-    codec.code,
-    hash
-  );
-  return new Block({ value, bytes: bytes2, cid });
-}
-
-// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/hashes/sha2-browser.js
-var sha = (name2) => (
-  /**
-   * @param {Uint8Array} data
-   */
-  async (data) => new Uint8Array(await crypto.subtle.digest(name2, data))
-);
-var sha2562 = from2({
-  name: "sha2-256",
-  code: 18,
-  encode: sha("SHA-256")
-});
-var sha512 = from2({
-  name: "sha2-512",
-  code: 19,
-  encode: sha("SHA-512")
-});
-
-// src/ipfs/ipfs-utils.ts
-var { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO);
-function prepareForPub(log, without = ["cid"]) {
-  const logWithout = {};
-  for (let [key, val] of Object.entries(log)) {
-    if (val === void 0) {
-      WARN(`log.${key} is undefined, which is not allowed - encoding as null`, log);
-      val = null;
-    }
-    if (!without.includes(key)) {
-      logWithout[key] = val && key === "pv" ? CID.parse(val) : val;
-    } else {
-      VERBOSE("excluding app log", { key, val });
-    }
-  }
-  return logWithout;
-}
-function encodeApplogAndGetCid(log) {
-  return getCidSync(encodeApplog(log).bytes);
-}
-function encodeApplog(log) {
-  return encodeBlock(prepareForPub(log));
-}
-function getCidSync(bytes2) {
-  const hash = sha256(bytes2);
-  const digest = digest_exports.create(sha2562.code, hash);
-  const cid = CID.create(1, code, digest);
-  VERBOSE(`[getCidSync]`, { bytes: bytes2, hash, digest, cid });
-  return cid;
-}
-function encodeBlock(jsonObject) {
-  DEBUG("[encodeBlock]", jsonObject);
-  const byteView = encode5(jsonObject);
-  return { bytes: byteView, cid: getCidSync(byteView) };
-}
-async function encodeBlockOriginal(jsonObject) {
-  const encoded = await encode6({ value: jsonObject, codec: src_exports, hasher: sha2562 });
-  const syncVariant = encodeBlock(jsonObject);
-  if (syncVariant.cid.toString() !== encoded.cid.toString()) {
-    ERROR(`[encodeBlockOriginal] sync cid mismatch`, { jsonObject, encoded, syncVariant });
-  }
-  return encoded;
-}
-
-export {
-  __commonJS,
-  __toESM,
-  Logger,
-  Type,
-  Token,
-  makeCborEncoders,
-  encode,
-  decode,
-  decode6 as decode2,
-  CID,
-  decode7 as decode3,
-  prepareForPub,
-  encodeApplogAndGetCid,
-  encodeApplog,
-  getCidSync,
-  encodeBlock,
-  encodeBlockOriginal
-};
-/*! Bundled license information:
-
-@noble/hashes/esm/utils.js:
-  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-*/
-//# sourceMappingURL=chunk-WOD425XV.min.js.map