Multiformats

https://multiformats.github.io/js-multiformats/
Admin
Multiformats is a JavaScript library providing interfaces and building blocks for multiformat...
Tokens:14,078
Snippets:129
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install multiformats via npm

Source: https://multiformats.github.io/js-multiformats

Use this command to add the library to your project dependencies.

```bash
$ npm i multiformats
```

--------------------------------

### walk(options)

Source: https://multiformats.github.io/js-multiformats/functions/traversal.walk.html

Traverses a data structure starting from a given CID, using a provided load function to resolve blocks.

```APIDOC
## walk(options)

### Description
Traverses a multiformat data structure starting from the provided CID. It uses a custom load function to fetch blocks during the traversal.

### Parameters
- **options** (Object) - Required
  - **cid** (CID) - Required - The starting CID for the traversal.
  - **seen** (Set<string>) - Optional - A set of CIDs already visited to prevent cycles.
  - **load** (Function) - Required - A function that takes a CID and returns a Promise resolving to a BlockView or null.

### Returns
- **Promise<void>** - A promise that resolves when the traversal is complete.
```

--------------------------------

### decode(data: Uint8Array, offset?: number)

Source: https://multiformats.github.io/js-multiformats/functions/index.varint.decode.html

Decodes a varint from the provided Uint8Array starting at the specified offset.

```APIDOC
## decode(data: Uint8Array, offset?: number)

### Description
Decodes a varint from a Uint8Array. Returns a tuple containing the decoded number and the number of bytes read.

### Parameters
- **data** (Uint8Array) - Required - The source data containing the varint.
- **offset** (number) - Optional - The starting position in the data array. Defaults to 0.

### Returns
- **[number, number]** - A tuple where the first element is the decoded value and the second element is the number of bytes consumed.
```

--------------------------------

### Create and Decode Blocks

Source: https://multiformats.github.io/js-multiformats

Shows how to encode, decode, and verify data blocks using a specific codec and hasher.

```javascript
import * as Block from 'multiformats/block'  
import * as codec from '@ipld/dag-cbor'  
import { sha256 as hasher } from 'multiformats/hashes/sha2'  
  
const value = { hello: 'world' }  
  
// encode a block  
let block = await Block.encode({ value, codec, hasher })  
  
block.value // { hello: 'world' }  
block.bytes // Uint8Array  
block.cid   // CID() w/ sha2-256 hash address and dag-cbor codec  
  
// you can also decode blocks from their binary state  
block = await Block.decode({ bytes: block.bytes, codec, hasher })  
  
// if you have the cid you can also verify the hash on decode  
block = await Block.create({ bytes: block.bytes, cid: block.cid, codec, hasher })
```

--------------------------------

### create<T, Code, Alg, V>

Source: https://multiformats.github.io/js-multiformats/functions/block.create.html

Creates a new block from the provided input parameters, returning a promise that resolves to a BlockView.

```APIDOC
## create<T, Code, Alg, V>

### Description
Creates a new block instance using the specified codec and hashing algorithm.

### Signature
`create<T, Code extends number, Alg extends number, V extends Version>(__namedParameters: CreateInput<T, Code, Alg, V>): Promise<BlockView<T, Code, Alg, V>>`

### Type Parameters
- **T**: Logical type of the data encoded in the block.
- **Code**: Multicodec code corresponding to the codec used to encode the block.
- **Alg**: Multicodec code corresponding to the hashing algorithm used in CID creation.
- **V**: CID version.

### Parameters
- **__namedParameters** (CreateInput<T, Code, Alg, V>) - The input configuration for creating the block.

### Returns
- **Promise<BlockView<T, Code, Alg, V>>** - A promise that resolves to the created BlockView.
```

--------------------------------

### CID Constructor

Source: https://multiformats.github.io/js-multiformats/classes/cid.CID.html

Creates a new instance of a CID.

```APIDOC
## constructor

### Description
Creates a new CID instance representing an IPLD link.

### Signature
new CID<Data, Format, Alg, Version>(version: Version, code: Format, multihash: MultihashDigest<Alg>, bytes: Uint8Array)

### Parameters
- **version** (Version) - The version of the CID.
- **code** (Format) - The multicodec code of the codec the content is encoded in.
- **multihash** (MultihashDigest<Alg>) - The multihash of the content.
- **bytes** (Uint8Array) - The raw byte representation of the CID.
```

--------------------------------

### Create a CID with JSON codec

Source: https://multiformats.github.io/js-multiformats

Demonstrates encoding a JSON object and creating a CID using the SHA-256 hashing algorithm.

```javascript
import { CID } from 'multiformats/cid'  
import * as json from 'multiformats/codecs/json'  
import { sha256 } from 'multiformats/hashes/sha2'  
  
const bytes = json.encode({ hello: 'world' })  
  
const hash = await sha256.digest(bytes)  
const cid = CID.create(1, json.code, hash)  
//> CID(bagaaierasords4njcts6vs7qvdjfcvgnume4hqohf65zsfguprqphs3icwea)
```

--------------------------------

### parse<Prefix, Data, Code, Alg, Ver>(source, base?)

Source: https://multiformats.github.io/js-multiformats/functions/link.parse.html

Takes a CID in a string representation and creates a Link instance. If a base decoder is not provided, it uses a default from the configuration. It throws an error if the encoding of the CID is not compatible with the supplied or default decoder.

```APIDOC
## parse<Prefix, Data, Code, Alg, Ver>(source, base?)

### Description
Takes a CID in a string representation and creates a Link instance. If a base decoder is not provided, it uses a default from the configuration. It throws an error if the encoding of the CID is not compatible with the supplied or default decoder.

### Parameters
- **source** (ToString<Link<Data, Code, Alg, Ver>, Prefix>) - Required - The string representation of the CID.
- **base** (MultibaseDecoder<Prefix>) - Optional - The multibase decoder to use for parsing.

### Returns
- **Link<Data, Code, Alg, Ver>** - An instance of the Link.
```

