@wovin/core 0.0.4 → 0.0.6

package/dist/chunk-2UCPKUQK.min.js

@@ -1,1256 +0,0 @@
-import {
-  CID,
-  Logger,
-  Token,
-  Type,
-  __commonJS,
-  __toESM,
-  decode,
-  decode2,
-  decode3,
-  encode,
-  makeCborEncoders
-} from "./chunk-WOD425XV.min.js";
-
-// ../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/encode.js
-var require_encode = __commonJS({
-  "../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/encode.js"(exports, module) {
-    "use strict";
-    module.exports = encode3;
-    var MSB = 128;
-    var REST = 127;
-    var MSBALL = ~REST;
-    var INT = Math.pow(2, 31);
-    function encode3(num, out, offset) {
-      if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
-        encode3.bytes = 0;
-        throw new RangeError("Could not encode varint");
-      }
-      out = out || [];
-      offset = offset || 0;
-      var oldOffset = offset;
-      while (num >= INT) {
-        out[offset++] = num & 255 | MSB;
-        num /= 128;
-      }
-      while (num & MSBALL) {
-        out[offset++] = num & 255 | MSB;
-        num >>>= 7;
-      }
-      out[offset] = num | 0;
-      encode3.bytes = offset - oldOffset + 1;
-      return out;
-    }
-  }
-});
-
-// ../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/decode.js
-var require_decode = __commonJS({
-  "../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/decode.js"(exports, module) {
-    "use strict";
-    module.exports = read;
-    var MSB = 128;
-    var REST = 127;
-    function read(buf, offset) {
-      var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
-      do {
-        if (counter >= l || shift > 49) {
-          read.bytes = 0;
-          throw new RangeError("Could not decode varint");
-        }
-        b = buf[counter++];
-        res += shift < 28 ? (b & REST) << shift : (b & REST) * Math.pow(2, shift);
-        shift += 7;
-      } while (b >= MSB);
-      read.bytes = counter - offset;
-      return res;
-    }
-  }
-});
-
-// ../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/length.js
-var require_length = __commonJS({
-  "../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/length.js"(exports, module) {
-    "use strict";
-    var 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);
-    module.exports = 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;
-    };
-  }
-});
-
-// ../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/index.js
-var require_varint = __commonJS({
-  "../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/index.js"(exports, module) {
-    "use strict";
-    module.exports = {
-      encode: require_encode(),
-      decode: require_decode(),
-      encodingLength: require_length()
-    };
-  }
-});
-
-// ../../../node_modules/.pnpm/@ipld+dag-cbor@9.0.6/node_modules/@ipld/dag-cbor/src/index.js
-var CID_CBOR_TAG = 42;
-function cidEncoder(obj) {
-  if (obj.asCID !== obj && obj["/"] !== obj.bytes) {
-    return null;
-  }
-  const cid = CID.asCID(obj);
-  if (!cid) {
-    return null;
-  }
-  const bytes = new Uint8Array(cid.bytes.byteLength + 1);
-  bytes.set(cid.bytes, 1);
-  return [
-    new Token(Type.tag, CID_CBOR_TAG),
-    new Token(Type.bytes, bytes)
-  ];
-}
-function undefinedEncoder() {
-  throw new Error("`undefined` is not supported by the IPLD Data Model and cannot be encoded");
-}
-function numberEncoder(num) {
-  if (Number.isNaN(num)) {
-    throw new Error("`NaN` is not supported by the IPLD Data Model and cannot be encoded");
-  }
-  if (num === Infinity || num === -Infinity) {
-    throw new Error("`Infinity` and `-Infinity` is not supported by the IPLD Data Model and cannot be encoded");
-  }
-  return null;
-}
-var encodeOptions = {
-  float64: true,
-  typeEncoders: {
-    Object: cidEncoder,
-    undefined: undefinedEncoder,
-    number: numberEncoder
-  }
-};
-function cidDecoder(bytes) {
-  if (bytes[0] !== 0) {
-    throw new Error("Invalid CID for CBOR tag 42; expected leading 0x00");
-  }
-  return CID.decode(bytes.subarray(1));
-}
-var decodeOptions = {
-  allowIndefinite: false,
-  coerceUndefinedToNull: true,
-  allowNaN: false,
-  allowInfinity: false,
-  allowBigInt: true,
-  // this will lead to BigInt for ints outside of
-  // safe-integer range, which may surprise users
-  strict: true,
-  useMaps: false,
-  rejectDuplicateMapKeys: true,
-  /** @type {import('cborg').TagDecoder[]} */
-  tags: []
-};
-decodeOptions.tags[CID_CBOR_TAG] = cidDecoder;
-var encode2 = (node) => encode(node, encodeOptions);
-var decode4 = (data) => decode(data, decodeOptions);
-
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/decoder-common.js
-var import_varint = __toESM(require_varint(), 1);
-var CIDV0_BYTES = {
-  SHA2_256: 18,
-  LENGTH: 32,
-  DAG_PB: 112
-};
-var V2_HEADER_LENGTH = (
-  /* characteristics */
-  16 + 8 + 8 + 8
-);
-function decodeVarint(bytes, seeker) {
-  if (!bytes.length) {
-    throw new Error("Unexpected end of data");
-  }
-  const i = import_varint.default.decode(bytes);
-  seeker.seek(
-    /** @type {number} */
-    import_varint.default.decode.bytes
-  );
-  return i;
-}
-function decodeV2Header(bytes) {
-  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  let offset = 0;
-  const header = {
-    version: 2,
-    /** @type {[bigint, bigint]} */
-    characteristics: [
-      dv.getBigUint64(offset, true),
-      dv.getBigUint64(offset += 8, true)
-    ],
-    dataOffset: Number(dv.getBigUint64(offset += 8, true)),
-    dataSize: Number(dv.getBigUint64(offset += 8, true)),
-    indexOffset: Number(dv.getBigUint64(offset += 8, true))
-  };
-  return header;
-}
-function getMultihashLength(bytes) {
-  import_varint.default.decode(bytes);
-  const codeLength = (
-    /** @type {number} */
-    import_varint.default.decode.bytes
-  );
-  const length = import_varint.default.decode(bytes.subarray(import_varint.default.decode.bytes));
-  const lengthLength = (
-    /** @type {number} */
-    import_varint.default.decode.bytes
-  );
-  const mhLength = codeLength + lengthLength + length;
-  return mhLength;
-}
-
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/header-validator.js
-var Kinds = {
-  Null: (
-    /** @returns {undefined|null} */
-    (obj) => obj === null ? obj : void 0
-  ),
-  Int: (
-    /** @returns {undefined|number} */
-    (obj) => Number.isInteger(obj) ? obj : void 0
-  ),
-  Float: (
-    /** @returns {undefined|number} */
-    (obj) => typeof obj === "number" && Number.isFinite(obj) ? obj : void 0
-  ),
-  String: (
-    /** @returns {undefined|string} */
-    (obj) => typeof obj === "string" ? obj : void 0
-  ),
-  Bool: (
-    /** @returns {undefined|boolean} */
-    (obj) => typeof obj === "boolean" ? obj : void 0
-  ),
-  Bytes: (
-    /** @returns {undefined|Uint8Array} */
-    (obj) => obj instanceof Uint8Array ? obj : void 0
-  ),
-  Link: (
-    /** @returns {undefined|object} */
-    (obj) => obj !== null && typeof obj === "object" && obj.asCID === obj ? obj : void 0
-  ),
-  List: (
-    /** @returns {undefined|Array<any>} */
-    (obj) => Array.isArray(obj) ? obj : void 0
-  ),
-  Map: (
-    /** @returns {undefined|object} */
-    (obj) => obj !== null && typeof obj === "object" && obj.asCID !== obj && !Array.isArray(obj) && !(obj instanceof Uint8Array) ? obj : void 0
-  )
-};
-var Types = {
-  "CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)": Kinds.Link,
-  "CarV1HeaderOrV2Pragma > roots (anon)": (
-    /** @returns {undefined|any} */
-    (obj) => {
-      if (Kinds.List(obj) === void 0) {
-        return void 0;
-      }
-      for (let i = 0; i < obj.length; i++) {
-        let v = obj[i];
-        v = Types["CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)"](v);
-        if (v === void 0) {
-          return void 0;
-        }
-        if (v !== obj[i]) {
-          const ret = obj.slice(0, i);
-          for (let j = i; j < obj.length; j++) {
-            let v2 = obj[j];
-            v2 = Types["CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)"](v2);
-            if (v2 === void 0) {
-              return void 0;
-            }
-            ret.push(v2);
-          }
-          return ret;
-        }
-      }
-      return obj;
-    }
-  ),
-  Int: Kinds.Int,
-  CarV1HeaderOrV2Pragma: (
-    /** @returns {undefined|any} */
-    (obj) => {
-      if (Kinds.Map(obj) === void 0) {
-        return void 0;
-      }
-      const entries = Object.entries(obj);
-      let ret = obj;
-      let requiredCount = 1;
-      for (let i = 0; i < entries.length; i++) {
-        const [key, value] = entries[i];
-        switch (key) {
-          case "roots":
-            {
-              const v = Types["CarV1HeaderOrV2Pragma > roots (anon)"](obj[key]);
-              if (v === void 0) {
-                return void 0;
-              }
-              if (v !== value || ret !== obj) {
-                if (ret === obj) {
-                  ret = {};
-                  for (let j = 0; j < i; j++) {
-                    ret[entries[j][0]] = entries[j][1];
-                  }
-                }
-                ret.roots = v;
-              }
-            }
-            break;
-          case "version":
-            {
-              requiredCount--;
-              const v = Types.Int(obj[key]);
-              if (v === void 0) {
-                return void 0;
-              }
-              if (v !== value || ret !== obj) {
-                if (ret === obj) {
-                  ret = {};
-                  for (let j = 0; j < i; j++) {
-                    ret[entries[j][0]] = entries[j][1];
-                  }
-                }
-                ret.version = v;
-              }
-            }
-            break;
-          default:
-            return void 0;
-        }
-      }
-      if (requiredCount > 0) {
-        return void 0;
-      }
-      return ret;
-    }
-  )
-};
-var Reprs = {
-  "CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)": Kinds.Link,
-  "CarV1HeaderOrV2Pragma > roots (anon)": (
-    /** @returns {undefined|any} */
-    (obj) => {
-      if (Kinds.List(obj) === void 0) {
-        return void 0;
-      }
-      for (let i = 0; i < obj.length; i++) {
-        let v = obj[i];
-        v = Reprs["CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)"](v);
-        if (v === void 0) {
-          return void 0;
-        }
-        if (v !== obj[i]) {
-          const ret = obj.slice(0, i);
-          for (let j = i; j < obj.length; j++) {
-            let v2 = obj[j];
-            v2 = Reprs["CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)"](v2);
-            if (v2 === void 0) {
-              return void 0;
-            }
-            ret.push(v2);
-          }
-          return ret;
-        }
-      }
-      return obj;
-    }
-  ),
-  Int: Kinds.Int,
-  CarV1HeaderOrV2Pragma: (
-    /** @returns {undefined|any} */
-    (obj) => {
-      if (Kinds.Map(obj) === void 0) {
-        return void 0;
-      }
-      const entries = Object.entries(obj);
-      let ret = obj;
-      let requiredCount = 1;
-      for (let i = 0; i < entries.length; i++) {
-        const [key, value] = entries[i];
-        switch (key) {
-          case "roots":
-            {
-              const v = Reprs["CarV1HeaderOrV2Pragma > roots (anon)"](value);
-              if (v === void 0) {
-                return void 0;
-              }
-              if (v !== value || ret !== obj) {
-                if (ret === obj) {
-                  ret = {};
-                  for (let j = 0; j < i; j++) {
-                    ret[entries[j][0]] = entries[j][1];
-                  }
-                }
-                ret.roots = v;
-              }
-            }
-            break;
-          case "version":
-            {
-              requiredCount--;
-              const v = Reprs.Int(value);
-              if (v === void 0) {
-                return void 0;
-              }
-              if (v !== value || ret !== obj) {
-                if (ret === obj) {
-                  ret = {};
-                  for (let j = 0; j < i; j++) {
-                    ret[entries[j][0]] = entries[j][1];
-                  }
-                }
-                ret.version = v;
-              }
-            }
-            break;
-          default:
-            return void 0;
-        }
-      }
-      if (requiredCount > 0) {
-        return void 0;
-      }
-      return ret;
-    }
-  )
-};
-var CarV1HeaderOrV2Pragma = {
-  toTyped: Types.CarV1HeaderOrV2Pragma,
-  toRepresentation: Reprs.CarV1HeaderOrV2Pragma
-};
-
-// ../../../node_modules/.pnpm/cborg@4.0.3/node_modules/cborg/lib/length.js
-var cborEncoders = makeCborEncoders();
-
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/buffer-writer.js
-var import_varint2 = __toESM(require_varint(), 1);
-var headerPreludeTokens = [
-  new Token(Type.map, 2),
-  new Token(Type.string, "version"),
-  new Token(Type.uint, 1),
-  new Token(Type.string, "roots")
-];
-var CID_TAG = new Token(Type.tag, 42);
-
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/decoder.js
-async function readHeader(reader, strictVersion) {
-  const length = decodeVarint(await reader.upTo(8), reader);
-  if (length === 0) {
-    throw new Error("Invalid CAR header (zero length)");
-  }
-  const header = await reader.exactly(length, true);
-  const block = decode4(header);
-  if (CarV1HeaderOrV2Pragma.toTyped(block) === void 0) {
-    throw new Error("Invalid CAR header format");
-  }
-  if (block.version !== 1 && block.version !== 2 || strictVersion !== void 0 && block.version !== strictVersion) {
-    throw new Error(`Invalid CAR version: ${block.version}${strictVersion !== void 0 ? ` (expected ${strictVersion})` : ""}`);
-  }
-  if (block.version === 1) {
-    if (!Array.isArray(block.roots)) {
-      throw new Error("Invalid CAR header format");
-    }
-    return block;
-  }
-  if (block.roots !== void 0) {
-    throw new Error("Invalid CAR header format");
-  }
-  const v2Header = decodeV2Header(await reader.exactly(V2_HEADER_LENGTH, true));
-  reader.seek(v2Header.dataOffset - reader.pos);
-  const v1Header = await readHeader(reader, 1);
-  return Object.assign(v1Header, v2Header);
-}
-async function readCid(reader) {
-  const first = await reader.exactly(2, false);
-  if (first[0] === CIDV0_BYTES.SHA2_256 && first[1] === CIDV0_BYTES.LENGTH) {
-    const bytes2 = await reader.exactly(34, true);
-    const multihash2 = decode2(bytes2);
-    return CID.create(0, CIDV0_BYTES.DAG_PB, multihash2);
-  }
-  const version = decodeVarint(await reader.upTo(8), reader);
-  if (version !== 1) {
-    throw new Error(`Unexpected CID version (${version})`);
-  }
-  const codec = decodeVarint(await reader.upTo(8), reader);
-  const bytes = await reader.exactly(getMultihashLength(await reader.upTo(8)), true);
-  const multihash = decode2(bytes);
-  return CID.create(version, codec, multihash);
-}
-async function readBlockHead(reader) {
-  const start = reader.pos;
-  let length = decodeVarint(await reader.upTo(8), reader);
-  if (length === 0) {
-    throw new Error("Invalid CAR section (zero length)");
-  }
-  length += reader.pos - start;
-  const cid = await readCid(reader);
-  const blockLength = length - Number(reader.pos - start);
-  return { cid, length, blockLength };
-}
-async function readBlock(reader) {
-  const { cid, blockLength } = await readBlockHead(reader);
-  const bytes = await reader.exactly(blockLength, true);
-  return { bytes, cid };
-}
-async function readBlockIndex(reader) {
-  const offset = reader.pos;
-  const { cid, length, blockLength } = await readBlockHead(reader);
-  const index = { cid, length, blockLength, offset, blockOffset: reader.pos };
-  reader.seek(index.blockLength);
-  return index;
-}
-function createDecoder(reader) {
-  const headerPromise = (async () => {
-    const header = await readHeader(reader);
-    if (header.version === 2) {
-      const v1length = reader.pos - header.dataOffset;
-      reader = limitReader(reader, header.dataSize - v1length);
-    }
-    return header;
-  })();
-  return {
-    header: () => headerPromise,
-    async *blocks() {
-      await headerPromise;
-      while ((await reader.upTo(8)).length > 0) {
-        yield await readBlock(reader);
-      }
-    },
-    async *blocksIndex() {
-      await headerPromise;
-      while ((await reader.upTo(8)).length > 0) {
-        yield await readBlockIndex(reader);
-      }
-    }
-  };
-}
-function bytesReader(bytes) {
-  let pos = 0;
-  return {
-    async upTo(length) {
-      const out = bytes.subarray(pos, pos + Math.min(length, bytes.length - pos));
-      return out;
-    },
-    async exactly(length, seek = false) {
-      if (length > bytes.length - pos) {
-        throw new Error("Unexpected end of data");
-      }
-      const out = bytes.subarray(pos, pos + length);
-      if (seek) {
-        pos += length;
-      }
-      return out;
-    },
-    seek(length) {
-      pos += length;
-    },
-    get pos() {
-      return pos;
-    }
-  };
-}
-function chunkReader(readChunk) {
-  let pos = 0;
-  let have = 0;
-  let offset = 0;
-  let currentChunk = new Uint8Array(0);
-  const read = async (length) => {
-    have = currentChunk.length - offset;
-    const bufa = [currentChunk.subarray(offset)];
-    while (have < length) {
-      const chunk = await readChunk();
-      if (chunk == null) {
-        break;
-      }
-      if (have < 0) {
-        if (chunk.length > have) {
-          bufa.push(chunk.subarray(-have));
-        }
-      } else {
-        bufa.push(chunk);
-      }
-      have += chunk.length;
-    }
-    currentChunk = new Uint8Array(bufa.reduce((p, c) => p + c.length, 0));
-    let off = 0;
-    for (const b of bufa) {
-      currentChunk.set(b, off);
-      off += b.length;
-    }
-    offset = 0;
-  };
-  return {
-    async upTo(length) {
-      if (currentChunk.length - offset < length) {
-        await read(length);
-      }
-      return currentChunk.subarray(offset, offset + Math.min(currentChunk.length - offset, length));
-    },
-    async exactly(length, seek = false) {
-      if (currentChunk.length - offset < length) {
-        await read(length);
-      }
-      if (currentChunk.length - offset < length) {
-        throw new Error("Unexpected end of data");
-      }
-      const out = currentChunk.subarray(offset, offset + length);
-      if (seek) {
-        pos += length;
-        offset += length;
-      }
-      return out;
-    },
-    seek(length) {
-      pos += length;
-      offset += length;
-    },
-    get pos() {
-      return pos;
-    }
-  };
-}
-function asyncIterableReader(asyncIterable) {
-  const iterator = asyncIterable[Symbol.asyncIterator]();
-  async function readChunk() {
-    const next = await iterator.next();
-    if (next.done) {
-      return null;
-    }
-    return next.value;
-  }
-  return chunkReader(readChunk);
-}
-function limitReader(reader, byteLimit) {
-  let bytesRead = 0;
-  return {
-    async upTo(length) {
-      let bytes = await reader.upTo(length);
-      if (bytes.length + bytesRead > byteLimit) {
-        bytes = bytes.subarray(0, byteLimit - bytesRead);
-      }
-      return bytes;
-    },
-    async exactly(length, seek = false) {
-      const bytes = await reader.exactly(length, seek);
-      if (bytes.length + bytesRead > byteLimit) {
-        throw new Error("Unexpected end of data");
-      }
-      if (seek) {
-        bytesRead += length;
-      }
-      return bytes;
-    },
-    seek(length) {
-      bytesRead += length;
-      reader.seek(length);
-    },
-    get pos() {
-      return reader.pos;
-    }
-  };
-}
-
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/indexer.js
-var CarIndexer = class {
-  /**
-   * @param {number} version
-   * @param {CID[]} roots
-   * @param {AsyncGenerator<BlockIndex>} iterator
-   */
-  constructor(version, roots, iterator) {
-    this._version = version;
-    this._roots = roots;
-    this._iterator = iterator;
-  }
-  get version() {
-    return this._version;
-  }
-  /**
-   * Get the list of roots defined by the CAR referenced by this indexer. May be
-   * zero or more `CID`s.
-   *
-   * @function
-   * @memberof CarIndexer
-   * @instance
-   * @async
-   * @returns {Promise<CID[]>}
-   */
-  async getRoots() {
-    return this._roots;
-  }
-  /**
-   * @returns {AsyncIterator<BlockIndex>}
-   */
-  [Symbol.asyncIterator]() {
-    return this._iterator;
-  }
-  /**
-   * Instantiate a {@link CarIndexer} from a `Uint8Array` blob. Only the header
-   * is decoded initially, the remainder is processed and emitted via the
-   * iterator as it is consumed.
-   *
-   * @async
-   * @static
-   * @memberof CarIndexer
-   * @param {Uint8Array} bytes
-   * @returns {Promise<CarIndexer>}
-   */
-  static async fromBytes(bytes) {
-    if (!(bytes instanceof Uint8Array)) {
-      throw new TypeError("fromBytes() requires a Uint8Array");
-    }
-    return decodeIndexerComplete(bytesReader(bytes));
-  }
-  /**
-   * Instantiate a {@link CarIndexer} from a `AsyncIterable<Uint8Array>`,
-   * such as a [modern Node.js stream](https://nodejs.org/api/stream.html#stream_streams_compatibility_with_async_generators_and_async_iterators).
-   * is decoded initially, the remainder is processed and emitted via the
-   * iterator as it is consumed.
-   *
-   * @async
-   * @static
-   * @memberof CarIndexer
-   * @param {AsyncIterable<Uint8Array>} asyncIterable
-   * @returns {Promise<CarIndexer>}
-   */
-  static async fromIterable(asyncIterable) {
-    if (!asyncIterable || !(typeof asyncIterable[Symbol.asyncIterator] === "function")) {
-      throw new TypeError("fromIterable() requires an async iterable");
-    }
-    return decodeIndexerComplete(asyncIterableReader(asyncIterable));
-  }
-};
-async function decodeIndexerComplete(reader) {
-  const decoder = createDecoder(reader);
-  const { version, roots } = await decoder.header();
-  return new CarIndexer(version, roots, decoder.blocksIndex());
-}
-
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/iterator.js
-var CarIteratorBase = class {
-  /**
-   * @param {number} version
-   * @param {CID[]} roots
-   * @param {AsyncIterable<Block>|void} iterable
-   */
-  constructor(version, roots, iterable) {
-    this._version = version;
-    this._roots = roots;
-    this._iterable = iterable;
-    this._decoded = false;
-  }
-  get version() {
-    return this._version;
-  }
-  /**
-   * @returns {Promise<CID[]>}
-   */
-  async getRoots() {
-    return this._roots;
-  }
-};
-var CarBlockIterator = class _CarBlockIterator extends CarIteratorBase {
-  // inherited method
-  /**
-   * Get the list of roots defined by the CAR referenced by this iterator. May be
-   * zero or more `CID`s.
-   *
-   * @function getRoots
-   * @memberof CarBlockIterator
-   * @instance
-   * @async
-   * @returns {Promise<CID[]>}
-   */
-  /**
-   * @returns {AsyncIterator<Block>}
-   */
-  [Symbol.asyncIterator]() {
-    if (this._decoded) {
-      throw new Error("Cannot decode more than once");
-    }
-    if (!this._iterable) {
-      throw new Error("Block iterable not found");
-    }
-    this._decoded = true;
-    return this._iterable[Symbol.asyncIterator]();
-  }
-  /**
-   * Instantiate a {@link CarBlockIterator} from a `Uint8Array` blob. Rather
-   * than decoding the entire byte array prior to returning the iterator, as in
-   * {@link CarReader.fromBytes}, only the header is decoded and the remainder
-   * of the CAR is parsed as the `Block`s as yielded.
-   *
-   * @async
-   * @static
-   * @memberof CarBlockIterator
-   * @param {Uint8Array} bytes
-   * @returns {Promise<CarBlockIterator>}
-   */
-  static async fromBytes(bytes) {
-    const { version, roots, iterator } = await fromBytes2(bytes);
-    return new _CarBlockIterator(version, roots, iterator);
-  }
-  /**
-   * Instantiate a {@link CarBlockIterator} from a `AsyncIterable<Uint8Array>`,
-   * such as a [modern Node.js stream](https://nodejs.org/api/stream.html#stream_streams_compatibility_with_async_generators_and_async_iterators).
-   * Rather than decoding the entire byte array prior to returning the iterator,
-   * as in {@link CarReader.fromIterable}, only the header is decoded and the
-   * remainder of the CAR is parsed as the `Block`s as yielded.
-   *
-   * @async
-   * @static
-   * @param {AsyncIterable<Uint8Array>} asyncIterable
-   * @returns {Promise<CarBlockIterator>}
-   */
-  static async fromIterable(asyncIterable) {
-    const { version, roots, iterator } = await fromIterable(asyncIterable);
-    return new _CarBlockIterator(version, roots, iterator);
-  }
-};
-var CarCIDIterator = class _CarCIDIterator extends CarIteratorBase {
-  // inherited method
-  /**
-   * Get the list of roots defined by the CAR referenced by this iterator. May be
-   * zero or more `CID`s.
-   *
-   * @function getRoots
-   * @memberof CarCIDIterator
-   * @instance
-   * @async
-   * @returns {Promise<CID[]>}
-   */
-  /**
-   * @returns {AsyncIterator<CID>}
-   */
-  [Symbol.asyncIterator]() {
-    if (this._decoded) {
-      throw new Error("Cannot decode more than once");
-    }
-    if (!this._iterable) {
-      throw new Error("Block iterable not found");
-    }
-    this._decoded = true;
-    const iterable = this._iterable[Symbol.asyncIterator]();
-    return {
-      async next() {
-        const next = await iterable.next();
-        if (next.done) {
-          return next;
-        }
-        return { done: false, value: next.value.cid };
-      }
-    };
-  }
-  /**
-   * Instantiate a {@link CarCIDIterator} from a `Uint8Array` blob. Rather
-   * than decoding the entire byte array prior to returning the iterator, as in
-   * {@link CarReader.fromBytes}, only the header is decoded and the remainder
-   * of the CAR is parsed as the `CID`s as yielded.
-   *
-   * @async
-   * @static
-   * @memberof CarCIDIterator
-   * @param {Uint8Array} bytes
-   * @returns {Promise<CarCIDIterator>}
-   */
-  static async fromBytes(bytes) {
-    const { version, roots, iterator } = await fromBytes2(bytes);
-    return new _CarCIDIterator(version, roots, iterator);
-  }
-  /**
-   * Instantiate a {@link CarCIDIterator} from a `AsyncIterable<Uint8Array>`,
-   * such as a [modern Node.js stream](https://nodejs.org/api/stream.html#stream_streams_compatibility_with_async_generators_and_async_iterators).
-   * Rather than decoding the entire byte array prior to returning the iterator,
-   * as in {@link CarReader.fromIterable}, only the header is decoded and the
-   * remainder of the CAR is parsed as the `CID`s as yielded.
-   *
-   * @async
-   * @static
-   * @memberof CarCIDIterator
-   * @param {AsyncIterable<Uint8Array>} asyncIterable
-   * @returns {Promise<CarCIDIterator>}
-   */
-  static async fromIterable(asyncIterable) {
-    const { version, roots, iterator } = await fromIterable(asyncIterable);
-    return new _CarCIDIterator(version, roots, iterator);
-  }
-};
-async function fromBytes2(bytes) {
-  if (!(bytes instanceof Uint8Array)) {
-    throw new TypeError("fromBytes() requires a Uint8Array");
-  }
-  return decodeIterator(bytesReader(bytes));
-}
-async function fromIterable(asyncIterable) {
-  if (!asyncIterable || !(typeof asyncIterable[Symbol.asyncIterator] === "function")) {
-    throw new TypeError("fromIterable() requires an async iterable");
-  }
-  return decodeIterator(asyncIterableReader(asyncIterable));
-}
-async function decodeIterator(reader) {
-  const decoder = createDecoder(reader);
-  const { version, roots } = await decoder.header();
-  return { version, roots, iterator: decoder.blocks() };
-}
-
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/encoder.js
-var import_varint3 = __toESM(require_varint(), 1);
-function createHeader(roots) {
-  const headerBytes = encode2({ version: 1, roots });
-  const varintBytes = import_varint3.default.encode(headerBytes.length);
-  const header = new Uint8Array(varintBytes.length + headerBytes.length);
-  header.set(varintBytes, 0);
-  header.set(headerBytes, varintBytes.length);
-  return header;
-}
-function createEncoder(writer) {
-  return {
-    /**
-     * @param {CID[]} roots
-     * @returns {Promise<void>}
-     */
-    async setRoots(roots) {
-      const bytes = createHeader(roots);
-      await writer.write(bytes);
-    },
-    /**
-     * @param {Block} block
-     * @returns {Promise<void>}
-     */
-    async writeBlock(block) {
-      const { cid, bytes } = block;
-      await writer.write(new Uint8Array(import_varint3.default.encode(cid.bytes.length + bytes.length)));
-      await writer.write(cid.bytes);
-      if (bytes.length) {
-        await writer.write(bytes);
-      }
-    },
-    /**
-     * @returns {Promise<void>}
-     */
-    async close() {
-      await writer.end();
-    }
-  };
-}
-
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/iterator-channel.js
-function noop() {
-}
-function create() {
-  const chunkQueue = [];
-  let drainer = null;
-  let drainerResolver = noop;
-  let ended = false;
-  let outWait = null;
-  let outWaitResolver = noop;
-  const makeDrainer = () => {
-    if (!drainer) {
-      drainer = new Promise((resolve) => {
-        drainerResolver = () => {
-          drainer = null;
-          drainerResolver = noop;
-          resolve();
-        };
-      });
-    }
-    return drainer;
-  };
-  const writer = {
-    /**
-     * @param {T} chunk
-     * @returns {Promise<void>}
-     */
-    write(chunk) {
-      chunkQueue.push(chunk);
-      const drainer2 = makeDrainer();
-      outWaitResolver();
-      return drainer2;
-    },
-    async end() {
-      ended = true;
-      const drainer2 = makeDrainer();
-      outWaitResolver();
-      await drainer2;
-    }
-  };
-  const iterator = {
-    /** @returns {Promise<IteratorResult<T>>} */
-    async next() {
-      const chunk = chunkQueue.shift();
-      if (chunk) {
-        if (chunkQueue.length === 0) {
-          drainerResolver();
-        }
-        return { done: false, value: chunk };
-      }
-      if (ended) {
-        drainerResolver();
-        return { done: true, value: void 0 };
-      }
-      if (!outWait) {
-        outWait = new Promise((resolve) => {
-          outWaitResolver = () => {
-            outWait = null;
-            outWaitResolver = noop;
-            return resolve(iterator.next());
-          };
-        });
-      }
-      return outWait;
-    }
-  };
-  return { writer, iterator };
-}
-
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/writer-browser.js
-var CarWriter = class _CarWriter {
-  /**
-   * @param {CID[]} roots
-   * @param {CarEncoder} encoder
-   */
-  constructor(roots, encoder) {
-    this._encoder = encoder;
-    this._mutex = encoder.setRoots(roots);
-    this._ended = false;
-  }
-  /**
-   * Write a `Block` (a `{ cid:CID, bytes:Uint8Array }` pair) to the archive.
-   *
-   * @function
-   * @memberof CarWriter
-   * @instance
-   * @async
-   * @param {Block} block - A `{ cid:CID, bytes:Uint8Array }` pair.
-   * @returns {Promise<void>} The returned promise will only resolve once the
-   * bytes this block generates are written to the `out` iterable.
-   */
-  async put(block) {
-    if (!(block.bytes instanceof Uint8Array) || !block.cid) {
-      throw new TypeError("Can only write {cid, bytes} objects");
-    }
-    if (this._ended) {
-      throw new Error("Already closed");
-    }
-    const cid = CID.asCID(block.cid);
-    if (!cid) {
-      throw new TypeError("Can only write {cid, bytes} objects");
-    }
-    this._mutex = this._mutex.then(() => this._encoder.writeBlock({ cid, bytes: block.bytes }));
-    return this._mutex;
-  }
-  /**
-   * Finalise the CAR archive and signal that the `out` iterable should end once
-   * any remaining bytes are written.
-   *
-   * @function
-   * @memberof CarWriter
-   * @instance
-   * @async
-   * @returns {Promise<void>}
-   */
-  async close() {
-    if (this._ended) {
-      throw new Error("Already closed");
-    }
-    await this._mutex;
-    this._ended = true;
-    return this._encoder.close();
-  }
-  /**
-   * Create a new CAR writer "channel" which consists of a
-   * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }` pair.
-   *
-   * @async
-   * @static
-   * @memberof CarWriter
-   * @param {CID[] | CID | void} roots
-   * @returns {WriterChannel} The channel takes the form of
-   * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }`.
-   */
-  static create(roots) {
-    roots = toRoots(roots);
-    const { encoder, iterator } = encodeWriter();
-    const writer = new _CarWriter(roots, encoder);
-    const out = new CarWriterOut(iterator);
-    return { writer, out };
-  }
-  /**
-   * Create a new CAR appender "channel" which consists of a
-   * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }` pair.
-   * This appender does not consider roots and does not produce a CAR header.
-   * It is designed to append blocks to an _existing_ CAR archive. It is
-   * expected that `out` will be concatenated onto the end of an existing
-   * archive that already has a properly formatted header.
-   *
-   * @async
-   * @static
-   * @memberof CarWriter
-   * @returns {WriterChannel} The channel takes the form of
-   * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }`.
-   */
-  static createAppender() {
-    const { encoder, iterator } = encodeWriter();
-    encoder.setRoots = () => Promise.resolve();
-    const writer = new _CarWriter([], encoder);
-    const out = new CarWriterOut(iterator);
-    return { writer, out };
-  }
-  /**
-   * Update the list of roots in the header of an existing CAR as represented
-   * in a Uint8Array.
-   *
-   * This operation is an _overwrite_, the total length of the CAR will not be
-   * modified. A rejection will occur if the new header will not be the same
-   * length as the existing header, in which case the CAR will not be modified.
-   * It is the responsibility of the user to ensure that the roots being
-   * replaced encode as the same length as the new roots.
-   *
-   * The byte array passed in an argument will be modified and also returned
-   * upon successful modification.
-   *
-   * @async
-   * @static
-   * @memberof CarWriter
-   * @param {Uint8Array} bytes
-   * @param {CID[]} roots - A new list of roots to replace the existing list in
-   * the CAR header. The new header must take up the same number of bytes as the
-   * existing header, so the roots should collectively be the same byte length
-   * as the existing roots.
-   * @returns {Promise<Uint8Array>}
-   */
-  static async updateRootsInBytes(bytes, roots) {
-    const reader = bytesReader(bytes);
-    await readHeader(reader);
-    const newHeader = createHeader(roots);
-    if (Number(reader.pos) !== newHeader.length) {
-      throw new Error(`updateRoots() can only overwrite a header of the same length (old header is ${reader.pos} bytes, new header is ${newHeader.length} bytes)`);
-    }
-    bytes.set(newHeader, 0);
-    return bytes;
-  }
-};
-var CarWriterOut = class {
-  /**
-   * @param {AsyncIterator<Uint8Array>} iterator
-   */
-  constructor(iterator) {
-    this._iterator = iterator;
-  }
-  [Symbol.asyncIterator]() {
-    if (this._iterating) {
-      throw new Error("Multiple iterator not supported");
-    }
-    this._iterating = true;
-    return this._iterator;
-  }
-};
-function encodeWriter() {
-  const iw = create();
-  const { writer, iterator } = iw;
-  const encoder = createEncoder(writer);
-  return { encoder, iterator };
-}
-function toRoots(roots) {
-  if (roots === void 0) {
-    return [];
-  }
-  if (!Array.isArray(roots)) {
-    const cid = CID.asCID(roots);
-    if (!cid) {
-      throw new TypeError("roots must be a single CID or an array of CIDs");
-    }
-    return [cid];
-  }
-  const _roots = [];
-  for (const root of roots) {
-    const _root = CID.asCID(root);
-    if (!_root) {
-      throw new TypeError("roots must be a single CID or an array of CIDs");
-    }
-    _roots.push(_root);
-  }
-  return _roots;
-}
-
-// src/ipfs/car.ts
-var { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO);
-async function decodeCarToApplogs(car) {
-  const { roots, blocks } = await decodeCar(car);
-  if (!roots || !blocks) {
-    throw ERROR("decodeCar is funky", { roots, blocks });
-  }
-  if (roots.length !== 1) {
-    WARN("Unexpected roots count:", roots);
-  }
-  const root = blocks.get(roots[0]);
-  let applogArr;
-  DEBUG(`root:`, root, { blocks });
-  if (root.info) {
-    applogArr = blocks.get(root.applogs.toString()).logs;
-    DEBUG(`new format - infoLogs`, blocks.get(root.info.toString()));
-  } else {
-    applogArr = root.applogs;
-  }
-  let applogs;
-  applogs = applogArr.map((cidOrLink) => {
-    const cid = cidOrLink.toV1 ? cidOrLink.toV1().toString() : cidOrLink["/"];
-    const applog = blocks.get(cid);
-    if (!applog)
-      throw ERROR(`Could not find applog CID in Car file:`, cid, { root, blocks });
-    return {
-      ...applog,
-      cid
-    };
-  });
-  DEBUG("Decoded car logs:", root, { roots, blocks, applogs });
-  return { applogs };
-}
-async function decodeCar(car) {
-  const roots = (await car.getRoots()).map((c) => c.toV1().toString());
-  const blocks = /* @__PURE__ */ new Map();
-  for await (const { cid, bytes } of car.blocks()) {
-    blocks.set(cid.toV1().toString(), decode3(bytes));
-  }
-  return { roots, blocks };
-}
-async function makeCarOut(roots, blocks) {
-  const { writer, out } = CarWriter.create(Array.isArray(roots) ? roots : [roots]);
-  VERBOSE(`Writing ${blocks.length} blocks to CAR`, { roots, blocks });
-  blocks.forEach((b) => writer.put(b));
-  writer.close();
-  return out;
-}
-async function makeCarBlob(roots, blocks) {
-  const carOut = await makeCarOut(roots, blocks);
-  const chunks = [];
-  for await (const chunk of carOut) {
-    chunks.push(chunk);
-  }
-  const blob = new Blob(chunks);
-  return blob;
-}
-
-export {
-  decodeCarToApplogs,
-  decodeCar,
-  makeCarOut,
-  makeCarBlob
-};
-//# sourceMappingURL=chunk-2UCPKUQK.min.js.map