@ipld/car 3.2.3 → 4.1.0

package/test/test-buffer-writer.js

@@ -0,0 +1,256 @@
+/* eslint-env mocha */
+
+import * as CarBufferWriter from '@ipld/car/buffer-writer'
+import { CarReader } from '@ipld/car/reader'
+import { createHeader } from '../lib/encoder.js'
+import { assert } from './common.js'
+import { CID, varint } from 'multiformats'
+import * as CBOR from '@ipld/dag-cbor'
+import { sha256, sha512 } from 'multiformats/hashes/sha2'
+import { identity } from 'multiformats/hashes/identity'
+import * as Raw from 'multiformats/codecs/raw'
+import * as Block from 'multiformats/block'
+
+describe('CarBufferWriter', () => {
+  const cid = CID.parse('bafkreifuosuzujyf4i6psbneqtwg2fhplc2wxptc5euspa2gn3bwhnihfu')
+  describe('calculateHeaderLength', async () => {
+    for (const count of [0, 1, 10, 18, 24, 48, 124, 255, 258, 65536 - 1, 65536]) {
+      it(`calculateHeaderLength(new Array(${count}).fill(36))`, () => {
+        const roots = new Array(count).fill(cid)
+        const sizes = new Array(count).fill(cid.bytes.byteLength)
+        assert.deepEqual(
+          CarBufferWriter.calculateHeaderLength(sizes),
+          createHeader(roots).byteLength
+        )
+      })
+      it(`calculateHeaderLength(new Array(${count}).fill(36))`, () => {
+        const roots = new Array(count).fill(cid)
+        const rootLengths = roots.map((c) => c.bytes.byteLength)
+        assert.deepEqual(CarBufferWriter.calculateHeaderLength(rootLengths), createHeader(roots).byteLength)
+      })
+    }
+    it('estimate on large CIDs', () => {
+      const largeCID = CID.parse(`bafkqbbac${'a'.repeat(416)}`)
+      assert.equal(
+        CarBufferWriter.calculateHeaderLength([
+          cid.bytes.byteLength,
+          largeCID.bytes.byteLength
+        ]),
+        createHeader([
+          cid,
+          largeCID
+        ]).byteLength
+      )
+    })
+
+    it('estimate on large CIDs 2', () => {
+      const largeCID = CID.createV1(Raw.code, identity.digest(new Uint8Array(512).fill(1)))
+      assert.equal(
+        CarBufferWriter.calculateHeaderLength([
+          cid.bytes.byteLength,
+          largeCID.bytes.byteLength
+        ]),
+        createHeader([cid, largeCID]).byteLength
+      )
+    })
+  })
+
+  describe('writer', () => {
+    it('estimate header and write blocks', async () => {
+      const headerSize = CarBufferWriter.estimateHeaderLength(1)
+      const dataSize = 256
+      const buffer = new ArrayBuffer(headerSize + dataSize)
+      const writer = CarBufferWriter.createWriter(buffer, { headerSize })
+      const b1 = await Block.encode({
+        value: { hello: 'world' },
+        codec: CBOR,
+        hasher: sha256
+      })
+
+      writer.write(b1)
+
+      const b2 = await Block.encode({
+        value: { bye: 'world' },
+        codec: CBOR,
+        hasher: sha256
+      })
+      writer.write(b2)
+
+      writer.addRoot(b1.cid)
+      const bytes = writer.close()
+
+      const reader = await CarReader.fromBytes(bytes)
+      assert.deepEqual(await reader.getRoots(), [b1.cid])
+      assert.deepEqual(reader._blocks, [{ cid: b1.cid, bytes: b1.bytes }, { cid: b2.cid, bytes: b2.bytes }])
+    })
+
+    it('overestimate header', async () => {
+      const headerSize = CarBufferWriter.estimateHeaderLength(2)
+      const dataSize = 256
+      const buffer = new ArrayBuffer(headerSize + dataSize)
+      const writer = CarBufferWriter.createWriter(buffer, { headerSize })
+      const b1 = await Block.encode({
+        value: { hello: 'world' },
+        codec: CBOR,
+        hasher: sha256
+      })
+
+      writer.write(b1)
+
+      const b2 = await Block.encode({
+        value: { bye: 'world' },
+        codec: CBOR,
+        hasher: sha256
+      })
+      writer.write(b2)
+
+      writer.addRoot(b1.cid)
+      assert.throws(() => writer.close(), /Header size was overestimate/)
+      const bytes = writer.close({ resize: true })
+
+      const reader = await CarReader.fromBytes(bytes)
+      assert.deepEqual(await reader.getRoots(), [b1.cid])
+      assert.deepEqual(reader._blocks, [{ cid: b1.cid, bytes: b1.bytes }, { cid: b2.cid, bytes: b2.bytes }])
+    })
+
+    it('underestimate header', async () => {
+      const headerSize = CarBufferWriter.estimateHeaderLength(2)
+      const dataSize = 300
+      const buffer = new ArrayBuffer(headerSize + dataSize)
+      const writer = CarBufferWriter.createWriter(buffer, { headerSize })
+      const b1 = await Block.encode({
+        value: { hello: 'world' },
+        codec: CBOR,
+        hasher: sha256
+      })
+
+      writer.write(b1)
+      writer.addRoot(b1.cid)
+
+      const b2 = await Block.encode({
+        value: { bye: 'world' },
+        codec: CBOR,
+        hasher: sha512
+      })
+      writer.write(b2)
+      assert.throws(() => writer.addRoot(b2.cid), /has no capacity/)
+      writer.addRoot(b2.cid, { resize: true })
+
+      const bytes = writer.close()
+
+      const reader = await CarReader.fromBytes(bytes)
+      assert.deepEqual(await reader.getRoots(), [b1.cid, b2.cid])
+      assert.deepEqual(reader._blocks, [{ cid: b1.cid, bytes: b1.bytes }, { cid: b2.cid, bytes: b2.bytes }])
+    })
+  })
+
+  it('has no space for the root', async () => {
+    const headerSize = CarBufferWriter.estimateHeaderLength(1)
+    const dataSize = 100
+    const buffer = new ArrayBuffer(headerSize + dataSize)
+    const writer = CarBufferWriter.createWriter(buffer, { headerSize })
+    const b1 = await Block.encode({
+      value: { hello: 'world' },
+      codec: CBOR,
+      hasher: sha256
+    })
+
+    writer.write(b1)
+    writer.addRoot(b1.cid)
+
+    const b2 = await Block.encode({
+      value: { bye: 'world' },
+      codec: CBOR,
+      hasher: sha256
+    })
+    writer.write(b2)
+    assert.throws(() => writer.addRoot(b2.cid), /Buffer has no capacity for a new root/)
+    assert.throws(() => writer.addRoot(b2.cid, { resize: true }), /Buffer has no capacity for a new root/)
+
+    const bytes = writer.close()
+
+    const reader = await CarReader.fromBytes(bytes)
+    assert.deepEqual(await reader.getRoots(), [b1.cid])
+    assert.deepEqual(reader._blocks, [{ cid: b1.cid, bytes: b1.bytes }, { cid: b2.cid, bytes: b2.bytes }])
+  })
+
+  it('has no space for the block', async () => {
+    const headerSize = CarBufferWriter.estimateHeaderLength(1)
+    const dataSize = 58
+    const buffer = new ArrayBuffer(headerSize + dataSize)
+    const writer = CarBufferWriter.createWriter(buffer, { headerSize })
+    const b1 = await Block.encode({
+      value: { hello: 'world' },
+      codec: CBOR,
+      hasher: sha256
+    })
+
+    writer.write(b1)
+    writer.addRoot(b1.cid)
+
+    const b2 = await Block.encode({
+      value: { bye: 'world' },
+      codec: CBOR,
+      hasher: sha256
+    })
+    assert.throws(() => writer.write(b2), /Buffer has no capacity for this block/)
+
+    const bytes = writer.close()
+
+    const reader = await CarReader.fromBytes(bytes)
+    assert.deepEqual(await reader.getRoots(), [b1.cid])
+    assert.deepEqual(reader._blocks, [{ cid: b1.cid, bytes: b1.bytes }])
+  })
+
+  it('provide roots', async () => {
+    const b1 = await Block.encode({
+      value: { hello: 'world' },
+      codec: CBOR,
+      hasher: sha256
+    })
+    const b2 = await Block.encode({
+      value: { bye: 'world' },
+      codec: CBOR,
+      hasher: sha512
+    })
+
+    const buffer = new ArrayBuffer(300)
+    const writer = CarBufferWriter.createWriter(buffer, { roots: [b1.cid, b2.cid] })
+
+    writer.write(b1)
+    writer.write(b2)
+
+    const bytes = writer.close()
+
+    const reader = await CarReader.fromBytes(bytes)
+    assert.deepEqual(await reader.getRoots(), [b1.cid, b2.cid])
+    assert.deepEqual(reader._blocks, [{ cid: b1.cid, bytes: b1.bytes }, { cid: b2.cid, bytes: b2.bytes }])
+  })
+
+  it('provide large CID root', async () => {
+    const bytes = new Uint8Array(512).fill(1)
+    const b1 = await Block.encode({
+      value: { hello: 'world' },
+      codec: CBOR,
+      hasher: sha256
+    })
+
+    const b2 = {
+      cid: CID.createV1(Raw.code, identity.digest(bytes)),
+      bytes
+    }
+
+    const headerSize = CBOR.encode({ version: 1, roots: [b1.cid, b2.cid] }).byteLength
+    const bodySize = CarBufferWriter.blockLength(b1) + CarBufferWriter.blockLength(b2)
+    const varintSize = varint.encodingLength(headerSize)
+
+    const writer = CarBufferWriter.createWriter(new ArrayBuffer(varintSize + headerSize + bodySize), { roots: [b1.cid, b2.cid] })
+
+    writer.write(b1)
+    writer.write(b2)
+    const car = writer.close()
+    const reader = await CarReader.fromBytes(car)
+    assert.deepEqual(await reader.getRoots(), [b1.cid, b2.cid])
+    assert.deepEqual(reader._blocks, [{ cid: b1.cid, bytes: b1.bytes }, { cid: b2.cid, bytes: b2.bytes }])
+  })
+})