--------------------------------

### Hasher Constructor

Source: https://multiformats.github.io/js-multiformats/classes/hashes_hasher.Hasher.html

Creates a new instance of a Hasher with the specified name, code, and encoding function.

```APIDOC
## constructor(name, code, encode, minDigestLength?, maxDigestLength?)

### Description
Initializes a new Hasher instance for a specific hashing algorithm.

### Parameters
- **name** (Name) - Required - The name of the multihash.
- **code** (Code) - Required - The code of the multihash.
- **encode** ((input: Uint8Array) => Await<Uint8Array<ArrayBuffer>>) - Required - Function that returns the raw digest representation of the binary input.
- **minDigestLength** (number) - Optional - Minimum length of the digest.
- **maxDigestLength** (number) - Optional - Maximum length of the digest.
```

--------------------------------

### Multibase Encoding and Decoding

Source: https://multiformats.github.io/js-multiformats

Demonstrates how to serialize a CID to a string using a multibase encoder and parse a CID string using a multibase decoder.

```APIDOC
## cid.toString(encoder)

### Description
Serializes a CID to a string representation using the provided multibase encoder.

### Usage
```javascript
import { base64 } from "multiformats/bases/base64"
cid.toString(base64.encoder)
```

## CID.parse(string, decoder)

### Description
Parses a CID string into a CID object using the provided multibase decoder.

### Usage
```javascript
CID.parse('mAYAEEiCTojlxqRTl6svwqNJRVM2jCcPBxy+7mRTUfGDzy2gViA', base64.decoder)
```

## Multibase Codecs

### Description
Multibase codecs implement both `MultibaseEncoder` and `MultibaseDecoder` interfaces, allowing them to be used directly for both serialization and parsing.

### Usage
```javascript
cid.toString(base64)
CID.parse(cid.toString(base64), base64)
```
```

--------------------------------

### create<Data, Code, Alg>(code, digest)

Source: https://multiformats.github.io/js-multiformats/functions/link.create.html

Creates a CIDv1 link using the provided content encoding code and multihash digest.

```APIDOC
## create<Data, Code extends number, Alg extends number>(code, digest)

### Description
Creates a simplified CIDv1 link.

### Parameters
- **code** (Code) - Required - Content encoding format code.
- **digest** (MultihashDigest<Alg>) - Required - Multihash of the content.

### Returns
- **Link<Data, Code, Alg>** - The resulting CIDv1 link.
```

--------------------------------

### createUnsafe<T, Code, Alg, V>

Source: https://multiformats.github.io/js-multiformats/functions/block.createUnsafe.html

Creates a BlockView instance using the provided input parameters including the logical data type, multicodec codes, and CID version.

```APIDOC
## createUnsafe<T, Code, Alg, V>

### Description
Creates a new BlockView instance. This function is used to construct a block from its constituent parts without performing internal validation checks.

### Signature
`createUnsafe<T, Code extends number, Alg extends number, V extends Version>(__namedParameters: CreateUnsafeInput<T, Code, Alg, V>): BlockView<T, Code, Alg, V>`

### Type Parameters
- **T**: Logical type of the data encoded in the block.
- **Code**: Multicodec code corresponding to the codec used to encode the block.
- **Alg**: Multicodec code corresponding to the hashing algorithm used in CID creation.
- **V**: CID version.

### Parameters
- **__namedParameters** (CreateUnsafeInput<T, Code, Alg, V>) - Required - The input object containing the data, codec, hashing algorithm, and CID version information.

### Returns
- **BlockView<T, Code, Alg, V>** - The constructed block view.
```

--------------------------------

### Load multiformats via script tag

Source: https://multiformats.github.io/js-multiformats

Include this script tag to access the library as the Multiformats global object in browser environments.

```html
<script src="https://unpkg.com/multiformats/dist/index.min.js"></script>
```

--------------------------------

### new Digest<Code, Size>(code, size, digest, bytes)

Source: https://multiformats.github.io/js-multiformats/classes/hashes_digest.Digest.html

Constructor for creating a new multihash digest instance.

```APIDOC
## Constructor

### Description
Creates a new instance of a multihash digest.

### Signature
`new Digest<Code, Size>(code: Code, size: Size, digest: Uint8Array, bytes: Uint8Array): Digest<Code, Size>`

### Parameters
- **code** (Code) - The multihash algorithm code.
- **size** (Size) - The byte length of the digest.
- **digest** (Uint8Array) - The raw hash digest.
- **bytes** (Uint8Array) - The full binary representation of the multihash digest.
```

--------------------------------

### format<T, Prefix>(link: T, base?: MultibaseEncoder<Prefix>): ToString<T, Prefix>

Source: https://multiformats.github.io/js-multiformats/functions/cid.format.html

Converts a CID link into a string representation. The optional base parameter allows specifying a multibase encoder for the output string.

```APIDOC
## format(link, base?)

### Description
Converts a CID link into its string representation. Optionally accepts a multibase encoder to format the resulting string.

### Parameters
- **link** (T extends Link<unknown, number, number, Version>) - Required - The CID link to format.
- **base** (MultibaseEncoder<Prefix>) - Optional - The multibase encoder to use for the string output.

### Returns
- **ToString<T, Prefix>** - The string representation of the CID.
```

--------------------------------

### Use Multibase Codecs

Source: https://multiformats.github.io/js-multiformats

Multibase codecs implement both encoder and decoder interfaces for convenience.

```javascript
cid.toString(base64)  
CID.parse(cid.toString(base64), base64)
```

--------------------------------

### walk()

Source: https://multiformats.github.io/js-multiformats/modules/index.html

