@norionsoft/hd-derivations 1.0.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NORIONSOFT
+
+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/NOTICE

@@ -0,0 +1,3 @@
+Required Notice: Copyright (c) 2026–present NORIONSOFT.
+
+This software is licensed under the MIT License (see LICENSE).

package/README.md

@@ -0,0 +1,263 @@
+# HD Derivations
+
+## Table of Contents
+- [Overview](#overview)
+- [License](#license)
+- [Features](#features)
+- [Installation](#installation)
+- [Usage](#how-to-use)
+  - [Importing](#1-import-utilities)
+  - [Getting a Network Instance](#2-get-network-instance-by)
+  - [Derivation Methods](#3-use-the-instance-methods)
+- [Folder Structure](#folder-structure)
+- [Contributing](#contributing)
+- [Supported Networks](#supported-networks)
+- [Quality Criteria](#quality-criteria)
+
+<a id="overview"></a>
+## Overview
+
+hd-derivations is a powerful and flexible hierarchical deterministic (HD) key derivation library designed for seamless multi-chain support. It allows users to derive private keys, public keys, and addresses from mnemonics or private keys, ensuring compatibility with various blockchain networks. The library is built to handle standard and non-standard derivation paths, making it ideal for restoring accounts from custom wallet setups.
+
+With support for multiple key types, derivation schemes, and other network specific configs, `hd-derivations` is a reliable solution for developers working with Bitcoin, Ethereum-compatible chains, Cardano, and more. Whether you are generating wallets, recovering accounts, or working with advanced key management, this package simplifies the process while maintaining security and flexibility.
+
+
+## License
+
+Licensed under the MIT License. See LICENSE for details.
+
+<a id="features"></a>
+## Key Features
+
+- **Mnemonic-based derivation** – Generate private keys, public keys, and addresses from a mnemonic phrase.
+- **Private key-based derivation** – Derive public keys and addresses directly from a private key.
+- **Batch derivation** – Derive multiple key sets from a mnemonic in a single operation.
+- **Mnemonic verification** – Verify if a private key was derived from a given mnemonic.
+- **Custom derivation paths** – Support non-standard paths for wallet recovery and custom setups.
+- **Multi-network compatibility** – Works with Bitcoin, EVM chains (Ethereum, Binance Smart Chain, etc.), Cardano, and more.
+- **Extensible & secure** – Designed for easy integration with blockchain clients while maintaining strong security principles.
+
+<a id="installation"></a>
+## Installation
+
+```bash
+pnpm add @norionsoft/hd-derivations
+```
+
+<a id="how-to-use"></a>
+## How to Use
+
+### 1. Import Utilities
+
+- Node JS:
+
+```ts
+import { getNetwork } from "@norionsoft/hd-derivations/node";
+```
+
+- Browser:
+
+```ts
+import { getNetwork } from "@norionsoft/hd-derivations/browser";
+```
+
+### 2. Create Network
+
+You can get a network instance by:
+
+- Manually passing the required parameters:
+
+```ts
+const network = getNetwork({
+  network: "bch",
+  mnemonic: "drill exotic title fall ivory boy praise unfold search foil surge tip",
+  derivationConfig: {
+    derivationType: "bchCashAddr",
+    networkPurpose: "mainnet",
+    prefixConfig: {
+      messagePrefix: "\x18Bitcoin Signed Message:\n",
+      bech32: "bc",
+      bip32: {
+        public: 0x0488b21e,
+        private: 0x0488ade4,
+      },
+      pubKeyHash: 0x00,
+      scriptHash: 0x05,
+      wif: 0x80,
+    },
+  },
+});
+```
+
+- Using the default parameters:
+
+```ts
+import { DEFAULT_BCH_INSTANCE_PARAMETERS, getNetwork } from "@norionsoft/hd-derivations/node"; // Or "@norionsoft/hd-derivations/browser"
+
+const network = getNetwork(DEFAULT_BCH_INSTANCE_PARAMETERS);
+```
+
+### 3. Network Methods
+
+The network instance has the following methods:
+
+- `deriveItemFromMnemonic` - Derive a single item from a mnemonic phrase.
+- `deriveItemsBatchFromMnemonic` - Derive multiple items from a mnemonic phrase.
+- `doesPKBelongToMnemonic` - Check if a private key belongs to a mnemonic phrase.
+- `getCredentialFromPK` - Get a credential from a private key.
+
+#### Examples
+
+- `deriveItemFromMnemonic`
+
+  ```ts
+  const item = network.deriveItemFromMnemonic({ derivationPath: "m/44'/145'/0'/0/0" });
+  ```
+
+  **Output**:
+
+  ```ts
+  {
+    privateKey: 'L5aNkaUVgbf9amcZaJxxkXBC6X9msHUGix6G1UiHS3seDADj3u7T',
+    publicKey: '030c98a8878c769710d0a986e824659b56fdb11a22ff3e8b4c3061944932fc5bcd',
+    address: 'bitcoincash:qpflutgnl6xg988yxaqv4y4jcef3x663gyejnjfxte',
+    derivationPath: "m/44'/145'/0'/0/0"
+  }
+  ```
+
+- `getCredentialFromPK`
+
+  ```ts
+  const credential = network.getCredentialFromPK({
+    privateKey: "Kysn6FCsYUwSwYVdUD4c6kdntJeZCZWpPYPj6LjEV2pDPyWNFhjX",
+  });
+  ```
+
+  **Output**:
+
+  ```ts
+  {
+    privateKey: 'Kysn6FCsYUwSwYVdUD4c6kdntJeZCZWpPYPj6LjEV2pDPyWNFhjX',
+    publicKey: '0333d222cc1fd501e74b6d64cb1e4dd85bbcb28d9ce3fd6a30133f5aa6211a8fc3',
+    address: 'bitcoincash:qrchjgvn4keqa6qwesjvywyj2fy46x2ex556xmy82u'
+  }
+  ```
+
+- `deriveItemsBatchFromMnemonic`
+
+  ```ts
+  const items = network.deriveItemsBatchFromMnemonic({
+    derivationPathPrefix: "m/44'/145'/0'/0",
+    indexLookupFrom: 0,
+    indexLookupTo: 2,
+  });
+  ```
+
+  **Output**:
+
+  ```ts
+  [
+    {
+      privateKey: "L5SA8xakaywY1Sham7js3Uj27kTP3voCghRZa8JdH5CuynwY89jM",
+      publicKey: "02766182fa20d62a27560d36516753d708cc5a47ff67b40d1967f2ea655c97f37b",
+      address: "bitcoincash:qpdlt7ra4edruc59yvkkqavgxuae2z73acv5p83mxh",
+      derivationPath: "m/44'/145'/0'/0/0",
+    },
+    {
+      privateKey: "L3dcBt5oH4Q5fLUgi3Sfr9S4dLVMGKSa42wkMqBeV7KECc4ThPJz",
+      publicKey: "0263144016657a7fe9c08d10e55e7fe08648a17ced5d1aa7a7e1f94ad122993245",
+      address: "bitcoincash:qq37wqs963g6dey6pkczd7g2jgpmrkmpmgcqp9knd5",
+      derivationPath: "m/44'/145'/0'/0/1",
+    },
+  ];
+  ```
+
+- `doesPKBelongToMnemonic`
+
+  ```ts
+  const doesPKBelongToMnemonic = network.doesPKBelongToMnemonic({
+    privateKey: "KxUYbZfVLLEFehzKcNXJSJvmBjbYswf9ZEsasfH5vFbdvvwS1F31",
+    derivationPathPrefix: "m/44'/145'",
+    indexLookupFrom: 0,
+    indexLookupTo: 2,
+  });
+  ```
+
+  **Output**:
+
+  ```ts
+  false;
+  ```
+
+#### Parameters
+
+Networks parameters are defined in the [`InstanceParameters`](src/modules/network/libs/types/instance-parameters.type.ts) type.
+
+**Info:** You can find the list of Polkadot `ss58` formats in the [ss 58 registry](https://github.com/paritytech/ss58-registry/blob/main/ss58-registry.json).
+
+Networks methods parameters are defined in the [`AbstractNetwork`](src/modules/network/libs/types/abstract-network.type.ts) type.
+
+<a id="folder-structure"></a>
+## Folder Structure
+
+1. The `libs` directory contains the reusable utilities throughout the package and it consists of the following entities:
+
+- `constants`
+- `enums`
+- `exceptions`
+- `helpers` - contains helper functions with more complex and less abstract logic that depends on other parts of the package
+- `modules` - contains separate entities
+- `types`
+- `utils` - contains simple utilities that don't depend on any part of the package
+
+> **If the needed entity is local for some directory the `libs` structure is also duplicated in that directory**
+
+2. The `modules` directory contains the main package entities
+
+<a id="contributing"></a>
+## Contributing
+
+### How to add a new Network
+
+> **Adapt or reuse any existing module if possible**
+
+- Implement curve logic in the [`curves`](src/libs/modules/curves) directory
+- Implement credentials logic in the [`key-derivation`](src/libs/modules/key-derivation) directory
+- Implement address logic in the [`address`](src/libs/modules/address) directory
+- Add the network derivation types to the [`DerivationTypeUnionByNetwork`](src/libs/types/derivation/derivation-type-union.type.ts) type
+- Add the network to the [`NetworkTypeMap`](src/modules/network/libs/types/network-type-map.type.ts) type
+- Adapt the [`AbstractNetwork`](src/modules/network/libs/types/abstract-network.type.ts) file to support the network
+- Adapt the [`ConstructorParameters`](src/modules/network/libs/types/constructor-parameters.type.ts) type for the network
+- Implement derivation handlers in the `src/modules/network/{network}/libs/helpers/get-derivation-handlers.helper.ts` file
+- Add `derivationHandlers` field to the network class
+- Implement `deriveItemFromMnemonic`, `getCredentialFromPK`, `deriveItemsBatchFromMnemonic` and `doesPKBelongToMnemonic` methods
+- Extend the [`getNetwork`](src/modules/network/get-network/get-network.ts) function
+
+<a id="supported-networks"></a>
+## Supported Networks
+
+- `Cardano`
+- `Aptos`
+- `Avalanche X`
+- `Avalanche P`
+- `Bitcoin Cash`
+- `BNB Beacon Chain`
+- `Bitcoin`
+- `Dogecoin`
+- `Polkadot`
+- `EVM`
+- `Litecoin`
+- `Solana`
+- `Sui`
+- `TON`
+- `Tron`
+- `XRP`
+- `Zcash`
+
+<a id="quality-criteria"></a>
+## Quality Criteria
+
+1. For full guidelines, see [`quality-criteria.md`](quality-criteria.md).
+
+2. Make sure you're not causing any circular dependencies and confused structure in the dependency graph:
+   [dependency-graph](https://github.com/morethanwallet/hd-derivations/blob/main/dependency-graph.svg)

package/build/browser/__vite-plugin-wasm-helper-C1xNeBGZ.js

@@ -0,0 +1,43 @@
+import { B as Buffer } from './index-CjeBPB5t.js';
+
+const __vite__initWasm = async (opts = {}, url) => {
+    let result;
+    if (url.startsWith("data:")) {
+        const urlContent = url.replace(/^data:.*?base64,/, "");
+        let bytes;
+        if (typeof Buffer === "function" && typeof Buffer.from === "function") {
+            bytes = Buffer.from(urlContent, "base64");
+        }
+        else if (typeof atob === "function") {
+            const binaryString = atob(urlContent);
+            bytes = new Uint8Array(binaryString.length);
+            for (let i = 0; i < binaryString.length; i++) {
+                bytes[i] = binaryString.charCodeAt(i);
+            }
+        }
+        else {
+            throw new Error("Cannot decode base64-encoded data URL");
+        }
+        result = await WebAssembly.instantiate(bytes, opts);
+    }
+    else {
+        // https://github.com/mdn/webassembly-examples/issues/5
+        // WebAssembly.instantiateStreaming requires the server to provide the
+        // correct MIME type for .wasm files, which unfortunately doesn't work for
+        // a lot of static file servers, so we just work around it by getting the
+        // raw buffer.
+        // @ts-ignore
+        const response = await fetch(url);
+        const contentType = response.headers.get("Content-Type") || "";
+        if ("instantiateStreaming" in WebAssembly && contentType.startsWith("application/wasm")) {
+            result = await WebAssembly.instantiateStreaming(response, opts);
+        }
+        else {
+            const buffer = await response.arrayBuffer();
+            result = await WebAssembly.instantiate(buffer, opts);
+        }
+    }
+    return result.instance.exports;
+};
+
+export { __vite__initWasm as _ };

package/build/browser/_commonjs-dynamic-modules-COweQ1RR.js

@@ -0,0 +1,5 @@
+function commonjsRequire(path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+
+export { commonjsRequire as c };

package/build/browser/_commonjsHelpers-BFTU3MAI.js

@@ -0,0 +1,7 @@
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export { commonjsGlobal as c, getDefaultExportFromCjs as g };

package/build/browser/_u64-C6ZvL3pZ.js

@@ -0,0 +1,294 @@
+const crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;
+
+/**
+ * Utilities for hex, bytes, CSPRNG.
+ * @module
+ */
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
+// node.js versions earlier than v19 don't declare it in global scope.
+// For node.js, package.json#exports field mapping rewrites import
+// from `crypto` to `cryptoNode`, which imports native module.
+// Makes the utils un-importable in browsers without a bundler.
+// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+function isBytes(a) {
+    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+}
+/** Asserts something is positive integer. */
+function anumber(n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error('positive integer expected, got ' + n);
+}
+/** Asserts something is Uint8Array. */
+function abytes(b, ...lengths) {
+    if (!isBytes(b))
+        throw new Error('Uint8Array expected');
+    if (lengths.length > 0 && !lengths.includes(b.length))
+        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
+}
+/** Asserts something is hash */
+function ahash(h) {
+    if (typeof h !== 'function' || typeof h.create !== 'function')
+        throw new Error('Hash should be wrapped by utils.createHasher');
+    anumber(h.outputLen);
+    anumber(h.blockLen);
+}
+/** Asserts a hash instance has not been destroyed / finished */
+function aexists(instance, checkFinished = true) {
+    if (instance.destroyed)
+        throw new Error('Hash instance has been destroyed');
+    if (checkFinished && instance.finished)
+        throw new Error('Hash#digest() has already been called');
+}
+/** Asserts output is properly-sized byte array */
+function aoutput(out, instance) {
+    abytes(out);
+    const min = instance.outputLen;
+    if (out.length < min) {
+        throw new Error('digestInto() expects output buffer of length at least ' + min);
+    }
+}
+/** Cast u8 / u16 / u32 to u32. */
+function u32(arr) {
+    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+function clean(...arrays) {
+    for (let i = 0; i < arrays.length; i++) {
+        arrays[i].fill(0);
+    }
+}
+/** Create DataView of an array for easy byte-level manipulation. */
+function createView(arr) {
+    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** The rotate right (circular right shift) operation for uint32 */
+function rotr(word, shift) {
+    return (word << (32 - shift)) | (word >>> shift);
+}
+/** The rotate left (circular left shift) operation for uint32 */
+function rotl(word, shift) {
+    return (word << shift) | ((word >>> (32 - shift)) >>> 0);
+}
+/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
+/** The byte swap operation for uint32 */
+function byteSwap(word) {
+    return (((word << 24) & 0xff000000) |
+        ((word << 8) & 0xff0000) |
+        ((word >>> 8) & 0xff00) |
+        ((word >>> 24) & 0xff));
+}
+/** Conditionally byte swap if on a big-endian platform */
+const swap8IfBE = isLE
+    ? (n) => n
+    : (n) => byteSwap(n);
+/** In place byte swap for Uint32Array */
+function byteSwap32(arr) {
+    for (let i = 0; i < arr.length; i++) {
+        arr[i] = byteSwap(arr[i]);
+    }
+    return arr;
+}
+const swap32IfBE = isLE
+    ? (u) => u
+    : byteSwap32;
+// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex
+const hasHexBuiltin = /* @__PURE__ */ (() => 
+// @ts-ignore
+typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();
+// Array where index 0xf0 (240) is mapped to string 'f0'
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+/**
+ * Convert byte array to hex string. Uses built-in function, when available.
+ * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+ */
+function bytesToHex(bytes) {
+    abytes(bytes);
+    // @ts-ignore
+    if (hasHexBuiltin)
+        return bytes.toHex();
+    // pre-caching improves the speed 6x
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        hex += hexes[bytes[i]];
+    }
+    return hex;
+}
+// We use optimized technique to convert hex string to byte array
+const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function asciiToBase16(ch) {
+    if (ch >= asciis._0 && ch <= asciis._9)
+        return ch - asciis._0; // '2' => 50-48
+    if (ch >= asciis.A && ch <= asciis.F)
+        return ch - (asciis.A - 10); // 'B' => 66-(65-10)
+    if (ch >= asciis.a && ch <= asciis.f)
+        return ch - (asciis.a - 10); // 'b' => 98-(97-10)
+    return;
+}
+/**
+ * Convert hex string to byte array. Uses built-in function, when available.
+ * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+ */
+function hexToBytes(hex) {
+    if (typeof hex !== 'string')
+        throw new Error('hex string expected, got ' + typeof hex);
+    // @ts-ignore
+    if (hasHexBuiltin)
+        return Uint8Array.fromHex(hex);
+    const hl = hex.length;
+    const al = hl / 2;
+    if (hl % 2)
+        throw new Error('hex string expected, got unpadded hex of length ' + hl);
+    const array = new Uint8Array(al);
+    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+        const n1 = asciiToBase16(hex.charCodeAt(hi));
+        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+        if (n1 === undefined || n2 === undefined) {
+            const char = hex[hi] + hex[hi + 1];
+            throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+        }
+        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
+    }
+    return array;
+}
+/**
+ * Converts string to bytes using UTF8 encoding.
+ * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+ */
+function utf8ToBytes(str) {
+    if (typeof str !== 'string')
+        throw new Error('string expected');
+    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+}
+/**
+ * Normalizes (non-hex) string or Uint8Array to Uint8Array.
+ * Warning: when Uint8Array is passed, it would NOT get copied.
+ * Keep in mind for future mutable operations.
+ */
+function toBytes(data) {
+    if (typeof data === 'string')
+        data = utf8ToBytes(data);
+    abytes(data);
+    return data;
+}
+/**
+ * Helper for KDFs: consumes uint8array or string.
+ * When string is passed, does utf8 decoding, using TextDecoder.
+ */
+function kdfInputToBytes(data) {
+    if (typeof data === 'string')
+        data = utf8ToBytes(data);
+    abytes(data);
+    return data;
+}
+/** Copies several Uint8Arrays into one. */
+function concatBytes(...arrays) {
+    let sum = 0;
+    for (let i = 0; i < arrays.length; i++) {
+        const a = arrays[i];
+        abytes(a);
+        sum += a.length;
+    }
+    const res = new Uint8Array(sum);
+    for (let i = 0, pad = 0; i < arrays.length; i++) {
+        const a = arrays[i];
+        res.set(a, pad);
+        pad += a.length;
+    }
+    return res;
+}
+function checkOpts(defaults, opts) {
+    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')
+        throw new Error('options should be object or undefined');
+    const merged = Object.assign(defaults, opts);
+    return merged;
+}
+/** For runtime check if class implements interface */
+class Hash {
+}
+/** Wraps hash function, creating an interface on top of it */
+function createHasher(hashCons) {
+    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+    const tmp = hashCons();
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = () => hashCons();
+    return hashC;
+}
+function createOptHasher(hashCons) {
+    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+    const tmp = hashCons({});
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = (opts) => hashCons(opts);
+    return hashC;
+}
+/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */
+function randomBytes(bytesLength = 32) {
+    if (crypto && typeof crypto.getRandomValues === 'function') {
+        return crypto.getRandomValues(new Uint8Array(bytesLength));
+    }
+    // Legacy Node.js compatibility
+    if (crypto && typeof crypto.randomBytes === 'function') {
+        return Uint8Array.from(crypto.randomBytes(bytesLength));
+    }
+    throw new Error('crypto.getRandomValues must be defined');
+}
+
+/**
+ * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
+ * @todo re-check https://issues.chromium.org/issues/42212588
+ * @module
+ */
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+    if (le)
+        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
+    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+    const len = lst.length;
+    let Ah = new Uint32Array(len);
+    let Al = new Uint32Array(len);
+    for (let i = 0; i < len; i++) {
+        const { h, l } = fromBig(lst[i], le);
+        [Ah[i], Al[i]] = [h, l];
+    }
+    return [Ah, Al];
+}
+// for Shift in [0, 32)
+const shrSH = (h, _l, s) => h >>> s;
+const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+// Right rotate for Shift in [1, 32)
+const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));
+const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+// Right rotate for Shift in (32, 64), NOTE: 32 is special case.
+const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
+const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
+// Right rotate for shift===32 (just swaps l&h)
+const rotr32H = (_h, l) => l;
+const rotr32L = (h, _l) => h;
+// Left rotate for Shift in [1, 32)
+const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
+const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
+// Left rotate for Shift in (32, 64), NOTE: 32 is special case.
+const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
+const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
+// JS uses 32-bit signed integers for bitwise operations which means we cannot
+// simple take carry out of low bit sum by shift, we need to use division.
+function add(Ah, Al, Bh, Bl) {
+    const l = (Al >>> 0) + (Bl >>> 0);
+    return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
+}
+// Addition with more than 2 elements
+const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+const add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
+const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+const add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
+const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
+
+export { split as A, createOptHasher as B, u32 as C, swap8IfBE as D, fromBig as E, swap32IfBE as F, rotr32L as G, Hash as H, rotr32H as I, bytesToHex as J, isBytes as K, hexToBytes as L, concatBytes as M, randomBytes as N, rotlBH as O, rotlSH as P, rotlBL as Q, rotlSL as R, utf8ToBytes as S, clean as a, createView as b, createHasher as c, ahash as d, checkOpts as e, anumber as f, aexists as g, abytes as h, aoutput as i, add4L as j, kdfInputToBytes as k, add4H as l, add5L as m, add5H as n, add as o, add3H as p, rotrSH as q, rotl as r, shrSH as s, toBytes as t, rotrSL as u, shrSL as v, rotrBH as w, rotrBL as x, add3L as y, rotr as z };