@rasmx/hash 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright © 2026 
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# @rasmx/hash 🚀
+
+[![NPM Version](https://img.shields.io/npm/v/@rasmx/hash.svg)](https://www.npmjs.com/package/@rasmx/hash)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Bundle Size](https://img.shields.io/bundlephobia/minzip/@rasmx/hash)](https://bundlephobia.com/package/@rasmx/hash)
+
+**@rasmx/hash** is a high-performance, universal hashing library for JavaScript and TypeScript, powered by **WebAssembly** and **Rust**.
+
+## Why @rasmx/hash?
+
+- **Blazing Fast**: Up to 10-20x faster than pure JS implementations (like crypto-js).
+- **Streaming Ready**: Hash gigabytes of data with zero-copy using browser `ReadableStream`.
+- **All-in-One**: One tiny package replaces dozens of single-algorithm libraries.
+- **Modern**: Full support for `SharedArrayBuffer` and ES Modules.
+
+## Supported Algorithms
+
+| Family | Variants |
+| :--- | :--- |
+| **SHA2** | 224, 256, 384, 512, 512/224, 512/256 |
+| **SHA3** | 224, 256, 384, 512 |
+| **Keccak** | 224, 256, 384, 512 |
+| **XXHash** | 32, 64, 3-64, 3-128 (with Seed support) |
+| **Other** | MD5, HMAC-SHA256, HMAC-SHA512, SHAKE128/256 |
+
+## Quick Start
+
+```javascript
+import { hash } from '@rasmx/hash';
+
+// Simple usage
+const hex = await hash.sha2.v256("hello world");
+
+// Streaming large files (Browser)
+const result = await hash.stream(file.stream(), new IncrementalSha256());
+```

package/index.d.ts

@@ -0,0 +1,106 @@
+export type InputData = string | Uint8Array | ArrayBuffer | SharedArrayBuffer;
+
+export interface HashFamily {
+    v224: (d: InputData) => Promise<string>;
+    v256: (d: InputData) => Promise<string>;
+    v384: (d: InputData) => Promise<string>;
+    v512: (d: InputData) => Promise<string>;
+    v512_224: (d: InputData) => Promise<string>;
+    v512_256: (d: InputData) => Promise<string>;
+}
+
+export const hash: {
+    sha2: HashFamily;
+    sha3: HashFamily;
+    keccak: HashFamily;
+    blake3: (d: InputData, key?: InputData) => Promise<string>;
+    shake: {
+        v128: (d: InputData, len: number) => Promise<string>;
+        v256: (d: InputData, len: number) => Promise<string>;
+    };
+    xxh: {
+        v32: (d: InputData, seed?: number) => Promise<string>;
+        v64: (d: InputData, seed?: bigint) => Promise<string>;
+        v3_64: (d: InputData) => Promise<string>;
+        v3_64_seed: (d: InputData, seed: bigint) => Promise<string>;
+        v3_128: (d: InputData) => Promise<string>;
+        v3_128_seed: (d: InputData, seed: bigint) => Promise<string>;
+    };
+    hmac: {
+        sha256: (key: InputData, d: InputData) => Promise<string>;
+        sha512: (key: InputData, d: InputData) => Promise<string>;
+    };
+    md5: (d: InputData) => Promise<string>;
+    stream: (readable: ReadableStream, hasher: any) => Promise<string>;
+};
+
+export interface IHasher {
+    update(d: InputData): Promise<void>;
+    finalize(): Promise<string>;
+    free(): Promise<void>;
+}
+
+export class IncrementalSha256 implements IHasher {
+    constructor();
+    update(d: InputData): Promise<void>;
+    finalize(): Promise<string>;
+    free(): Promise<void>;
+}
+
+export class IncrementalSha512 implements IHasher {
+    constructor();
+    update(d: InputData): Promise<void>;
+    finalize(): Promise<string>;
+    free(): Promise<void>;
+}
+
+export class IncrementalMd5 implements IHasher {
+    constructor();
+    update(d: InputData): Promise<void>;
+    finalize(): Promise<string>;
+    free(): Promise<void>;
+}
+
+export class IncrementalBlake3 implements IHasher {
+    constructor();
+    update(d: InputData): Promise<void>;
+    finalize(): Promise<string>;
+    free(): Promise<void>;
+}
+
+export class IncrementalXxh3 {
+    constructor();
+    update(d: InputData): Promise<void>;
+    finalize64(): Promise<string>;
+    finalize128(): Promise<string>;
+    finalize(): Promise<string>;
+    free(): Promise<void>;
+}
+
+export class IncrementalXxh32 implements IHasher {
+    constructor(seed?: number);
+    update(d: InputData): Promise<void>;
+    finalize(): Promise<string>;
+    free(): Promise<void>;
+}
+
+export class IncrementalXxh64 implements IHasher {
+    constructor(seed?: bigint);
+    update(d: InputData): Promise<void>;
+    finalize(): Promise<string>;
+    free(): Promise<void>;
+}
+
+export class IncrementalSha3_256 implements IHasher {
+    constructor();
+    update(d: InputData): Promise<void>;
+    finalize(): Promise<string>;
+    free(): Promise<void>;
+}
+
+export class IncrementalKeccak256 implements IHasher {
+    constructor();
+    update(d: InputData): Promise<void>;
+    finalize(): Promise<string>;
+    free(): Promise<void>;
+}

package/index.js

@@ -0,0 +1,140 @@
+import init, * as wasm from './pkg/rasmx_hash.js';
+
+let ready = false;
+async function ensure() {
+    if (!ready) {
+        await init();
+        ready = true;
+    }
+}
+
+function toBuf(data) {
+    if (data instanceof Uint8Array) return data;
+    if (typeof data === 'string') return new TextEncoder().encode(data);
+    if (data instanceof ArrayBuffer || (typeof SharedArrayBuffer !== 'undefined' && data instanceof SharedArrayBuffer)) {
+        return new Uint8Array(data);
+    }
+    return new Uint8Array(data);
+}
+
+export const hash = {
+    sha2: {
+        v224: async (d) => { await ensure(); return wasm.sha2_224(toBuf(d)); },
+        v256: async (d) => { await ensure(); return wasm.sha2_256(toBuf(d)); },
+        v384: async (d) => { await ensure(); return wasm.sha2_384(toBuf(d)); },
+        v512: async (d) => { await ensure(); return wasm.sha2_512(toBuf(d)); },
+        v512_224: async (d) => { await ensure(); return wasm.sha2_512_224(toBuf(d)); },
+        v512_256: async (d) => { await ensure(); return wasm.sha2_512_256(toBuf(d)); }
+    },
+    sha3: {
+        v224: async (d) => { await ensure(); return wasm.sha3_224(toBuf(d)); },
+        v256: async (d) => { await ensure(); return wasm.sha3_256(toBuf(d)); },
+        v384: async (d) => { await ensure(); return wasm.sha3_384(toBuf(d)); },
+        v512: async (d) => { await ensure(); return wasm.sha3_512(toBuf(d)); }
+    },
+    keccak: {
+        v224: async (d) => { await ensure(); return wasm.keccak_224(toBuf(d)); },
+        v256: async (d) => { await ensure(); return wasm.keccak_256(toBuf(d)); },
+        v384: async (d) => { await ensure(); return wasm.keccak_384(toBuf(d)); },
+        v512: async (d) => { await ensure(); return wasm.keccak_512(toBuf(d)); }
+    },
+    shake: {
+        v128: async (d, len) => { await ensure(); return wasm.shake128(toBuf(d), len); },
+        v256: async (d, len) => { await ensure(); return wasm.shake256(toBuf(d), len); }
+    },
+    blake3: async (d, key = null) => { 
+        await ensure(); 
+        return key ? wasm.blake3_keyed_hex(toBuf(d), toBuf(key)) : wasm.blake3_hex(toBuf(d)); 
+    },
+    xxh: {
+        v32: async (d, seed = 0) => { await ensure(); return wasm.xxh32_hex(toBuf(d), seed); },
+        v64: async (d, seed = 0n) => { await ensure(); return wasm.xxh64_hex(toBuf(d), BigInt(seed)); },
+        v3_64: async (d) => { await ensure(); return wasm.xxh3_64_hex(toBuf(d)); },
+        v3_64_seed: async (d, seed) => { await ensure(); return wasm.xxh3_64_seed_hex(toBuf(d), BigInt(seed)); },
+        v3_128: async (d) => { await ensure(); return wasm.xxh3_128_hex(toBuf(d)); },
+        v3_128_seed: async (d, seed) => { await ensure(); return wasm.xxh3_128_seed_hex(toBuf(d), BigInt(seed)); }
+    },
+    hmac: {
+        sha256: async (key, d) => { await ensure(); return wasm.hmac_sha256(toBuf(key), toBuf(d)); },
+        sha512: async (key, d) => { await ensure(); return wasm.hmac_sha512(toBuf(key), toBuf(d)); }
+    },
+    md5: async (d) => { await ensure(); return wasm.md5_hex(toBuf(d)); },
+    stream: async (readable, hasher) => {
+        const reader = readable.getReader();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            await hasher.update(value);
+        }
+        const res = await hasher.finalize();
+        if (hasher.free) await hasher.free();
+        return res;
+    }
+};
+
+class BaseIncremental {
+    constructor() { this.p = ensure(); this.i = null; }
+    async free() {
+        await this.p;
+        if (this.i) {
+            this.i.free();
+            this.i = null;
+        }
+    }
+}
+
+export class IncrementalSha256 extends BaseIncremental {
+    constructor() { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalSha256()); }
+    async update(d) { await this.p; this.i.update(toBuf(d)); }
+    async finalize() { await this.p; return this.i.finalize(); }
+}
+
+export class IncrementalSha512 extends BaseIncremental {
+    constructor() { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalSha512()); }
+    async update(d) { await this.p; this.i.update(toBuf(d)); }
+    async finalize() { await this.p; return this.i.finalize(); }
+}
+
+export class IncrementalSha3_256 extends BaseIncremental {
+    constructor() { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalSha3_256()); }
+    async update(d) { await this.p; this.i.update(toBuf(d)); }
+    async finalize() { await this.p; return this.i.finalize(); }
+}
+
+export class IncrementalKeccak256 extends BaseIncremental {
+    constructor() { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalKeccak256()); }
+    async update(d) { await this.p; this.i.update(toBuf(d)); }
+    async finalize() { await this.p; return this.i.finalize(); }
+}
+
+export class IncrementalMd5 extends BaseIncremental {
+    constructor() { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalMd5()); }
+    async update(d) { await this.p; this.i.update(toBuf(d)); }
+    async finalize() { await this.p; return this.i.finalize(); }
+}
+
+export class IncrementalBlake3 extends BaseIncremental {
+    constructor() { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalBlake3()); }
+    async update(d) { await this.p; this.i.update(toBuf(d)); }
+    async finalize() { await this.p; return this.i.finalize(); }
+}
+
+export class IncrementalXxh3 extends BaseIncremental {
+    constructor() { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalXxh3()); }
+    async update(d) { await this.p; this.i.update(toBuf(d)); }
+    async finalize64() { await this.p; return this.i.finalize_64(); }
+    async finalize128() { await this.p; return this.i.finalize_128(); }
+    async finalize() { return this.finalize64(); }
+}
+
+export class IncrementalXxh32 extends BaseIncremental {
+    constructor(seed = 0) { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalXxh32(seed)); }
+    async update(d) { await this.p; this.i.update(toBuf(d)); }
+    async finalize() { await this.p; return this.i.finalize(); }
+}
+
+export class IncrementalXxh64 extends BaseIncremental {
+    constructor(seed = 0n) { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalXxh64(BigInt(seed))); }
+    async update(d) { await this.p; this.i.update(toBuf(d)); }
+    async finalize() { await this.p; return this.i.finalize(); }
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@rasmx/hash",
+  "version": "1.0.0",
+  "description": "Blazing fast WASM hashing library powered by Rust. Support for SHA2, SHA3, Keccak, XXHash, and MD5 with streaming support.",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "wasm",
+    "hash",
+    "sha256",
+    "sha3",
+    "xxhash",
+    "keccak",
+    "rust",
+    "performance",
+    "streaming"
+  ],
+  "author": "deniis",
+  "license": "MIT",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "files": [
+    "pkg/rasmx_hash_bg.wasm",
+    "pkg/rasmx_hash.js",
+    "pkg/rasmx_hash.d.ts",
+    "index.js",
+    "index.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build:wasm": "wasm-pack build ../../crates/rasmx_hash --target web --release --out-dir ../../packages/hash/pkg"
+  }
+}