The walk function traverses graphs of data by following links in each block of a DAG. It uses a user-supplied loader function to fetch blocks in depth-first order.

```APIDOC
## walk(options)

### Description
Walks through the links in each block of a DAG calling a user-supplied loader function for each one, in depth-first order with no duplicate block visits.

### Parameters
- **cid** (CID) - Required - The root CID to start the traversal from.
- **load** (Function) - Required - A loader function that takes a CID and returns a Block object, or null to skip the block.
```

--------------------------------

### Implement a Multihash Hasher

Source: https://multiformats.github.io/js-multiformats

Uses the hasher utility to create a custom hash function, which can then be used to generate digests for CIDs.

```javascript
import * as hasher from 'multiformats/hashes/hasher'  
  
const sha256 = hasher.from({  
  // As per multiformats table  
  // https://github.com/multiformats/multicodec/blob/master/table.csv#L9  
  name: 'sha2-256',  
  code: 0x12,  
  
  encode: (input) => new Uint8Array(crypto.createHash('sha256').update(input).digest())  
})  
  
const hash = await sha256.digest(json.encode({ hello: 'world' }))  
CID.create(1, json.code, hash)  
  
//> CID(bagaaierasords4njcts6vs7qvdjfcvgnume4hqohf65zsfguprqphs3icwea)
```

--------------------------------

### digest(input, options?)

Source: https://multiformats.github.io/js-multiformats/interfaces/hashes_interface.MultihashHasher.html

Generates a multihash digest from the provided binary input. The method returns either a MultihashDigest or a Promise resolving to one, allowing for both synchronous and asynchronous usage.

```APIDOC
## digest(input, options?)

### Description
Takes binary input and returns its multihash digest. The return value is either a promise of a digest or a digest directly, allowing performance-critical code to avoid unnecessary awaiting.

### Parameters
- **input** (Uint8Array) - Required - The binary data to hash.
- **options** (DigestOptions) - Optional - Configuration options for the hashing process.

### Returns
- **MultihashDigest<Code> | Promise<MultihashDigest<Code>>** - The resulting multihash digest.
```

--------------------------------

### Traverse a DAG with walk()

Source: https://multiformats.github.io/js-multiformats

Performs a depth-first traversal of a DAG using a loader function to resolve blocks by CID.

```javascript
import { walk } from 'multiformats/traversal'  
import * as Block from 'multiformats/block'  
import * as codec from 'multiformats/codecs/json'  
import { sha256 as hasher } from 'multiformats/hashes/sha2'  
  
// build a DAG (a single block for this simple example)  
const value = { hello: 'world' }  
const block = await Block.encode({ value, codec, hasher })  
const { cid } = block  
console.log(cid)  
//> CID(bagaaierasords4njcts6vs7qvdjfcvgnume4hqohf65zsfguprqphs3icwea)  
  
// create a loader function that also collects CIDs of blocks in  
// their traversal order  
const load = (cid, blocks) => async (cid) => {  
  // fetch a block using its cid  
  // e.g.: const block = await fetchBlockByCID(cid)  
  blocks.push(cid)  
  return block  
}  
  
// collect blocks in this DAG starting from the root `cid`  
const blocks = []  
await walk({ cid, load: load(cid, blocks) })  
  
console.log(blocks)  
//> [CID(bagaaierasords4njcts6vs7qvdjfcvgnume4hqohf65zsfguprqphs3icwea)]
```

--------------------------------

### encode(input)

Source: https://multiformats.github.io/js-multiformats/interfaces/hashes_interface.MultihashHasher.html

Returns the raw digest representation of the binary input, excluding the hashing codec prefix.

```APIDOC
## encode(input)

### Description
Returns the raw digest representation of the binary input (e.g., without the hashing codec prefix).

### Parameters
- **input** (Uint8Array) - Required - The binary data to encode.

### Returns
- **Uint8Array<ArrayBuffer> | Promise<Uint8Array<ArrayBuffer>>** - The raw digest bytes.
```

--------------------------------

### from<Name, Code>(HasherInit<Name, Code>): MultihashHasher<Code>

Source: https://multiformats.github.io/js-multiformats/functions/hashes_hasher.from.html

Creates a new MultihashHasher instance based on the provided initialization object.

```APIDOC
## from<Name, Code>(HasherInit<Name, Code>)

### Description
Creates a new MultihashHasher instance. This function is used to define a hasher by providing its name and code.

### Parameters
- **__namedParameters** (HasherInit<Name, Code>) - Required - An object containing the initialization configuration for the hasher, including the name and code.

### Returns
- **MultihashHasher<Code>** - Returns a configured MultihashHasher instance.
```

--------------------------------

### HasherInit Interface

Source: https://multiformats.github.io/js-multiformats/interfaces/hashes_hasher.HasherInit.html

The HasherInit interface defines the configuration and encoding requirements for a hasher implementation.

```APIDOC
## Interface HasherInit<Name, Code>

### Description
Defines the properties and methods required to initialize a hasher in the multiformats library.

### Properties
- **code** (Code) - The numeric code for the hasher.
- **name** (Name) - The string name of the hasher.
- **maxDigestLength** (number, optional) - The maximum length a hash is allowed to be truncated to in bytes.
- **minDigestLength** (number, optional) - The minimum length a hash is allowed to be truncated to in bytes (Default: 20).

### Methods
#### encode(input: Uint8Array)
Encodes the provided input into a digest.
- **Parameters**:
  - **input** (Uint8Array) - The data to hash.
- **Returns**: Await<Uint8Array<ArrayBuffer>>
```

--------------------------------

### reduce(callbackfn, initialValue?)

Source: https://multiformats.github.io/js-multiformats/interfaces/block_interface.ByteView.html

Calls the specified callback function for all the elements in an array to accumulate a result.