package/test/test-errors.js

@@ -3,7 +3,7 @@ import { bytes } from 'multiformats'
 import { encode as cbEncode } from '@ipld/dag-cbor'
 import { encode as vEncode } from 'varint'
 import { CarReader } from '@ipld/car/reader'
-import { carBytes, assert } from './common.js'
+import { carBytes, assert, goCarV2Bytes } from './common.js'
 
 /**
  * @param {any} block
@@ -34,43 +34,65 @@ describe('Misc errors', () => {
 
   it('bad version', async () => {
     // quick sanity check that makeHeader() works properly!
-    const buf2 = bytes.fromHex('0aa16776657273696f6e02')
-    // {version:2} - fixed string, likely to be used by CARv2 to escape header parsing rules
-    assert.strictEqual(bytes.toHex(makeHeader({ version: 2 })), '0aa16776657273696f6e02')
-    await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR version: 2')
+    const buf2 = bytes.fromHex('0aa16776657273696f6e03')
+    assert.strictEqual(bytes.toHex(makeHeader({ version: 3 })), '0aa16776657273696f6e03')
+    // {version:3}
+    await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR version: 3')
   })
 
-  it('bad header', async () => {
-    // sanity check, this should be fine
-    let buf2 = makeHeader({ version: 1, roots: [] })
-    await assert.isFulfilled(CarReader.fromBytes(buf2))
+  describe('bad header', async () => {
+    it('sanity check', async () => {
+      // sanity check, this should be fine
+      const buf2 = makeHeader({ version: 1, roots: [] })
+      await assert.isFulfilled(CarReader.fromBytes(buf2))
+    })
 
-    // no 'version' array
-    buf2 = makeHeader({ roots: [] })
-    await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR version: undefined')
+    it('no \'version\' array', async () => {
+      const buf2 = makeHeader({ roots: [] })
+      await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format')
+    })
 
-    // bad 'version' type
-    buf2 = makeHeader({ version: '1', roots: [] })
-    await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR version: "1"')
+    it('bad \'version\' type', async () => {
+      const buf2 = makeHeader({ version: '1', roots: [] })
+      await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format')
+    })
+
+    it('no \'roots\' array', async () => {
+      const buf2 = makeHeader({ version: 1 })
+      await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format')
+    })
 
-    // no 'roots' array
-    buf2 = makeHeader({ version: 1 })
-    await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format')
+    it('bad \'roots\' type', async () => {
+      const buf2 = makeHeader({ version: 1, roots: {} })
+      await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format')
+    })
 
-    // bad 'roots' type
-    buf2 = makeHeader({ version: 1, roots: {} })
-    await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format')
+    it('extraneous properties', async () => {
+      const buf2 = makeHeader({ version: 1, roots: [], blip: true })
+      await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format')
+    })
 
-    // extraneous properties
-    buf2 = makeHeader({ version: 1, roots: [], blip: true })
-    await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format')
+    it('not an object', async () => {
+      const buf2 = makeHeader([1, []])
+      await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format')
+    })
 
-    // not an object
-    buf2 = makeHeader([1, []])
-    await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format')
+    it('not an object', async () => {
+      const buf2 = makeHeader(null)
+      await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format')
+    })
 
-    // not an object
-    buf2 = makeHeader(null)
-    await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format')
+    it('recursive v2 header', async () => {
+      // first 51 bytes are the carv2 header:
+      //   11b prefix, 16b characteristics, 8b data offset, 8b data size, 8b index offset
+      const v2Header = goCarV2Bytes.slice(0, 51)
+      // parser should expect to get a carv1 header at the data offset, but it uses the same
+      // code to check the carv2 header so let's make sure it doesn't allow recursive carv2
+      // headers
+      const buf2 = new Uint8Array(51 * 2)
+      buf2.set(v2Header, 0)
+      buf2.set(v2Header, 51)
+      await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR version: 2 (expected 1)')
+    })
   })
 })

package/test/test-indexer.js

@@ -1,7 +1,15 @@
 /* eslint-env mocha */
 
 import { CarIndexer } from '@ipld/car/indexer'
