@wovin/core 0.0.6 → 0.0.8

package/dist/chunk-ORHJN4G2.min.js

@@ -0,0 +1,1425 @@
+import {
+  CID,
+  Logger,
+  Token,
+  Type,
+  decode,
+  decode2,
+  decode3,
+  encode,
+  makeCborEncoders
+} from "./chunk-2J7BWXZ3.min.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-KRQZ6V4Y.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.5/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/reader-browser.js
+var CarReader = class {
+  /**
+   * @constructs CarReader
+   * @param {CarHeader|CarV2Header} header
+   * @param {Block[]} blocks
+   */
+  constructor(header, blocks) {
+    this._header = header;
+    this._blocks = blocks;
+    this._keys = blocks.map((b) => b.cid.toString());
+  }
+  /**
+   * @property
+   * @memberof CarReader
+   * @instance
+   */
+  get version() {
+    return this._header.version;
+  }
+  /**
+   * Get the list of roots defined by the CAR referenced by this reader. May be
+   * zero or more `CID`s.
+   *
+   * @function
+   * @memberof CarReader
+   * @instance
+   * @async
+   * @returns {Promise<CID[]>}
+   */
+  async getRoots() {
+    return this._header.roots;
+  }
+  /**
+   * Check whether a given `CID` exists within the CAR referenced by this
+   * reader.
+   *
+   * @function
+   * @memberof CarReader
+   * @instance
+   * @async
+   * @param {CID} key
+   * @returns {Promise<boolean>}
+   */
+  async has(key) {
+    return this._keys.indexOf(key.toString()) > -1;
+  }
+  /**
+   * Fetch a `Block` (a `{ cid:CID, bytes:Uint8Array }` pair) from the CAR
+   * referenced by this reader matching the provided `CID`. In the case where
+   * the provided `CID` doesn't exist within the CAR, `undefined` will be
+   * returned.
+   *
+   * @function
+   * @memberof CarReader
+   * @instance
+   * @async
+   * @param {CID} key
+   * @returns {Promise<Block | undefined>}
+   */
+  async get(key) {
+    const index = this._keys.indexOf(key.toString());
+    return index > -1 ? this._blocks[index] : void 0;
+  }
+  /**
+   * Returns a `BlockIterator` (`AsyncIterable<Block>`) that iterates over all
+   * of the `Block`s (`{ cid:CID, bytes:Uint8Array }` pairs) contained within
+   * the CAR referenced by this reader.
+   *
+   * @function
+   * @memberof CarReader
+   * @instance
+   * @async
+   * @generator
+   * @returns {AsyncGenerator<Block>}
+   */
+  async *blocks() {
+    for (const block of this._blocks) {
+      yield block;
+    }
+  }
+  /**
+   * Returns a `CIDIterator` (`AsyncIterable<CID>`) that iterates over all of
+   * the `CID`s contained within the CAR referenced by this reader.
+   *
+   * @function
+   * @memberof CarReader
+   * @instance
+   * @async
+   * @generator
+   * @returns {AsyncGenerator<CID>}
+   */
+  async *cids() {
+    for (const block of this._blocks) {
+      yield block.cid;
+    }
+  }
+  /**
+   * Instantiate a {@link CarReader} from a `Uint8Array` blob. This performs a
+   * decode fully in memory and maintains the decoded state in memory for full
+   * access to the data via the `CarReader` API.
+   *
+   * @async
+   * @static
+   * @memberof CarReader
+   * @param {Uint8Array} bytes
+   * @returns {Promise<CarReader>}
+   */
+  static async fromBytes(bytes) {
+    if (!(bytes instanceof Uint8Array)) {
+      throw new TypeError("fromBytes() requires a Uint8Array");
+    }
+    return decodeReaderComplete(bytesReader(bytes));
+  }
+  /**
+   * Instantiate a {@link CarReader} from a `AsyncIterable<Uint8Array>`, such as
+   * a [modern Node.js stream](https://nodejs.org/api/stream.html#stream_streams_compatibility_with_async_generators_and_async_iterators).
+   * This performs a decode fully in memory and maintains the decoded state in
+   * memory for full access to the data via the `CarReader` API.
+   *
+   * Care should be taken for large archives; this API may not be appropriate
+   * where memory is a concern or the archive is potentially larger than the
+   * amount of memory that the runtime can handle.
+   *
+   * @async
+   * @static
+   * @memberof CarReader
+   * @param {AsyncIterable<Uint8Array>} asyncIterable
+   * @returns {Promise<CarReader>}
+   */
+  static async fromIterable(asyncIterable) {
+    if (!asyncIterable || !(typeof asyncIterable[Symbol.asyncIterator] === "function")) {
+      throw new TypeError("fromIterable() requires an async iterable");
+    }
+    return decodeReaderComplete(asyncIterableReader(asyncIterable));
+  }
+};
+async function decodeReaderComplete(reader) {
+  const decoder = createDecoder(reader);
+  const header = await decoder.header();
+  const blocks = [];
+  for await (const block of decoder.blocks()) {
+    blocks.push(block);
+  }
+  return new CarReader(header, blocks);
+}
+
+// ../../../node_modules/.pnpm/@ipld+car@5.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) {
+      ERROR(`Could not find applog CID in Car file:`, cid, { root, blocks });
+      throw new Error(`Could not find applog CID in Car file: ${cid.toString()}`);
+    }
+    if (applog.pv instanceof CID)
+      applog.pv = applog.pv.toV1().toString();
+    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;
+}
+async function carFromBlob(blob) {
+  return CarReader.fromBytes(new Uint8Array(await blob.arrayBuffer()));
+}
+function streamReaderToIterable(bodyReader) {
+  return async function* () {
+    while (true) {
+      const { done, value } = await bodyReader.read();
+      if (done) {
+        break;
+      }
+      yield value;
+    }
+  }();
+}
+
+export {
+  decodeCarToApplogs,
+  decodeCar,
+  makeCarOut,
+  makeCarBlob,
+  carFromBlob,
+  streamReaderToIterable
+};
+//# sourceMappingURL=chunk-ORHJN4G2.min.js.map