open-index/open-npm huggingface dataset:
npm package: @hashbuf/blake3
Description: BLAKE3 hash with streaming support, powered by Rust/WASM. Works in Node.js, Deno, Bun, and browsers.
Author: carry0987
Latest version: 1.1.0

# @hashbuf/blake3

BLAKE3 cryptographic hash function powered by Rust/WASM. Supports one-shot hashing, double hashing, keyed MAC, and incremental streaming.

## Install

```bash
npm install @hashbuf/blake3
```

## Usage

### One-shot hashing

```ts
import { blake3, blake3Hex, doubleBlake3, blake3Mac } from '@hashbuf/blake3';

const data = new TextEncoder().encode('hello');

const hash = blake3(data);           // Uint8Array (32 bytes)
const hex  = blake3Hex(data);        // hex string (64 chars)
const dhash = doubleBlake3(data);    // blake3(blake3(data))
const mac = blake3Mac(key32, data);  // keyed MAC (key must be 32 bytes)
```

### Streaming

```ts
import { Blake3Hasher } from '@hashbuf/blake3';

const hasher = new Blake3Hasher();
hasher.update(chunk1);
hasher.update(chunk2);
const hash = hasher.finalize(); // non-consumptive, can continue updating
hasher.free();
```

With consumptive `digest()` (mirrors `node:crypto` style):

```ts
const hasher = new Blake3Hasher();
hasher.update(chunk1);
hasher.update(chunk2);
const hash = hasher.digest();       // Uint8Array, auto-frees hasher
// or
const hex = hasher.digest('hex');   // hex string, single WASM call
```

With TC39 Explicit Resource Management:

```ts
using hasher = new Blake3Hasher();
hasher.update(data);
const hash = hasher.finalize();
```

### Async stream

```ts
import { blake3Stream } from '@hashbuf/blake3';

const hash = await blake3Stream(readableStream);
```

### HashAlgorithm interface

```ts
import { BLAKE3 } from '@hashbuf/blake3';

BLAKE3.hash(data);          // one-shot
BLAKE3.doubleHash(data);    // double hash
BLAKE3.digestLength;        // 32
BLAKE3.createHasher();      // streaming hasher
await BLAKE3.stream(source); // async stream
```

## API

| Export | Description |
|--------|-------------|
| `blake3(data)` | One-shot BLAKE3 hash → 32 bytes |
| `blake3Hex(data)` | One-shot BLAKE3 hash → hex string |
| `doubleBlake3(data)` | Double BLAKE3 hash → 32 bytes |
| `blake3Mac(key, data)` | Keyed MAC (32-byte key) → 32 bytes |
| `Blake3Hasher` | Streaming hasher class |
| `Blake3Hasher.digest()` | Consumptive finalize → `Uint8Array` (auto-frees) |
| `Blake3Hasher.digest('hex')` | Consumptive finalize → hex `string` (auto-frees) |
| `blake3Stream(source)` | Hash async iterable → 32 bytes |
| `BLAKE3` | `HashAlgorithm` interface singleton |

## License

Apache-2.0
npm package: @hashbuf/sha256
Description: SHA-256 hash and HMAC-SHA256 with streaming support, powered by Rust/WASM.
Author: carry0987
Latest version: 1.1.0

# @hashbuf/sha256

SHA-256 cryptographic hash function and HMAC-SHA256 powered by Rust/WASM. Supports one-shot hashing, double hashing, HMAC, and incremental streaming.

## Install

```bash
npm install @hashbuf/sha256
```

## Usage

### One-shot hashing

```ts
import { sha256, sha256Hex, doubleSha256, hmacSha256 } from '@hashbuf/sha256';

const data = new TextEncoder().encode('hello');

const hash = sha256(data);              // Uint8Array (32 bytes)
const hex  = sha256Hex(data);           // hex string (64 chars)
const dhash = doubleSha256(data);       // sha256(sha256(data))
const mac = hmacSha256(key, data);      // HMAC-SHA256
```

### Streaming

```ts
import { Sha256Hasher } from '@hashbuf/sha256';

const hasher = new Sha256Hasher();
hasher.update(chunk1);
hasher.update(chunk2);
const hash = hasher.finalize(); // non-consumptive, can continue updating
hasher.free();
```

With consumptive `digest()` (mirrors `node:crypto` style):

```ts
const hasher = new Sha256Hasher();
hasher.update(chunk1);
hasher.update(chunk2);
const hash = hasher.digest();       // Uint8Array, auto-frees hasher
// or
const hex = hasher.digest('hex');   // hex string, single WASM call
```

With TC39 Explicit Resource Management:

```ts
using hasher = new Sha256Hasher();
hasher.update(data);
const hash = hasher.finalize();
```

### Async stream

```ts
import { sha256Stream } from '@hashbuf/sha256';

const hash = await sha256Stream(readableStream);
```

### HashAlgorithm interface

```ts
import { SHA256 } from '@hashbuf/sha256';

SHA256.hash(data);          // one-shot
SHA256.doubleHash(data);    // double hash
SHA256.digestLength;        // 32
SHA256.createHasher();      // streaming hasher
await SHA256.stream(source); // async stream
```

## API

| Export | Description |
|--------|-------------|
| `sha256(data)` | One-shot SHA-256 hash → 32 bytes |
| `sha256Hex(data)` | One-shot SHA-256 hash → hex string |
| `doubleSha256(data)` | Double SHA-256 hash → 32 bytes |
| `hmacSha256(key, data)` | HMAC-SHA256 → 32 bytes |
| `Sha256Hasher` | Streaming hasher class |
| `Sha256Hasher.digest()` | Consumptive finalize → `Uint8Array` (auto-frees) |
| `Sha256Hasher.digest('hex')` | Consumptive finalize → hex `string` (auto-frees) |
| `sha256Stream(source)` | Hash async iterable → 32 bytes |
| `SHA256` | `HashAlgorithm` interface singleton |

## License

Apache-2.0
npm package: @hashbuf/types
Description: Shared type definitions for hashbuf packages.
Author: carry0987
Latest version: 1.1.0

# @hashbuf/types

Shared type definitions for hashbuf packages.

## Install

```bash
npm install @hashbuf/types
```

## Interfaces

### `Hasher`

A streaming hasher that accumulates data incrementally.

```ts
interface Hasher {
    update(data: Uint8Array): this;
    finalize(): Uint8Array;
    reset(): this;
    free(): void;
    digest(): Uint8Array;
    digest(encoding: 'hex'): string;
}
```

### `HashAlgorithm`

A hash algorithm providing both one-shot and streaming APIs.

```ts
interface HashAlgorithm {
    readonly name: string;
    readonly digestLength: number;
    hash(data: Uint8Array): Uint8Array;
    doubleHash(data: Uint8Array): Uint8Array;
    createHasher(): Hasher;
    stream(source: AsyncIterable<Uint8Array>): Promise<Uint8Array>;
}
```

## License

Apache-2.0