-import { goCarBytes, goCarIndex, makeIterable, assert } from './common.js'
+import {
+  goCarBytes,
+  goCarIndex,
+  goCarV2Bytes,
+  goCarV2Roots,
+  goCarV2Index,
+  makeIterable,
+  assert
+} from './common.js'
 import { verifyRoots } from './verify-store-reader.js'
 
 describe('CarIndexer fromBytes()', () => {
@@ -18,6 +26,21 @@ describe('CarIndexer fromBytes()', () => {
     assert.deepStrictEqual(indexData, goCarIndex)
   })
 
+  it('v2 complete', async () => {
+    const indexer = await CarIndexer.fromBytes(goCarV2Bytes)
+    const roots = await indexer.getRoots()
+    assert.strictEqual(roots.length, 1)
+    assert(goCarV2Roots[0].equals(roots[0]))
+    assert.strictEqual(indexer.version, 2)
+
+    const indexData = []
+    for await (const index of indexer) {
+      indexData.push(index)
+    }
+
+    assert.deepStrictEqual(indexData, goCarV2Index)
+  })
+
   it('bad argument', async () => {
     for (const arg of [true, false, null, undefined, 'string', 100, { obj: 'nope' }]) {
       // @ts-ignore

package/test/test-reader.js

@@ -2,10 +2,21 @@
 
 import { CarReader } from '@ipld/car/reader'
 import { CarWriter } from '@ipld/car/writer'
+import { bytesReader, readHeader } from '@ipld/car/decoder'
 import * as Block from 'multiformats/block'
 import { sha256 } from 'multiformats/hashes/sha2'
 import * as raw from 'multiformats/codecs/raw'
-import { carBytes, makeIterable, assert } from './common.js'
+import { base64 } from 'multiformats/bases/base64'
+import * as dagPb from '@ipld/dag-pb'
+import {
+  carBytes,
+  makeIterable,
+  assert,
+  goCarV2Bytes,
+  goCarV2Roots,
+  goCarV2Index,
+  goCarV2Contents
+} from './common.js'
 import {
   verifyRoots,
   verifyHas,
@@ -13,6 +24,8 @@ import {
   verifyBlocks,
   verifyCids
 } from './verify-store-reader.js'
+import { data as fixtures } from './fixtures.js'
+import { expectations as fixtureExpectations } from './fixtures-expectations.js'
 
 describe('CarReader fromBytes()', () => {
   it('complete', async () => {
@@ -48,6 +61,30 @@ describe('CarReader fromBytes()', () => {
     })
   })
 
+  it('v2 complete', async () => {
+    const reader = await CarReader.fromBytes(goCarV2Bytes)
+    const roots = await reader.getRoots()
+    assert.strictEqual(roots.length, 1)
+    assert(goCarV2Roots[0].equals(roots[0]))
+    assert.strictEqual(reader.version, 2)
+    for (const { cid } of goCarV2Index) {
+      const block = await reader.get(cid)
+      assert.isDefined(block)
+      if (block) {
+        assert(cid.equals(block.cid))
+        let content
+        if (cid.code === dagPb.code) {
+          content = dagPb.decode(block.bytes)
+        } else if (cid.code === 85) { // raw
+          content = new TextDecoder().decode(block.bytes)
+        } else {
+          assert.fail('Unexpected codec')
+        }
+        assert.deepStrictEqual(content, goCarV2Contents[cid.toString()])
+      }
+    }
+  })
+
   it('decode error - trailing null bytes', async () => {
     const bytes = new Uint8Array(carBytes.length + 5)
     bytes.set(carBytes)
@@ -149,4 +186,60 @@ describe('CarReader fromIterable()', () => {
       message: 'Unexpected end of data'
     })
   })
+
+  it('v2 decode error - truncated', async () => {
+    const bytes = goCarV2Bytes.slice()
+    const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+    // dataSize is an 64-bit uint at byte offset 35 from the begining, we're shortening it
+    // by 10 to simulate a premature end of CARv1 content
+    dv.setBigUint64(35, BigInt(448 - 10), true)
+    await assert.isRejected(CarReader.fromIterable(makeIterable(bytes, 64)), {
+      name: 'Error',
+      message: 'Unexpected end of data'
+    })
+  })
+})
+
+describe('Shared fixtures', () => {
+  describe('Header', () => {
+    for (const [name, { version: expectedVersion, err: expectedError }] of Object.entries(fixtureExpectations)) {
+      it(name, async () => {
+        const data = base64.baseDecode(fixtures[name])
+        let header
+        try {
+          header = await readHeader(bytesReader(data))
+        } catch (err) {
+          if (expectedError != null) {
+            assert.equal(err.message, expectedError)
+            return
+          }
+          assert.ifError(err)
+        }
+        if (expectedError != null) {
+          assert.fail(`Expected error: ${expectedError}`)
+        }
+        assert.isDefined(header, 'did not decode header')
+        if (expectedVersion != null && header != null) {
+          assert.strictEqual(header.version, expectedVersion)
+        }
+      })
+    }
+  })
+
+  describe('Contents', () => {
+    for (const [name, { cids: expectedCids }] of Object.entries(fixtureExpectations)) {
+      if (expectedCids == null) {
+        continue
+      }
+      it(name, async () => {
+        const data = base64.baseDecode(fixtures[name])
+        const reader = await CarReader.fromBytes(data)
+        let i = 0
+        for await (const cid of reader.cids()) {
+          assert.strictEqual(cid.toString(), expectedCids[i++])
+        }
+        assert.strictEqual(i, expectedCids.length)
+      })
+    }
+  })
 })

package/tsconfig.json

@@ -31,10 +31,12 @@
     "paths": {
       "@ipld/car": [ "car.js", "car-browser.js", "lib/" ],
       "@ipld/car/writer": [ "./lib/writer.js" ],
+      "@ipld/car/buffer-writer": ["./lib/buffer-writer.js"],
       "@ipld/car/reader": [ "./lib/reader.js" ],
       "@ipld/car/indexed-reader": [ "./lib/indexed-reader.js" ],
       "@ipld/car/iterator": [ "./lib/iterator.js" ],
-      "@ipld/car/indexer": [ "./lib/indexer.js" ]
+      "@ipld/car/indexer": [ "./lib/indexer.js" ],
+      "@ipld/car/decoder": [ "./lib/decoder.js" ],
     }
   },
   "exclude": [

package/types/api.d.ts

@@ -1,4 +1,5 @@
 import { CID } from 'multiformats/cid';
+export type { CID };
 export declare type Block = {
     cid: CID;
     bytes: Uint8Array;
@@ -30,6 +31,21 @@ export interface BlockWriter {
     put(block: Block): Promise<void>;
     close(): Promise<void>;
 }
+export interface CarBufferWriter {
+    addRoot(root: CID, options?: {
+        resize?: boolean;
+    }): CarBufferWriter;
+    write(block: Block): CarBufferWriter;
+    close(options?: {
+        resize?: boolean;
+    }): Uint8Array;
+}
+export interface CarBufferWriterOptions {
+    roots?: CID[];
+    byteOffset?: number;
+    byteLength?: number;
+    headerSize?: number;
+}
 export interface WriterChannel {
     writer: BlockWriter;
     out: AsyncIterable<Uint8Array>;

package/types/api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAItC,oBAAY,KAAK,GAAG;IAAE,GAAG,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,CAAA;AAEnD,oBAAY,WAAW,GAAG;IACxB,GAAG,EAAE,GAAG,CAAC;IACT,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,oBAAY,UAAU,GAAG,WAAW,GAAG;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC,CAAA;CAC3B;AAED,MAAM,WAAW,aAAc,SAAQ,aAAa,CAAC,KAAK,CAAC;CAAG;AAE9D,MAAM,WAAW,WAAY,SAAQ,aAAa,CAAC,GAAG,CAAC;CAAG;AAE1D,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC/B,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAA;IACzC,MAAM,IAAI,aAAa,CAAA;IACvB,IAAI,IAAI,WAAW,CAAA;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAChC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,WAAW,CAAA;IACnB,GAAG,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;CAC/B;AAED,MAAM,WAAW,SAAU,SAAQ,WAAW,EAAE,WAAW;CAAG"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAEtC,YAAY,EAAE,GAAG,EAAE,CAAA;AAGnB,oBAAY,KAAK,GAAG;IAClB,GAAG,EAAE,GAAG,CAAA;IACR,KAAK,EAAE,UAAU,CAAA;CAClB,CAAA;AAED,oBAAY,WAAW,GAAG;IACxB,GAAG,EAAE,GAAG,CAAA;IACR,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,oBAAY,UAAU,GAAG,WAAW,GAAG;IACrC,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC,CAAA;CAC3B;AAED,MAAM,WAAW,aAAc,SAAQ,aAAa,CAAC,KAAK,CAAC;CAAG;AAE9D,MAAM,WAAW,WAAY,SAAQ,aAAa,CAAC,GAAG,CAAC;CAAG;AAE1D,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC/B,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAA;IACzC,MAAM,IAAI,aAAa,CAAA;IACvB,IAAI,IAAI,WAAW,CAAA;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAChC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,IAAI,EAAC,GAAG,EAAE,OAAO,CAAC,EAAC;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAE,eAAe,CAAA;IAChE,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,eAAe,CAAA;IACpC,KAAK,CAAC,OAAO,CAAC,EAAC;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,UAAU,CAAA;CACjD;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAA;IACb,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,WAAW,CAAA;IACnB,GAAG,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;CAC/B;AAED,MAAM,WAAW,SAAU,SAAQ,WAAW,EAAE,WAAW;CAAG"}

package/types/lib/buffer-writer.d.ts

@@ -0,0 +1,86 @@
+export function addRoot(writer: CarBufferWriter, root: CID, { resize }?: {
+    resize?: boolean | undefined;
+} | undefined): void;
+export function blockLength({ cid, bytes }: Block): number;
+export function addBlock(writer: CarBufferWriter, { cid, bytes }: Block): void;
+export function close(writer: CarBufferWriter, { resize }?: {
+    resize?: boolean | undefined;
+} | undefined): Uint8Array;
+export function resizeHeader(writer: CarBufferWriter, byteLength: number): void;
+export function calculateHeaderLength(rootLengths: number[]): number;
+export function headerLength({ roots }: {
+    roots: CID[];
+}): number;
+export function estimateHeaderLength(rootCount: number, rootByteLength?: number | undefined): number;
+export function createWriter(buffer: ArrayBuffer, { roots, byteOffset, byteLength, headerSize }?: {
+    roots?: import("multiformats/cid").CID[] | undefined;
+    byteOffset?: number | undefined;
+    byteLength?: number | undefined;
+    headerSize?: number | undefined;
+} | undefined): CarBufferWriter;
+export type CID = import('../api').CID;
+export type Block = import('../api').Block;
+export type Writer = import('../api').CarBufferWriter;
+export type Options = import('../api').CarBufferWriterOptions;
+export type CarEncoder = import('./coding').CarEncoder;
+/**
+ * @typedef {import('../api').CID} CID
+ * @typedef {import('../api').Block} Block
+ * @typedef {import('../api').CarBufferWriter} Writer
+ * @typedef {import('../api').CarBufferWriterOptions} Options
+ * @typedef {import('./coding').CarEncoder} CarEncoder
+ */
+/**
+ * A simple CAR writer that writes to a pre-allocated buffer.
+ *
+ * @class
+ * @name CarBufferWriter
+ * @implements {Writer}
+ */
+declare class CarBufferWriter implements Writer {
+    /**
+     * @param {Uint8Array} bytes
+     * @param {number} headerSize
+     */
+    constructor(bytes: Uint8Array, headerSize: number);
+    /** @readonly */
+    readonly bytes: Uint8Array;
+    byteOffset: number;
+    /**
+     * @readonly
+     * @type {CID[]}
+     */
+    readonly roots: CID[];
+    headerSize: number;
+    /**
+     * Add a root to this writer, to be used to create a header when the CAR is
+     * finalized with {@link CarBufferWriter.close `close()`}
+     *
+     * @param {CID} root
+     * @param {{resize?:boolean}} [options]
+     * @returns {CarBufferWriter}
+     */
+    addRoot(root: CID, options?: {
+        resize?: boolean | undefined;
+    } | undefined): CarBufferWriter;
+    /**
+     * Write a `Block` (a `{ cid:CID, bytes:Uint8Array }` pair) to the archive.
+     * Throws if there is not enough capacity.
+     *
+     * @param {Block} block A `{ cid:CID, bytes:Uint8Array }` pair.
+     * @returns {CarBufferWriter}
+     */
+    write(block: Block): CarBufferWriter;
+    /**
+     * Finalize the CAR and return it as a `Uint8Array`.
+     *
+     * @param {object} [options]
+     * @param {boolean} [options.resize]
+     * @returns {Uint8Array}
+     */
+    close(options?: {
+        resize?: boolean | undefined;
+    } | undefined): Uint8Array;
+}
+export {};
+//# sourceMappingURL=buffer-writer.d.ts.map

package/types/lib/buffer-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-writer.d.ts","sourceRoot":"","sources":["../../lib/buffer-writer.js"],"names":[],"mappings":"AAgFO,gCAJI,eAAe,QACf,GAAG;;qBA0Bb;AAUM,4CAHI,KAAK,GACH,MAAM,CAKlB;AAMM,iCAHI,eAAe,kBACf,KAAK,QAYf;AAOM,8BAJI,eAAe;;2BA2BzB;AAMM,qCAHI,eAAe,cACf,MAAM,QAShB;AAqCM,mDAHI,MAAM,EAAE,GACN,MAAM,CAWlB;AAUM;IAHmB,KAAK,EAApB,GAAG,EAAE;IACH,MAAM,CAG4C;AAYxD,gDAJI,MAAM,wCAEJ,MAAM,CAG+C;AAuB3D,qCARI,WAAW;;;;;gBAMT,eAAe,CAmB3B;kBAvRY,OAAO,QAAQ,EAAE,GAAG;oBACpB,OAAO,QAAQ,EAAE,KAAK;qBACtB,OAAO,QAAQ,EAAE,eAAe;sBAChC,OAAO,QAAQ,EAAE,sBAAsB;yBACvC,OAAO,UAAU,EAAE,UAAU;AAL1C;;;;;;GAMG;AAEH;;;;;;GAMG;AACH;IACE;;;OAGG;IACH,mBAHW,UAAU,cACV,MAAM,EAahB;IAVC,gBAAgB;IAChB,2BAAkB;IAClB,mBAA4B;IAE5B;;;OAGG;IACH,gBAFU,GAAG,EAAE,CAEA;IACf,mBAA4B;IAG9B;;;;;;;OAOG;IACH,cAJW,GAAG;;oBAED,eAAe,CAK3B;IAED;;;;;;OAMG;IACH,aAHW,KAAK,GACH,eAAe,CAK3B;IAED;;;;;;OAMG;IACH;;oBAFa,UAAU,CAItB;CACF"}