```APIDOC
## reduce(callbackfn, initialValue?)

### Description
Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

### Parameters
- **callbackfn** ((previousValue: U, currentValue: number, currentIndex: number, array: this) => U) - Required - A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
- **initialValue** (U) - Optional - If initialValue is specified, it is used as the initial value to start the accumulation.

### Returns
- **U**
```

--------------------------------

### DigestOptions

Source: https://multiformats.github.io/js-multiformats/interfaces/hashes_hasher.DigestOptions.html

Configuration options for digest generation, including truncation settings.

```APIDOC
## Interface: DigestOptions

### Description
Configuration options for hashing operations. Currently supports truncating the output digest.

### Properties
- **truncate** (number) - Optional - Truncate the returned digest to this number of bytes. Note that this may cause the operation to throw if the value is greater than the digest length or below a threshold where collision risk is significant.
```

--------------------------------

### BlockView Interface

Source: https://multiformats.github.io/js-multiformats/interfaces/block_interface.BlockView.html

The BlockView interface defines the structure for interacting with IPLD blocks, providing properties for data access and methods for block traversal.

```APIDOC
## Interface BlockView<T, C, A, V>

### Description
Represents an IPLD block (including its CID) that can be decoded to data of type T.

### Properties
- **bytes** (ByteView<T>) - The raw bytes of the block.
- **cid** (CID<T, C, A, V>) - The CID associated with the block.
- **value** (T) - The decoded value of the block.

### Methods
#### get(path: string)
Returns a BlockCursorView for the specified path.
- **path** (string) - The path to traverse.

#### links()
Returns an iterable of links contained within the block.
- **Returns** (Iterable<[string, CID<unknown, number, number, Version>]>)

#### tree()
Returns an iterable of all paths available in the block.
- **Returns** (Iterable<string>)
```

--------------------------------

### createLegacy(digest: MultihashDigest<18>): LegacyLink

Source: https://multiformats.github.io/js-multiformats/functions/link.createLegacy.html

Creates a legacy CIDv0 link from a provided multihash digest.

```APIDOC
## createLegacy(digest: MultihashDigest<18>): LegacyLink

### Description
Simplified version of `create` for CIDv0.

### Parameters
- **digest** (MultihashDigest<18>) - Required - The multihash digest to convert into a legacy link.

### Returns
- **LegacyLink** - The resulting CIDv0 legacy link.
```

--------------------------------

### toArrayBufferBackedArray(b: Uint8Array)

Source: https://multiformats.github.io/js-multiformats/functions/bytes.toArrayBufferBackedArray.html

Ensures the provided Uint8Array is backed by an ArrayBuffer. If the input is not backed by an ArrayBuffer, a new Uint8Array is created and the contents are copied into it.

```APIDOC
## toArrayBufferBackedArray(b: Uint8Array)

### Description
Ensures that the provided `Uint8Array` is backed by an `ArrayBuffer`. If the input is not backed by an `ArrayBuffer`, a new `Uint8Array` is created and the contents of `b` are copied into it.

### Parameters
- **b** (Uint8Array) - The input byte array to check.

### Returns
- **Uint8Array<ArrayBuffer>** - A `Uint8Array` that is guaranteed to be backed by an `ArrayBuffer`.
```

--------------------------------

### fromJSON<Link extends UnknownLink>(json: LinkJSON<Link>): CID<unknown, number, number, Version>

Source: https://multiformats.github.io/js-multiformats/functions/cid.fromJSON.html

Reconstructs a CID instance from a provided JSON object.

```APIDOC
## fromJSON

### Description
Reconstructs a CID instance from a provided JSON object.

### Signature
`fromJSON<Link extends UnknownLink>(json: LinkJSON<Link>): CID<unknown, number, number, Version>`

### Parameters
- **json** (LinkJSON<Link>) - Required - The JSON representation of the CID to be reconstructed.

### Returns
- **CID<unknown, number, number, Version>** - A new CID instance.
```

--------------------------------

### toHex(d: Uint8Array): string

Source: https://multiformats.github.io/js-multiformats/functions/bytes.toHex.html

Converts a Uint8Array into a hexadecimal string.

```APIDOC
## toHex(d: Uint8Array): string

### Description
Converts a Uint8Array into its hexadecimal string representation.

### Parameters
- **d** (Uint8Array) - Required - The byte array to convert.

### Returns
- **string** - The hexadecimal representation of the input bytes.
```

--------------------------------

### create<Code extends number>(code: Code, digest: Uint8Array): Digest<Code, number>

Source: https://multiformats.github.io/js-multiformats/functions/hashes_digest.create.html

Creates a multihash digest from a provided code and digest byte array.

```APIDOC
## create(code, digest)

### Description
Creates a multihash digest.

### Signature
`create<Code extends number>(code: Code, digest: Uint8Array): Digest<Code, number>`

### Parameters
- **code** (Code extends number) - Required - The multihash code.
- **digest** (Uint8Array) - Required - The digest byte array.

### Returns
- **Digest<Code, number>** - A new multihash digest object.
```

--------------------------------

### toString(b: Uint8Array): string

Source: https://multiformats.github.io/js-multiformats/functions/bytes.toString.html

Converts the passed byte array to a string, interpreting each byte as a single character.

```APIDOC
## toString(b: Uint8Array): string

### Description
Converts the passed byte array to a string, interpreting each byte as a single character.

### Parameters
- **b** (Uint8Array) - Required - The byte array to convert.

### Returns
- **string** - The resulting string representation of the byte array.
```

--------------------------------

### CID.inspectBytes

Source: https://multiformats.github.io/js-multiformats/classes/cid.CID.html

Inspects the initial bytes of a CID to determine its properties.