package/pkg/rasmx_hash.d.ts

@@ -0,0 +1,323 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class IncrementalBlake3 {
+    free(): void;
+    [Symbol.dispose](): void;
+    finalize(): string;
+    constructor();
+    update(data: Uint8Array): void;
+}
+
+export class IncrementalKeccak256 {
+    free(): void;
+    [Symbol.dispose](): void;
+    finalize(): string;
+    constructor();
+    update(data: Uint8Array): void;
+}
+
+export class IncrementalMd5 {
+    free(): void;
+    [Symbol.dispose](): void;
+    finalize(): string;
+    constructor();
+    update(data: Uint8Array): void;
+}
+
+export class IncrementalSha256 {
+    free(): void;
+    [Symbol.dispose](): void;
+    finalize(): string;
+    constructor();
+    update(data: Uint8Array): void;
+}
+
+export class IncrementalSha3_256 {
+    free(): void;
+    [Symbol.dispose](): void;
+    finalize(): string;
+    constructor();
+    update(data: Uint8Array): void;
+}
+
+export class IncrementalSha512 {
+    free(): void;
+    [Symbol.dispose](): void;
+    finalize(): string;
+    constructor();
+    update(data: Uint8Array): void;
+}
+
+export class IncrementalXxh3 {
+    free(): void;
+    [Symbol.dispose](): void;
+    finalize_128(): string;
+    finalize_64(): string;
+    constructor();
+    update(data: Uint8Array): void;
+}
+
+export class IncrementalXxh32 {
+    free(): void;
+    [Symbol.dispose](): void;
+    finalize(): string;
+    constructor(seed: number);
+    update(data: Uint8Array): void;
+}
+
+export class IncrementalXxh64 {
+    free(): void;
+    [Symbol.dispose](): void;
+    finalize(): string;
+    constructor(seed: bigint);
+    update(data: Uint8Array): void;
+}
+
+/**
+ * Computes BLAKE3 hash. Fast and secure.
+ */
+export function blake3_hex(data: Uint8Array): string;
+
+/**
+ * Computes keyed BLAKE3 hash. Key must be exactly 32 bytes.
+ */
+export function blake3_keyed_hex(data: Uint8Array, key: Uint8Array): string;
+
+/**
+ * Computes HMAC-SHA256 with a given key and data.
+ */
+export function hmac_sha256(key: Uint8Array, data: Uint8Array): string;
+
+/**
+ * Computes HMAC-SHA512 with a given key and data.
+ */
+export function hmac_sha512(key: Uint8Array, data: Uint8Array): string;
+
+/**
+ * Computes Keccak-224 hash.
+ */
+export function keccak_224(data: Uint8Array): string;
+
+/**
+ * Computes Keccak-256 hash.
+ */
+export function keccak_256(data: Uint8Array): string;
+
+/**
+ * Computes Keccak-384 hash.
+ */
+export function keccak_384(data: Uint8Array): string;
+
+/**
+ * Computes Keccak-512 hash.
+ */
+export function keccak_512(data: Uint8Array): string;
+
+/**
+ * Computes MD5 hash. Returns 32-character hex string.
+ */
+export function md5_hex(data: Uint8Array): string;
+
+export function run_app(): void;
+
+/**
+ * Computes SHA-224 hash.
+ */
+export function sha2_224(data: Uint8Array): string;
+
+/**
+ * Computes SHA-256 hash.
+ */
+export function sha2_256(data: Uint8Array): string;
+
+/**
+ * Computes SHA-384 hash.
+ */
+export function sha2_384(data: Uint8Array): string;
+
+/**
+ * Computes SHA-512 hash.
+ */
+export function sha2_512(data: Uint8Array): string;
+
+/**
+ * Computes SHA-512/224 hash.
+ */
+export function sha2_512_224(data: Uint8Array): string;
+
+/**
+ * Computes SHA-512/256 hash.
+ */
+export function sha2_512_256(data: Uint8Array): string;
+
+/**
+ * Computes SHA3-224 hash.
+ */
+export function sha3_224(data: Uint8Array): string;
+
+/**
+ * Computes SHA3-256 hash.
+ */
+export function sha3_256(data: Uint8Array): string;
+
+/**
+ * Computes SHA3-384 hash.
+ */
+export function sha3_384(data: Uint8Array): string;
+
+/**
+ * Computes SHA3-512 hash.
+ */
+export function sha3_512(data: Uint8Array): string;
+
+/**
+ * SHAKE-128: arbitrary-length output.
+ */
+export function shake128(data: Uint8Array, output_len: number): string;
+
+/**
+ * SHAKE-256: arbitrary-length output.
+ */
+export function shake256(data: Uint8Array, output_len: number): string;
+
+/**
+ * Computes XXH32 hash with a 32-bit seed.
+ */
+export function xxh32_hex(data: Uint8Array, seed: number): string;
+
+/**
+ * Computes XXH3 128-bit hash.
+ */
+export function xxh3_128_hex(data: Uint8Array): string;
+
+/**
+ * Computes XXH3 128-bit hash with a 192-byte secret.
+ */
+export function xxh3_128_secret_hex(data: Uint8Array, secret: Uint8Array): string;
+
+/**
+ * Computes XXH3 128-bit hash with a 64-bit seed.
+ */
+export function xxh3_128_seed_hex(data: Uint8Array, seed: bigint): string;
+
+/**
+ * Computes XXH3 64-bit hash. Fast and high quality.
+ */
+export function xxh3_64_hex(data: Uint8Array): string;
+
+/**
+ * Computes XXH3 64-bit hash with a 192-byte secret.
+ */
+export function xxh3_64_secret_hex(data: Uint8Array, secret: Uint8Array): string;
+
+/**
+ * Computes XXH3 64-bit hash with a 64-bit seed.
+ */
+export function xxh3_64_seed_hex(data: Uint8Array, seed: bigint): string;
+
+/**
+ * Computes XXH64 hash with a 64-bit seed.
+ */
+export function xxh64_hex(data: Uint8Array, seed: bigint): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_incrementalblake3_free: (a: number, b: number) => void;
+    readonly __wbg_incrementalkeccak256_free: (a: number, b: number) => void;
+    readonly __wbg_incrementalmd5_free: (a: number, b: number) => void;
+    readonly __wbg_incrementalsha256_free: (a: number, b: number) => void;
+    readonly __wbg_incrementalsha512_free: (a: number, b: number) => void;
+    readonly __wbg_incrementalxxh32_free: (a: number, b: number) => void;
+    readonly __wbg_incrementalxxh3_free: (a: number, b: number) => void;
+    readonly __wbg_incrementalxxh64_free: (a: number, b: number) => void;
+    readonly blake3_hex: (a: number, b: number) => [number, number];
+    readonly blake3_keyed_hex: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+    readonly hmac_sha256: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly hmac_sha512: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly incrementalblake3_finalize: (a: number) => [number, number];
+    readonly incrementalblake3_new: () => number;
+    readonly incrementalblake3_update: (a: number, b: number, c: number) => void;
+    readonly incrementalkeccak256_finalize: (a: number) => [number, number];
+    readonly incrementalkeccak256_new: () => number;
+    readonly incrementalkeccak256_update: (a: number, b: number, c: number) => void;
+    readonly incrementalmd5_finalize: (a: number) => [number, number];
+    readonly incrementalmd5_new: () => number;
+    readonly incrementalmd5_update: (a: number, b: number, c: number) => void;
+    readonly incrementalsha256_finalize: (a: number) => [number, number];
+    readonly incrementalsha256_new: () => number;
+    readonly incrementalsha256_update: (a: number, b: number, c: number) => void;
+    readonly incrementalsha3_256_finalize: (a: number) => [number, number];
+    readonly incrementalsha512_finalize: (a: number) => [number, number];
+    readonly incrementalsha512_new: () => number;
+    readonly incrementalsha512_update: (a: number, b: number, c: number) => void;
+    readonly incrementalxxh32_finalize: (a: number) => [number, number];
+    readonly incrementalxxh32_new: (a: number) => number;
+    readonly incrementalxxh32_update: (a: number, b: number, c: number) => void;
+    readonly incrementalxxh3_finalize_128: (a: number) => [number, number];
+    readonly incrementalxxh3_finalize_64: (a: number) => [number, number];
+    readonly incrementalxxh3_new: () => number;
+    readonly incrementalxxh3_update: (a: number, b: number, c: number) => void;
+    readonly incrementalxxh64_finalize: (a: number) => [number, number];
+    readonly incrementalxxh64_new: (a: bigint) => number;
+    readonly incrementalxxh64_update: (a: number, b: number, c: number) => void;
+    readonly keccak_224: (a: number, b: number) => [number, number];
+    readonly keccak_256: (a: number, b: number) => [number, number];
+    readonly keccak_384: (a: number, b: number) => [number, number];
+    readonly keccak_512: (a: number, b: number) => [number, number];
+    readonly md5_hex: (a: number, b: number) => [number, number];
+    readonly sha2_224: (a: number, b: number) => [number, number];
+    readonly sha2_256: (a: number, b: number) => [number, number];
+    readonly sha2_384: (a: number, b: number) => [number, number];
+    readonly sha2_512: (a: number, b: number) => [number, number];
+    readonly sha2_512_224: (a: number, b: number) => [number, number];
+    readonly sha2_512_256: (a: number, b: number) => [number, number];
+    readonly sha3_224: (a: number, b: number) => [number, number];
+    readonly sha3_256: (a: number, b: number) => [number, number];
+    readonly sha3_384: (a: number, b: number) => [number, number];
+    readonly sha3_512: (a: number, b: number) => [number, number];
+    readonly shake128: (a: number, b: number, c: number) => [number, number];
+    readonly shake256: (a: number, b: number, c: number) => [number, number];
+    readonly xxh32_hex: (a: number, b: number, c: number) => [number, number];
+    readonly xxh3_128_hex: (a: number, b: number) => [number, number];
+    readonly xxh3_128_secret_hex: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+    readonly xxh3_128_seed_hex: (a: number, b: number, c: bigint) => [number, number];
+    readonly xxh3_64_hex: (a: number, b: number) => [number, number];
+    readonly xxh3_64_secret_hex: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+    readonly xxh3_64_seed_hex: (a: number, b: number, c: bigint) => [number, number];
+    readonly xxh64_hex: (a: number, b: number, c: bigint) => [number, number];
+    readonly run_app: () => void;
+    readonly incrementalsha3_256_new: () => number;
+    readonly __wbg_incrementalsha3_256_free: (a: number, b: number) => void;
+    readonly incrementalsha3_256_update: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;