```APIDOC
## CID.inspectBytes<T, C, A, V>(initialBytes)

### Description
Inspects the initial bytes of a CID to determine its properties such as codec, digest size, and version. It is recommended to provide at least 10 bytes for a complete inspection.

### Parameters
- **initialBytes** (ByteView<Link<T, C, A, V>>) - Required - The byte view of the CID.

### Returns
- **Object** - Returns an object containing codec, digestSize, multihashCode, multihashSize, size, and version.
```

--------------------------------

### reduceRight(callbackfn, initialValue?)

Source: https://multiformats.github.io/js-multiformats/interfaces/block_interface.ByteView.html

Calls the specified callback function for all the elements in an array in descending order to accumulate a result.

```APIDOC
## reduceRight(callbackfn, initialValue?)

### Description
Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

### Parameters
- **callbackfn** ((previousValue: U, currentValue: number, currentIndex: number, array: this) => U) - Required - A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
- **initialValue** (U) - Optional - If initialValue is specified, it is used as the initial value to start the accumulation.

### Returns
- **U**
```

--------------------------------

### set(array, offset?)

Source: https://multiformats.github.io/js-multiformats/interfaces/block_interface.ByteView.html

Sets a value or an array of values into the current array.

```APIDOC
## set(array, offset?)

### Description
Sets a value or an array of values.

### Parameters
- **array** (ArrayLike<number>) - Required - A typed or untyped array of values to set.
- **offset** (number) - Optional - The index in the current array at which the values are to be written.

### Returns
- **void**
```

--------------------------------

### map(callbackfn, thisArg?)

Source: https://multiformats.github.io/js-multiformats/interfaces/block_interface.ByteView.html

Calls a defined callback function on each element of an array and returns an array containing the results.

```APIDOC
## map(callbackfn, thisArg?)

### Description
Calls a defined callback function on each element of an array, and returns an array that contains the results.

### Parameters
- **callbackfn** ((value: number, index: number, array: this) => number) - Required - A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
- **thisArg** (any) - Optional - An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.

### Returns
- **Uint8Array<ArrayBuffer>**
```

--------------------------------

### Handle Default Base Encodings

Source: https://multiformats.github.io/js-multiformats

CIDs can be parsed and serialized using bundled base32 and base58btc codecs without explicit encoder/decoder supply.

```javascript
const v1 = CID.parse('bagaaierasords4njcts6vs7qvdjfcvgnume4hqohf65zsfguprqphs3icwea')  
v1.toString()  
//> 'bagaaierasords4njcts6vs7qvdjfcvgnume4hqohf65zsfguprqphs3icwea'  
  
const v0 = CID.parse('QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n')  
v0.toString()  
//> 'QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n'  
v0.toV1().toString()  
//> 'bafybeihdwdcefgh4dqkjv67uzcmw7ojee6xedzdetojuzjevtenxquvyku'
```

--------------------------------

### digest

Source: https://multiformats.github.io/js-multiformats/classes/hashes_hasher.Hasher.html

Computes the hash digest for the provided binary input.

```APIDOC
## digest(input, options?)

### Description
Takes binary input and returns the multihash digest. The return value may be a promise or a direct value depending on the implementation.

### Parameters
- **input** (Uint8Array) - Required - The binary data to hash.
- **options** (DigestOptions) - Optional - Additional options for the digest operation.

### Returns
- **Await<Digest<Code, number>>** - The computed hash digest.
```

--------------------------------

### decode(multibase: Multibase<Prefix>): Uint8Array<ArrayBuffer>

Source: https://multiformats.github.io/js-multiformats/interfaces/bases_interface.CombobaseDecoder.html

Decodes a multibase string into a Uint8Array. The input must include a valid multibase prefix; otherwise, an exception is thrown.

```APIDOC
## decode

### Description
Decodes a multibase string into a byte array. The input string must contain a valid multibase prefix supported by the decoder.

### Signature
`decode(multibase: Multibase<Prefix>): Uint8Array<ArrayBuffer>`

### Parameters
- **multibase** (Multibase<Prefix>) - The multibase string to decode.

### Returns
- **Uint8Array<ArrayBuffer>** - The decoded byte array.
```

--------------------------------

### CID.parse

Source: https://multiformats.github.io/js-multiformats/classes/cid.CID.html

Parses a string representation of a CID into an instance.

```APIDOC
## CID.parse<Prefix, Data, Code, Alg, Version>(source, base?)

### Description
Creates a CID instance from its string representation. If a base decoder is not provided, a default one is used.

### Parameters
- **source** (ToString<Link<Data, Code, Alg, Version>, Prefix>) - Required - The string representation of the CID.
- **base** (MultibaseDecoder<Prefix>) - Optional - The decoder to use for parsing.

### Returns
- **CID<Data, Code, Alg, Version>** - The parsed CID instance.
```

--------------------------------

### reverse()

Source: https://multiformats.github.io/js-multiformats/interfaces/block_interface.ByteView.html

Reverses the elements in the array.

```APIDOC
## reverse()

### Description
Reverses the elements in an Array.

### Returns
- **this**
```

--------------------------------

### fromString(str: string)

Source: https://multiformats.github.io/js-multiformats/functions/bytes.fromString.html

Converts a string into a byte array, constraining each character value to a single byte.

```APIDOC
## fromString(str: string)

### Description
Converts the passed string into a byte array, constraining each character value to a single byte.

### Signature
`fromString(str: string): Uint8Array<ArrayBuffer>`

### Parameters
- **str** (string) - The input string to convert.

### Returns
- **Uint8Array<ArrayBuffer>** - A byte array representation of the input string.
```

--------------------------------

### Multibase Codec Usage

Source: https://multiformats.github.io/js-multiformats/modules/index.html

Using a multibase codec which implements both encoder and decoder interfaces for convenience.

```APIDOC
## Multibase Codec Usage

### Description
Codecs expose both `encoder` and `decoder` properties and implement both interfaces, allowing them to be used directly in `toString` and `parse` methods.

### Usage
```javascript
cid.toString(base64)
CID.parse(cid.toString(base64), base64)
```
```

--------------------------------

### Implement a JSON BlockCodec

Source: https://multiformats.github.io/js-multiformats

Defines a codec implementation conforming to the BlockCodec interface, which includes name, code, encode, and decode properties.

```javascript
export const { name, code, encode, decode } = {  
  name: 'json',  
  code: 0x0200,  
  encode: json => new TextEncoder().encode(JSON.stringify(json)),  
  decode: bytes => JSON.parse(new TextDecoder().decode(bytes))  
}
```

--------------------------------

### Parse CID with Multibase Decoder

Source: https://multiformats.github.io/js-multiformats

Use a multibase decoder to parse a serialized CID string.

```javascript
CID.parse('mAYAEEiCTojlxqRTl6svwqNJRVM2jCcPBxy+7mRTUfGDzy2gViA', base64.decoder)  
//> CID(bagaaierasords4njcts6vs7qvdjfcvgnume4hqohf65zsfguprqphs3icwea)
```

--------------------------------

### encode(node: Uint8Array)

Source: https://multiformats.github.io/js-multiformats/functions/codecs_raw.encode.html

Encodes a Uint8Array into a ByteView.

```APIDOC
## encode(node: Uint8Array)

### Description
Encodes the provided Uint8Array into a ByteView format.

### Parameters
- **node** (Uint8Array) - Required - The data to be encoded.

### Returns
- **ByteView<Uint8Array<ArrayBufferLike>>** - The encoded byte view of the input data.
```

--------------------------------

### Serialize CID with Multibase Encoder

Source: https://multiformats.github.io/js-multiformats

Use a multibase encoder to convert a CID into a string representation.

```javascript
import { base64 } from "multiformats/bases/base64"  
cid.toString(base64.encoder)  
//> 'mAYAEEiCTojlxqRTl6svwqNJRVM2jCcPBxy+7mRTUfGDzy2gViA'
```

--------------------------------

### fromHex(hex: string)

Source: https://multiformats.github.io/js-multiformats/functions/bytes.fromHex.html

Converts a hexadecimal string into a Uint8Array.

```APIDOC
## fromHex(hex: string)

### Description
Converts a hexadecimal string into a Uint8Array.

### Parameters
- **hex** (string) - The hexadecimal string to convert.

### Returns
- **Uint8Array<ArrayBuffer>** - The resulting byte array.
```

--------------------------------

### baseEncode(bytes: Uint8Array): string

Source: https://multiformats.github.io/js-multiformats/interfaces/bases_interface.BaseEncoder.html

Encodes a Uint8Array into a plain base-encoded string. This method does not include a multibase prefix.

```APIDOC
## baseEncode(bytes: Uint8Array): string

### Description
Encodes the provided byte array into a plain base-encoded string. Unlike standard multibase encoders, this method does not prepend a multibase prefix to the output.

### Parameters
- **bytes** (Uint8Array) - Required - The byte array to be encoded.

### Returns
- **string** - The resulting base-encoded string.
```

--------------------------------

### MultibaseEncoder.encode

Source: https://multiformats.github.io/js-multiformats/interfaces/bases_interface.MultibaseEncoder.html

Encodes binary data into a multibase string with a prefix.

```APIDOC
## encode(bytes: Uint8Array): Multibase<Prefix>

### Description
Encodes binary data into a multibase string, which will have the encoder's specific prefix added.

### Parameters
- **bytes** (Uint8Array) - The binary data to encode.

### Returns
- **Multibase<Prefix>** - The resulting multibase string with the prefix.
```

--------------------------------

### coerce(o)

Source: https://multiformats.github.io/js-multiformats/functions/bytes.coerce.html

Normalizes binary input to a plain Uint8Array backed by an ArrayBuffer. Returns the input itself if it is already a plain Uint8Array, otherwise returns a fresh view or a copy.

```APIDOC
## coerce(o)

### Description
Normalizes binary input to a plain `Uint8Array` backed by an `ArrayBuffer`. Returns the input itself when it is already a plain `Uint8Array` over an `ArrayBuffer`, otherwise a fresh view (or, for `SharedArrayBuffer`-backed input, a copy) over the same bytes.

### Parameters
- **o** (ArrayBuffer | Uint8Array<ArrayBufferLike> | ArrayBufferView<ArrayBufferLike>) - Required - The binary input to normalize.

### Returns
- **Uint8Array<ArrayBuffer>** - A normalized Uint8Array.

### Throws
- Throws an error if the input is not a recognised binary type.
```

--------------------------------

### LegacyLink Interface Definition

Source: https://multiformats.github.io/js-multiformats/interfaces/link_interface.LegacyLink.html

Defines the structure of a legacy IPLD link, including properties for byte representation and methods for conversion and comparison.

```typescript
interface LegacyLink<T extends unknown = unknown> {  
"[Marker]"?: T;  
byteLength: number;  
byteOffset: number;  
bytes: ByteView<Link<T, 112, 18, 0>>;  
code: 112;  
multihash: MultihashDigest<18>;  
version: 0;  
equals(other: unknown): other is Link<T, 112, 18, Version>;  
link(): Link<T, 112, 18, 0>;  
toString<Prefix extends string>(  
base?: MultibaseEncoder<Prefix>,  
): ToString<Link<T, 112, 18, Version>, Prefix>;  
toV1(): Link<T, 112, 18, 1>;  
}
```

--------------------------------

### CID.equals

Source: https://multiformats.github.io/js-multiformats/classes/cid.CID.html

Checks if two CID instances are equal.

```APIDOC
## CID.equals<Data, Format, Alg, Version>(self, other)

### Description
Compares a CID instance with another value to determine equality.

### Parameters
- **self** (Link<Data, Format, Alg, Version>) - Required - The CID instance to compare.
- **other** (unknown) - Required - The value to compare against.

### Returns
- **boolean** - Returns true if the values are equal, otherwise false.
```

--------------------------------

### encode

Source: https://multiformats.github.io/js-multiformats/modules/codecs_raw.html

Encodes data into the raw format.

```APIDOC
## encode

### Description
Encodes the provided input into a raw format.

### Signature
`encode(input)`
```

--------------------------------

### CID.parse(string, decoder)

Source: https://multiformats.github.io/js-multiformats/modules/index.html

Parses a multibase-encoded CID string back into a CID instance using a provided multibase decoder.

```APIDOC
## CID.parse(string, decoder)

### Description
Parses a string representation of a CID using the specified multibase decoder.

### Usage
```javascript
CID.parse('mAYAEEiCTojlxqRTl6svwqNJRVM2jCcPBxy+7mRTUfGDzy2gViA', base64.decoder)
```
```

--------------------------------

### decode<Data, Code, Alg, Ver>(bytes: ByteView<Link<Data, Code, Alg, Ver>>): Link<Data, Code, Alg, Ver>

Source: https://multiformats.github.io/js-multiformats/functions/link.decode.html

Decodes a CID from its binary representation. The byte array must contain only the CID with no additional bytes. An error will be thrown if the bytes provided do not contain a valid binary representation of a CID.

```APIDOC
## decode<Data, Code, Alg, Ver>(bytes: ByteView<Link<Data, Code, Alg, Ver>>): Link<Data, Code, Alg, Ver>

### Description
Decodes a CID from its binary representation. The byte array must contain only the CID with no additional bytes. An error will be thrown if the bytes provided do not contain a valid binary representation of a CID.

### Parameters
- **bytes** (ByteView<Link<Data, Code, Alg, Ver>>) - Required - The binary representation of the CID.

### Returns
- **Link<Data, Code, Alg, Ver>** - The decoded CID Link object.
```

--------------------------------

### toJSON<Link extends UnknownLink>(link: Link): LinkJSON<Link>

Source: https://multiformats.github.io/js-multiformats/functions/cid.toJSON.html

Converts a provided link object into a JSON-serializable format.

```APIDOC
## toJSON

### Description
Converts a CID or Link object into its JSON-serializable representation.

### Signature
`toJSON<Link extends UnknownLink>(link: Link): LinkJSON<Link>`

### Parameters
- **link** (Link) - Required - The link object to convert.

### Returns
- **LinkJSON<Link>** - The JSON-serializable representation of the link.
```

--------------------------------

### decode(data)

Source: https://multiformats.github.io/js-multiformats/functions/codecs_raw.decode.html

Decodes raw data into a Uint8Array.

```APIDOC
## decode(data)

### Description
Decodes the provided input data into a Uint8Array.

### Parameters
- **data** (ByteView<Uint8Array<ArrayBufferLike>> | ArrayBufferView<Uint8Array<ArrayBufferLike>>) - Required - The raw data to be decoded.

### Returns
- **Uint8Array** - The decoded byte array.
```

--------------------------------

### isBinary(o: unknown)

Source: https://multiformats.github.io/js-multiformats/functions/bytes.isBinary.html

Checks if the provided object is a binary type (ArrayBuffer or ArrayBufferView).

```APIDOC
## isBinary(o: unknown)

### Description
Checks if the provided input is an `ArrayBuffer` or an `ArrayBufferView`.

### Signature
`isBinary(o: unknown): o is ArrayBuffer | ArrayBufferView<ArrayBufferLike>`

### Parameters
- **o** (unknown) - The value to check.

### Returns
- **boolean** - Returns true if the input is an `ArrayBuffer` or `ArrayBufferView`, otherwise false.
```

--------------------------------

### decode(multihash: Uint8Array)

Source: https://multiformats.github.io/js-multiformats/functions/hashes_digest.decode.html

Converts a byte array into a MultihashDigest instance.

```APIDOC
## decode(multihash: Uint8Array)

### Description
Turns bytes representation of multihash digest into an instance.

### Parameters
- **multihash** (Uint8Array) - Required - The byte representation of the multihash digest.

### Returns
- **MultihashDigest** - An instance representing the decoded multihash digest.
```

--------------------------------

### equals(aa: Uint8Array, bb: Uint8Array): boolean

Source: https://multiformats.github.io/js-multiformats/functions/bytes.equals.html

Compares two Uint8Array instances to determine if they contain the same bytes.

```APIDOC
## equals(aa: Uint8Array, bb: Uint8Array)

### Description
Compares two Uint8Array instances for equality.

### Parameters
- **aa** (Uint8Array) - The first byte array to compare.
- **bb** (Uint8Array) - The second byte array to compare.

### Returns
- **boolean** - Returns true if the arrays are equal, otherwise false.
```

--------------------------------

### CID.toString(encoder)

Source: https://multiformats.github.io/js-multiformats/modules/index.html

Serializes a CID to a string representation using a provided multibase encoder.

```APIDOC
## CID.toString(encoder)

### Description
Serializes a CID instance into a string using the specified multibase encoder.

### Usage
```javascript
import { base64 } from "multiformats/bases/base64"
cid.toString(base64.encoder)
```
```

--------------------------------

### ArrayBufferView Accessors and Methods

Source: https://multiformats.github.io/js-multiformats/interfaces/block_interface.ArrayBufferView.html

Individual definitions for the accessors and methods available on the ArrayBufferView interface.

```typescript
get detached(): boolean
```

```typescript
get maxByteLength(): number
```

```typescript
get resizable(): boolean
```

```typescript
resize(newByteLength?: number): void
```

```typescript
slice(begin?: number, end?: number): ArrayBuffer
```

```typescript
transfer(newByteLength?: number): ArrayBuffer
```

```typescript
transferToFixedLength(newByteLength?: number): ArrayBuffer
```

--------------------------------

### encodeTo(int: number, target: Uint8Array, offset?: number): Uint8Array

Source: https://multiformats.github.io/js-multiformats/functions/index.varint.encodeTo.html

Encodes an integer into a varint format and writes the result into the provided Uint8Array buffer.

```APIDOC
## encodeTo(int: number, target: Uint8Array, offset?: number)

### Description
Encodes a number into a varint and writes the bytes into the provided `target` Uint8Array starting at the specified `offset`.

### Parameters
- **int** (number) - The integer to encode.
- **target** (Uint8Array) - The buffer to write the encoded bytes into.
- **offset** (number) - Optional. The starting index in the target array. Defaults to 0.

### Returns
- **Uint8Array** - The target array containing the encoded varint.
```

--------------------------------

### encode<T>(node: T): ByteView<T>

Source: https://multiformats.github.io/js-multiformats/functions/codecs_json.encode.html

Serializes a provided node of type T into a ByteView<T>.

```APIDOC
## encode<T>(node: T)

### Description
Serializes the provided node into a ByteView format using the JSON codec.

### Signature
`encode<T>(node: T): ByteView<T>`

### Parameters
- **node** (T) - The data node to be encoded.

### Returns
- **ByteView<T>** - The encoded representation of the node.
```

--------------------------------

### HasherInit Interface Definition

Source: https://multiformats.github.io/js-multiformats/interfaces/hashes_hasher.HasherInit.html

Defines the required properties and methods for a hasher implementation, including the encoding function and optional length constraints.

```typescript
interface HasherInit<Name extends string, Code extends number> {  
code: Code;  
maxDigestLength?: number;  
minDigestLength?: number;  
name: Name;  
encode(input: Uint8Array): Await<Uint8Array<ArrayBuffer>>;  
}
```

--------------------------------

### encode<T, Code, Alg>

Source: https://multiformats.github.io/js-multiformats/functions/block.encode.html

Encodes data into a block using a specified codec and hashing algorithm.

```APIDOC
## encode<T, Code extends number, Alg extends number>

### Description
Encodes data into a block. This function takes an input object containing the data, codec, and hashing algorithm, and returns a Promise that resolves to a `BlockView`.

### Signature
`encode<T, Code extends number, Alg extends number>(__namedParameters: EncodeInput<T, Code, Alg>): Promise<BlockView<T, Code, Alg, 1>>`

### Type Parameters
- **T**: Logical type of the data encoded in the block.
- **Code**: Multicodec code corresponding to the codec used to encode the block.
- **Alg**: Multicodec code corresponding to the hashing algorithm used in CID creation.

### Parameters
- **__namedParameters** (EncodeInput<T, Code, Alg>) - Required - The input configuration containing data, codec, and hashing algorithm.

### Returns
- **Promise<BlockView<T, Code, Alg, 1>>** - A promise that resolves to the encoded block view.
```

--------------------------------

### Sort a copy of an array

Source: https://multiformats.github.io/js-multiformats/interfaces/block_interface.ByteView.html

Returns a new Uint8Array that is a sorted copy of the original array.

```javascript
const myNums = Uint8Array.from([11, 2, 22, 1]);  
myNums.toSorted((a, b) => a - b) // Uint8Array(4) [1, 2, 11, 22]
```

--------------------------------

### baseDecode(text: string): Uint8Array

Source: https://multiformats.github.io/js-multiformats/interfaces/bases_interface.BaseDecoder.html

Decodes a plain string (not a multibase) into a Uint8Array.

```APIDOC
## baseDecode(text: string): Uint8Array

### Description
Decodes a plain string (not a multibase) into a Uint8Array. This method is used to convert encoded string data into raw bytes.

### Parameters
- **text** (string) - Required - The plain string to be decoded.

### Returns
- **Uint8Array** - The decoded byte array.
```

--------------------------------

### equals(a, b)

Source: https://multiformats.github.io/js-multiformats/functions/hashes_digest.equals.html

Compares a MultihashDigest object with another value to check for equality.

```APIDOC
## equals(a, b)

### Description
Checks if the provided value is a MultihashDigest and if it is equal to the given MultihashDigest instance.

### Signature
`equals(a: MultihashDigest, b: unknown): b is MultihashDigest<number>`

### Parameters
- **a** (MultihashDigest) - The MultihashDigest instance to compare.
- **b** (unknown) - The value to compare against.

### Returns
- **boolean** (type guard) - Returns true if b is a MultihashDigest and equal to a.
```

--------------------------------

### Define BlockCodec Interface

Source: https://multiformats.github.io/js-multiformats/interfaces/codecs_interface.BlockCodec.html

The interface structure for implementing an IPLD codec, requiring a numeric code, a name, and encode/decode methods.

```typescript
interface BlockCodec<Code extends number, T> {  
code: Code;  
name: string;  
decode(bytes: ByteView<T> | ArrayBufferView<T>): T;  
encode(data: T): ByteView<T>;  
}
```

--------------------------------

### BlockDecoder Interface

Source: https://multiformats.github.io/js-multiformats/interfaces/codecs_interface.BlockDecoder.html

The BlockDecoder interface is used to define how IPLD blocks are decoded. It requires a numeric codec identifier and a decode function.

```APIDOC
## Interface: BlockDecoder<Code, T>

### Description
IPLD decoder part of the codec.

### Properties
- **code** (Code) - The numeric identifier for the codec.

### Methods
#### decode(bytes: ByteView<T> | ArrayBufferView<T>): T
- **bytes** (ByteView<T> | ArrayBufferView<T>) - The input data to be decoded.
- **Returns** (T) - The decoded object.
```
Tokens:
Raw