{"version":3,"file":"index.cjs","sources":["../../../node_modules/@noble/hashes/_u64.js","../../../node_modules/@noble/hashes/utils.js","../../../node_modules/@noble/hashes/_blake.js","../../../node_modules/@noble/hashes/_md.js","../../../node_modules/@noble/hashes/blake2.js","../../../node_modules/@noble/hashes/argon2.js","../src/argon2.ts","../src/evpkdf.ts","../src/hkdf.ts","../src/hmac.ts","../src/pbkdf2.ts","../../../node_modules/@noble/hashes/hmac.js","../../../node_modules/@noble/hashes/pbkdf2.js","../../../node_modules/@noble/hashes/sha2.js","../../../node_modules/@noble/hashes/scrypt.js","../src/scrypt.ts","../src/preset.ts"],"sourcesContent":["const U32_MASK64 = /* @__PURE__ */ (() => BigInt(2 ** 32 - 1))();\nconst _32n = /* @__PURE__ */ BigInt(32);\n// Split bigint into two 32-bit halves. With `le=true`, returned fields become `{ h: low, l: high\n// }` to match little-endian word order rather than the property names.\nfunction fromBig(n, le = false) {\n    if (le)\n        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };\n    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };\n}\n// Split bigint list into `[highWords, lowWords]` when `le=false`; with `le=true`, the first array\n// holds the low halves because `fromBig(...)` swaps the semantic meaning of `h` and `l`.\nfunction split(lst, le = false) {\n    const len = lst.length;\n    let Ah = new Uint32Array(len);\n    let Al = new Uint32Array(len);\n    for (let i = 0; i < len; i++) {\n        const { h, l } = fromBig(lst[i], le);\n        [Ah[i], Al[i]] = [h, l];\n    }\n    return [Ah, Al];\n}\n// Combine explicit `(high, low)` 32-bit halves into a bigint; `>>> 0` normalizes signed JS\n// bitwise results back to uint32 first, and little-endian callers must swap.\nconst toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);\n// Split a JS number into u32 halves without a BigInt allocation. Exact only for integers\n// `0 <= n < 2**53`; callers use it on byte / bit counters, which JS length math caps far below\n// that (an ArrayBuffer cannot exceed 2**53 - 1 bytes).\nconst fromNumH = (n) => (n / 2 ** 32) | 0;\nconst fromNumL = (n) => n >>> 0;\n// Drop-in replacement for `view.setBigUint64(byteOffset, BigInt(n), isLE)` without the per-call\n// BigInt allocation. Same `n < 2**53` precondition as `fromNumH`/`fromNumL`.\nfunction setU64FromNum(view, byteOffset, n, isLE) {\n    const h = fromNumH(n);\n    const l = fromNumL(n);\n    view.setUint32(byteOffset, isLE ? l : h, isLE);\n    view.setUint32(byteOffset + 4, isLE ? h : l, isLE);\n}\n// High 32-bit half of a 64-bit logical right shift for `s` in `0..31`.\nconst shrSH = (h, _l, s) => h >>> s;\n// Low 32-bit half of a 64-bit logical right shift, valid for `s` in `1..31`.\nconst shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// High 32-bit half of a 64-bit right rotate, valid for `s` in `1..31`.\nconst rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));\n// Low 32-bit half of a 64-bit right rotate, valid for `s` in `1..31`.\nconst rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// High 32-bit half of a 64-bit right rotate, valid for `s` in `33..63`; `32` uses `rotr32*`.\nconst rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));\n// Low 32-bit half of a 64-bit right rotate, valid for `s` in `33..63`; `32` uses `rotr32*`.\nconst rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));\n// High 32-bit half of a 64-bit right rotate for `s === 32`; this is just the swapped low half.\nconst rotr32H = (_h, l) => l;\n// Low 32-bit half of a 64-bit right rotate for `s === 32`; this is just the swapped high half.\nconst rotr32L = (h, _l) => h;\n// 64-bit left rotates (rotl*) are not defined here: sha3.ts, their only consumer, keeps\n// local copies so V8 inlines them into keccakP.\n// Add two split 64-bit words and return the split `{ h, l }` sum.\n// JS uses 32-bit signed integers for bitwise operations, so we cannot simply shift the carry out\n// of the low sum and instead use division.\nfunction add(Ah, Al, Bh, Bl) {\n    const l = (Al >>> 0) + (Bl >>> 0);\n    return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };\n}\n// Addition with more than 2 elements\n// Unmasked low-word accumulator for 3-way addition; pass the raw result into `add3H(...)`.\nconst add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);\n// High-word finalize step for 3-way addition; `low` must be the untruncated output of `add3L(...)`.\nconst add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;\n// Unmasked low-word accumulator for 4-way addition; pass the raw result into `add4H(...)`.\nconst add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);\n// High-word finalize step for 4-way addition; `low` must be the untruncated output of `add4L(...)`.\nconst add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;\n// Unmasked low-word accumulator for 5-way addition; pass the raw result into `add5H(...)`.\nconst add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);\n// High-word finalize step for 5-way addition; `low` must be the untruncated output of `add5L(...)`.\nconst add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;\n// prettier-ignore\nexport { add, add3H, add3L, add4H, add4L, add5H, add5L, fromBig, fromNumH, fromNumL, rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL, setU64FromNum, shrSH, shrSL, split, toBig };\n","/**\n * Checks if something is Uint8Array. Be careful: nodejs Buffer will return true.\n * @param a - value to test\n * @returns `true` when the value is a Uint8Array-compatible view.\n * @example\n * Check whether a value is a Uint8Array-compatible view.\n * ```ts\n * isBytes(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport function isBytes(a) {\n    // Plain `instanceof Uint8Array` is too strict for some Buffer / proxy / cross-realm cases.\n    // The fallback still requires a real ArrayBuffer view, so plain\n    // JSON-deserialized `{ constructor: ... }` spoofing is rejected, and\n    // `BYTES_PER_ELEMENT === 1` keeps the fallback on byte-oriented views.\n    return (a instanceof Uint8Array ||\n        (ArrayBuffer.isView(a) &&\n            a.constructor.name === 'Uint8Array' &&\n            'BYTES_PER_ELEMENT' in a &&\n            a.BYTES_PER_ELEMENT === 1));\n}\n// Shared error-message prefix builder. Only called on throw paths, so assert\n// success paths never pay for the string concatenation.\nconst atitle = (title) => (title ? `\"${title}\" ` : '');\n/**\n * Asserts something is a non-negative integer.\n * @param n - number to validate\n * @param title - label included in thrown errors\n * @returns The validated number.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @example\n * Validate a non-negative integer option.\n * ```ts\n * anumber(32, 'length');\n * ```\n */\nexport function anumber(n, title = '') {\n    if (typeof n !== 'number')\n        throw new TypeError(atitle(title) + 'expected number, got ' + typeof n);\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new RangeError(atitle(title) + 'expected integer >= 0, got ' + n);\n    return n;\n}\n/**\n * Asserts something is a boolean.\n * @param value - value to validate\n * @param title - label included in thrown errors\n * @returns The validated boolean.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Validate a boolean option.\n * ```ts\n * abool(true, 'enableXOF');\n * ```\n */\nexport function abool(value, title = '') {\n    if (typeof value !== 'boolean')\n        throw new TypeError(atitle(title) + 'expected boolean, got type=' + typeof value);\n    return value;\n}\n/**\n * Asserts something is Uint8Array.\n * @param value - value to validate\n * @param length - optional exact length constraint\n * @param title - label included in thrown errors\n * @returns The validated byte array.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @example\n * Validate that a value is a byte array.\n * ```ts\n * abytes(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport function abytes(value, length, title = '') {\n    // Success path first: this runs at the start of every update() / digestInto(), and the\n    // common `abytes(data)` form must not pay for length handling it does not use.\n    if (isBytes(value) && (length === undefined || value.length === length))\n        return value;\n    // Error path: recompute freely to build the exact message.\n    if (length !== undefined)\n        anumber(length, 'length');\n    const bytes = isBytes(value);\n    const ofLen = length !== undefined ? ` of length ${length}` : '';\n    const got = bytes ? `length=${value.length}` : `type=${typeof value}`;\n    const message = atitle(title) + 'expected Uint8Array' + ofLen + ', got ' + got;\n    if (!bytes)\n        throw new TypeError(message);\n    throw new RangeError(message);\n}\n/**\n * Copies bytes into a fresh Uint8Array.\n * Buffer-style slices can alias the same backing store, so callers that need ownership should copy.\n * @param bytes - source bytes to clone\n * @returns Freshly allocated copy of `bytes`.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Clone a byte array before mutating it.\n * ```ts\n * const copy = copyBytes(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport function copyBytes(bytes) {\n    // `Uint8Array.from(...)` would also accept arrays / other typed arrays. Keep this helper strict\n    // because callers use it at byte-validation boundaries before mutating the detached copy.\n    return Uint8Array.from(abytes(bytes));\n}\n/**\n * Asserts something is a wrapped hash constructor.\n * @param h - hash constructor to validate\n * @throws On wrong argument types or invalid hash wrapper shape. {@link TypeError}\n * @throws On invalid hash metadata ranges or values. {@link RangeError}\n * @throws If the hash metadata allows empty outputs or block sizes. {@link Error}\n * @example\n * Validate a callable hash wrapper.\n * ```ts\n * import { ahash } from '@noble/hashes/utils.js';\n * import { sha256 } from '@noble/hashes/sha2.js';\n * ahash(sha256);\n * ```\n */\nexport function ahash(h) {\n    if (typeof h !== 'function' || typeof h.create !== 'function')\n        throw new TypeError('expected hash wrapped by utils.createHasher');\n    anumber(h.outputLen);\n    anumber(h.blockLen);\n    // HMAC and KDF callers treat these as real byte lengths; allowing zero lets fake wrappers pass\n    // validation and can produce empty outputs instead of failing fast.\n    if (h.outputLen < 1 || h.blockLen < 1)\n        throw new Error('hash blockLen / outputLen must be >= 1');\n}\nconst aobject = (value, label) => {\n    if (value === null || typeof value !== 'object' || Array.isArray(value))\n        throw new TypeError((label === 'object' ? '' : `\"${label}\" `) + 'expected object, got type=' + typeof value);\n};\n/**\n * Asserts a hash instance has not been destroyed or finished.\n * @param instance - hash instance to validate\n * @param checkFinished - whether to reject finalized instances\n * @throws If the hash instance has already been destroyed or finalized. {@link Error}\n * @example\n * Validate that a hash instance is still usable.\n * ```ts\n * import { aexists } from '@noble/hashes/utils.js';\n * import { sha256 } from '@noble/hashes/sha2.js';\n * const hash = sha256.create();\n * aexists(hash);\n * ```\n */\nexport function aexists(instance, checkFinished = true) {\n    // Runs on every update()/digestInto(); the flags are library-owned booleans, so only their\n    // truthiness is checked - re-validating their type per call was pure hot-path overhead.\n    if (instance.destroyed)\n        throw new Error('hash was destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('digest() was already called');\n}\n/**\n * Asserts output is a sufficiently-sized byte array.\n * @param out - destination buffer\n * @param instance - hash instance providing output length\n * Oversized buffers are allowed; downstream code only promises to fill the first `outputLen` bytes.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @example\n * Validate a caller-provided digest buffer.\n * ```ts\n * import { aoutput } from '@noble/hashes/utils.js';\n * import { sha256 } from '@noble/hashes/sha2.js';\n * const hash = sha256.create();\n * aoutput(new Uint8Array(hash.outputLen), hash);\n * ```\n */\nexport function aoutput(out, instance) {\n    abytes(out, undefined, 'output');\n    // `outputLen` is a library-owned readonly number; the negated comparison keeps failing fast\n    // when it is missing/NaN (comparisons with undefined/NaN are false) without an anumber() call.\n    const min = instance.outputLen;\n    if (!(out.length >= min)) {\n        throw new RangeError('\"output\" expected length >= ' + min);\n    }\n}\n/**\n * Casts a typed array view to Uint8Array.\n * @param arr - source typed array\n * @returns Uint8Array view over the same buffer.\n * @example\n * Reinterpret a typed array as bytes.\n * ```ts\n * u8(new Uint32Array([1, 2]));\n * ```\n */\nexport function u8(arr) {\n    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/**\n * Casts a typed array view to Uint32Array.\n * `arr.byteOffset` must already be 4-byte aligned or the platform\n * Uint32Array constructor will throw.\n * @param arr - source typed array\n * @returns Uint32Array view over the same buffer.\n * @example\n * Reinterpret a byte array as 32-bit words.\n * ```ts\n * u32(new Uint8Array(8));\n * ```\n */\nexport function u32(arr) {\n    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n/**\n * Zeroizes typed arrays in place. Warning: JS provides no guarantees.\n * @param arrays - arrays to overwrite with zeros\n * @example\n * Zeroize sensitive buffers in place.\n * ```ts\n * clean(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport function clean(...arrays) {\n    for (let i = 0; i < arrays.length; i++) {\n        arrays[i].fill(0);\n    }\n}\n/**\n * Creates a DataView for byte-level manipulation.\n * @param arr - source typed array\n * @returns DataView over the same buffer region.\n * @example\n * Create a DataView over an existing buffer.\n * ```ts\n * createView(new Uint8Array(4));\n * ```\n */\nexport function createView(arr) {\n    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/**\n * Rotate-right operation for uint32 values.\n * @param word - source word\n * @param shift - shift amount in bits\n * @returns Rotated word.\n * @example\n * Rotate a 32-bit word to the right.\n * ```ts\n * rotr(0x12345678, 8);\n * ```\n */\nexport function rotr(word, shift) {\n    return (word << (32 - shift)) | (word >>> shift);\n}\n/**\n * Rotate-left operation for uint32 values.\n * @param word - source word\n * @param shift - shift amount in bits\n * @returns Rotated word.\n * @example\n * Rotate a 32-bit word to the left.\n * ```ts\n * rotl(0x12345678, 8);\n * ```\n */\nexport function rotl(word, shift) {\n    return (word << shift) | ((word >>> (32 - shift)) >>> 0);\n}\n/** Whether the current platform is little-endian. */\nexport const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n/**\n * Byte-swap operation for uint32 values.\n * @param word - source word\n * @returns Word with reversed byte order.\n * @example\n * Reverse the byte order of a 32-bit word.\n * ```ts\n * byteSwap(0x11223344);\n * ```\n */\nexport function byteSwap(word) {\n    return (((word << 24) & 0xff000000) |\n        ((word << 8) & 0xff0000) |\n        ((word >>> 8) & 0xff00) |\n        ((word >>> 24) & 0xff));\n}\n/**\n * Conditionally byte-swaps one 32-bit word on big-endian platforms.\n * @param n - source word\n * @returns Original or byte-swapped word depending on platform endianness.\n * @example\n * Normalize a 32-bit word for host endianness.\n * ```ts\n * swap8IfBE(0x11223344);\n * ```\n */\nexport const swap8IfBE = isLE\n    ? (n) => n\n    : (n) => byteSwap(n) >>> 0;\n/**\n * Byte-swaps every word of a Uint32Array in place.\n * @param arr - array to mutate\n * @returns The same array after mutation; callers pass live state arrays here.\n * @example\n * Reverse the byte order of every word in place.\n * ```ts\n * byteSwap32(new Uint32Array([0x11223344]));\n * ```\n */\nexport function byteSwap32(arr) {\n    for (let i = 0; i < arr.length; i++) {\n        arr[i] = byteSwap(arr[i]);\n    }\n    return arr;\n}\n/**\n * Conditionally byte-swaps a Uint32Array on big-endian platforms.\n * @param u - array to normalize for host endianness\n * @returns Original or byte-swapped array depending on platform endianness.\n *   On big-endian runtimes this mutates `u` in place via `byteSwap32(...)`.\n * @example\n * Normalize a word array for host endianness.\n * ```ts\n * swap32IfBE(new Uint32Array([0x11223344]));\n * ```\n */\nexport const swap32IfBE = isLE\n    ? (u) => u\n    : byteSwap32;\n// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\nconst hasHexBuiltin = /* @__PURE__ */ (() => \n// @ts-ignore\ntypeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * Convert byte array to hex string.\n * Uses the built-in function when available and assumes it matches the tested\n * fallback semantics.\n * @param bytes - bytes to encode\n * @returns Lowercase hexadecimal string.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Convert bytes to lowercase hexadecimal.\n * ```ts\n * bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])); // 'cafe0123'\n * ```\n */\nexport function bytesToHex(bytes) {\n    abytes(bytes);\n    // @ts-ignore\n    if (hasHexBuiltin)\n        return bytes.toHex();\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\n// Strict ASCII nibble parser: non-ASCII hex lookalikes are rejected as undefined.\n// ASCII codes: '0'..'9' = 48..57, 'A'..'F' = 65..70, 'a'..'f' = 97..102.\n// prettier-ignore\nfunction asciiToBase16(ch) {\n    return ch >= 48 && ch <= 57 ? ch - 48 // '2' => 50-48\n        : ch >= 65 && ch <= 70 ? ch - (65 - 10) // 'B' => 66-(65-10)\n            : ch >= 97 && ch <= 102 ? ch - (97 - 10) // 'b' => 98-(97-10)\n                : undefined;\n}\n/**\n * Convert hex string to byte array. Uses built-in function, when available.\n * @param hex - hexadecimal string to decode\n * @returns Decoded bytes.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @example\n * Decode lowercase hexadecimal into bytes.\n * ```ts\n * hexToBytes('cafe0123'); // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n * ```\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new TypeError('hex string expected, got ' + typeof hex);\n    if (hasHexBuiltin) {\n        try {\n            return Uint8Array.fromHex(hex);\n        }\n        catch (error) {\n            if (error instanceof SyntaxError)\n                throw new RangeError(error.message);\n            throw error;\n        }\n    }\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new RangeError('hex string expected, got unpadded hex of length ' + hl);\n    const array = new Uint8Array(al);\n    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n        const n1 = asciiToBase16(hex.charCodeAt(hi)); // parse first char, multiply it by 16\n        const n2 = asciiToBase16(hex.charCodeAt(hi + 1)); // parse second char\n        if (n1 === undefined || n2 === undefined) {\n            const char = hex[hi] + hex[hi + 1];\n            throw new RangeError('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n        }\n        array[ai] = n1 * 16 + n2; // example: 'A9' => 10*16 + 9\n    }\n    return array;\n}\n/**\n * There is no setImmediate in browser and setTimeout is slow.\n * This yields to the Promise/microtask scheduler queue, not to timers or the\n * full macrotask event loop.\n * @example\n * Yield to the next scheduler tick.\n * ```ts\n * await nextTick();\n * ```\n */\nexport const nextTick = async () => { };\n/**\n * Returns control to the Promise/microtask scheduler every `tick`\n * milliseconds to avoid blocking long loops.\n * @param iters - number of loop iterations to run\n * @param tick - maximum time slice in milliseconds\n * @param cb - callback executed on each iteration\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @example\n * Run a loop that periodically yields back to the event loop.\n * ```ts\n * await asyncLoop(2, 0, () => {});\n * ```\n */\nexport async function asyncLoop(iters, tick, cb) {\n    anumber(iters, 'iters');\n    anumber(tick, 'tick');\n    if (typeof cb !== 'function')\n        throw new TypeError('callback must be a function');\n    // Callback is synchronous by contract; asyncLoop only yields between sync work windows.\n    let ts = Date.now();\n    for (let i = 0; i < iters; i++) {\n        cb(i);\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < tick)\n            continue;\n        await nextTick();\n        // Track only synchronous work time; scheduler delay after yielding is outside our budget.\n        ts += diff;\n    }\n}\n/**\n * Converts string to bytes using UTF8 encoding.\n * Built-in doesn't validate input to be string: we do the check.\n * Non-ASCII details are delegated to the platform `TextEncoder`.\n * @param str - string to encode\n * @returns UTF-8 encoded bytes.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Encode a string as UTF-8 bytes.\n * ```ts\n * utf8ToBytes('abc'); // Uint8Array.from([97, 98, 99])\n * ```\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new TypeError('string expected');\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Helper for KDFs: consumes Uint8Array or string.\n * String inputs are UTF-8 encoded; byte-array inputs stay aliased to the caller buffer.\n * @param data - user-provided KDF input\n * @param errorTitle - label included in thrown errors\n * @returns Byte representation of the input.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Normalize KDF input to bytes.\n * ```ts\n * kdfInputToBytes('password');\n * ```\n */\nexport function kdfInputToBytes(data, errorTitle = '') {\n    if (typeof data === 'string')\n        return utf8ToBytes(data);\n    return abytes(data, undefined, errorTitle);\n}\n/**\n * Copies several Uint8Arrays into one.\n * @param arrays - arrays to concatenate\n * @returns Concatenated byte array.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Concatenate multiple byte arrays.\n * ```ts\n * concatBytes(new Uint8Array([1]), new Uint8Array([2]));\n * ```\n */\nexport function concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        abytes(a);\n        sum += a.length;\n    }\n    const res = new Uint8Array(sum);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        res.set(a, pad);\n        pad += a.length;\n    }\n    return res;\n}\n/**\n * Validates declared required and optional field types on a plain object.\n * This walks field schemas and formats detailed errors, so avoid it on hot paths; use direct\n * one-line guards such as `abytes()`, `abool()`, or `anumber()` instead.\n * @param object - object to validate\n * @param fields - map of required field names to expected types\n * @param optFields - map of optional field names to expected types\n * @param title - label included in thrown errors\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Validate required and optional option fields.\n * ```ts\n * validateObject({ N: 1024, dkLen: 32 }, { N: 'number' }, { dkLen: 'number' });\n * ```\n */\nexport const validateObject = (object, fields = {}, optFields = {}, title = 'object') => {\n    aobject(object, title);\n    aobject(fields, 'fields');\n    aobject(optFields, 'optFields');\n    function checkField(fieldName, expectedType, isOpt) {\n        const label = title === 'object' ? `param \"${String(fieldName)}\"` : `\"${title}.${String(fieldName)}\"`;\n        // Config fields must be explicit own properties. Optional inherited values are rejected too\n        // because callers keep reading the same options object after validation.\n        const val = object[fieldName];\n        // Runtime objects such as Field instances intentionally satisfy required method slots\n        // via their shared prototype.\n        if (!Object.hasOwn(object, fieldName) &&\n            (isOpt ? val !== undefined : expectedType !== 'function')) {\n            throw new TypeError(`${label} is invalid: expected own property`);\n        }\n        if (isOpt && val === undefined)\n            return;\n        const current = typeof val;\n        if (current !== expectedType || val === null)\n            throw new TypeError(`${label} is invalid: expected ${expectedType}, got ${current}`);\n    }\n    const iter = (f, isOpt) => Object.entries(f).forEach(([k, v]) => checkField(k, v, isOpt));\n    iter(fields, false);\n    iter(optFields, true);\n};\n/**\n * Merges default options and passed options.\n * @param defaults - base option object\n * @param opts - user overrides\n * @param title - label included in thrown override errors\n * @returns Merged option object. The merge mutates `defaults` in place.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Merge user overrides onto default options.\n * ```ts\n * checkOpts({ dkLen: 32 }, { asyncTick: 10 });\n * ```\n */\nexport function checkOpts(defaults, opts, title = 'opts') {\n    aobject(defaults, 'defaults');\n    if (opts !== undefined)\n        aobject(opts, title);\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\n/**\n * Creates a callable hash function from a stateful class constructor.\n * @param hashCons - hash constructor or factory\n * @param info - optional metadata such as DER OID\n * @returns Frozen callable hash wrapper with `.create()`.\n *   Wrapper construction eagerly calls `hashCons(undefined)` once to read\n *   `outputLen` / `blockLen`, so constructor side effects happen at module\n *   init time.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Wrap a stateful hash constructor into a callable helper.\n * ```ts\n * import { createHasher } from '@noble/hashes/utils.js';\n * import { sha256 } from '@noble/hashes/sha2.js';\n * const wrapped = createHasher(sha256.create, { oid: sha256.oid });\n * wrapped(new Uint8Array([1]));\n * ```\n */\nexport function createHasher(hashCons, info = {}) {\n    if (typeof hashCons !== 'function')\n        throw new TypeError('\"hashCons\" expected function, got type=' + typeof hashCons);\n    info = checkOpts({}, info, 'info');\n    const hashC = (msg, opts) => hashCons(opts)\n        .update(msg)\n        .digest();\n    const tmp = hashCons(undefined);\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.canXOF = tmp.canXOF;\n    hashC.create = (opts) => hashCons(opts);\n    Object.assign(hashC, info);\n    return Object.freeze(hashC);\n}\n/**\n * Cryptographically secure PRNG backed by `crypto.getRandomValues`.\n * @param bytesLength - number of random bytes to generate\n * @returns Random bytes.\n * The platform `getRandomValues()` implementation still defines any\n * single-call length cap, and this helper rejects oversize requests\n * with a stable library `RangeError` instead of host-specific errors.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @throws If the current runtime does not provide `crypto.getRandomValues`. {@link Error}\n * @example\n * Generate a fresh random key or nonce.\n * ```ts\n * const key = randomBytes(16);\n * ```\n */\nexport function randomBytes(bytesLength = 32) {\n    // Match the repo's other length-taking helpers instead of relying on Uint8Array coercion.\n    anumber(bytesLength, 'bytesLength');\n    const cr = typeof globalThis === 'object' ? globalThis.crypto : null;\n    if (typeof cr?.getRandomValues !== 'function')\n        throw new Error('crypto.getRandomValues must be defined');\n    // Web Cryptography API Level 2 §10.1.1:\n    // if `byteLength > 65536`, throw `QuotaExceededError`.\n    // Keep the guard explicit so callers can see the quota in code\n    // instead of discovering it by reading the spec or host errors.\n    // This wrapper surfaces the same quota as a stable library RangeError.\n    if (bytesLength > 65536)\n        throw new RangeError(`\"bytesLength\" expected <= 65536, got ${bytesLength}`);\n    return cr.getRandomValues(new Uint8Array(bytesLength));\n}\n/**\n * Creates OID metadata for NIST hashes with prefix `06 09 60 86 48 01 65 03 04 02`.\n * @param suffix - final OID byte for the selected hash.\n *   The helper accepts any byte even though only the documented NIST hash\n *   suffixes are meaningful downstream.\n * @returns Object containing the DER-encoded OID.\n * @example\n * Build OID metadata for a NIST hash.\n * ```ts\n * oidNist(0x01);\n * ```\n */\nexport const oidNist = (suffix) => ({\n    // Current NIST hashAlgs suffixes used here fit in one DER subidentifier octet.\n    // Larger suffix values would need base-128 OID encoding and a different length byte.\n    oid: Uint8Array.from([0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, suffix]),\n});\n","/**\n * Internal helpers for blake hash.\n * @module\n */\nimport { rotr } from \"./utils.js\";\n// Unrealized speed-up: a file-local copy of rotr measured ~1-2% faster blake2s/blake256/blake3\n// on Node 24 (V8 does not inline it into G1s/G2s across the module boundary). Reused from\n// utils for deduplication.\n/**\n * Internal blake permutation table.\n * Rows `0..9` serve BLAKE2s, rows `0..11` serve BLAKE2b with `10..11 = 0..1`, and Blake1 also\n * reuses the later rows shown below. Blake1 expands rounds `10..15` as `SIGMA[i % 10]`, so rows\n * `10..15` intentionally repeat rows `0..5` for the 14-round (256) and 16-round (512) variants.\n */\n// prettier-ignore\nexport const BSIGMA = /* @__PURE__ */ Uint8Array.from([\n    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n    14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,\n    11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,\n    7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,\n    9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,\n    2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,\n    12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11,\n    13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10,\n    6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5,\n    10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0,\n    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n    14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,\n    // Blake1, unused in others\n    11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,\n    7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,\n    9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,\n    2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,\n]);\n// Unrealized speed-up: G1s/G2s return a fresh {a,b,c,d} per call (160×/blake2s block), which\n// V8's escape analysis does not eliminate when G stays a real call. Writing into one reused\n// module-level slot instead measured +4-6% blake2s/blake256 1MB throughput on Node 24 — but\n// ~2% slower blake3 (whose profile inlines G and scalar-replaces the fresh object) and no\n// difference on 32-byte inputs. Kept simple.\n// 32-bit / BLAKE2s first half of G, with the fixed `(16, 12)` rotation pair.\n// Parameter `x` is the RFC 7693 first-half message word, or Blake1's pre-mixed\n// `m[sigma[r][2i]] ^ u[sigma[r][2i+1]]` addend in the 32-bit path.\nexport function G1s(a, b, c, d, x) {\n    a = (a + b + x) | 0;\n    d = rotr(d ^ a, 16);\n    c = (c + d) | 0;\n    b = rotr(b ^ c, 12);\n    return { a, b, c, d };\n}\n// 32-bit / BLAKE2s second half of G.\n// Parameter `x` is the RFC 7693 second-half (`y`) message word, or Blake1's pre-mixed\n// `m[sigma[r][2i + 1]] ^ u[sigma[r][2i]]` addend in the 32-bit path.\nexport function G2s(a, b, c, d, x) {\n    a = (a + b + x) | 0;\n    d = rotr(d ^ a, 8);\n    c = (c + d) | 0;\n    b = rotr(b ^ c, 7);\n    return { a, b, c, d };\n}\n","/**\n * Internal Merkle-Damgard hash utils.\n * @module\n */\nimport { setU64FromNum } from \"./_u64.js\";\nimport { abytes, aexists, aoutput, createView } from \"./utils.js\";\n/**\n * Shared 32-bit conditional boolean primitive reused by SHA-256, SHA-1, and MD5 `F`.\n * Returns bits from `b` when `a` is set, otherwise from `c`.\n * The XOR form is equivalent to MD5's `F(X,Y,Z) = XY v not(X)Z` because the masked terms never\n * set the same bit.\n * @param a - selector word\n * @param b - word chosen when selector bit is set\n * @param c - word chosen when selector bit is clear\n * @returns Mixed 32-bit word.\n * @example\n * Combine three words with the shared 32-bit choice primitive.\n * ```ts\n * Chi(0xffffffff, 0x12345678, 0x87654321);\n * ```\n */\nexport function Chi(a, b, c) {\n    return (a & b) ^ (~a & c);\n}\n/**\n * Shared 32-bit majority primitive reused by SHA-256 and SHA-1.\n * Returns bits shared by at least two inputs.\n * @param a - first input word\n * @param b - second input word\n * @param c - third input word\n * @returns Mixed 32-bit word.\n * @example\n * Combine three words with the shared 32-bit majority primitive.\n * ```ts\n * Maj(0xffffffff, 0x12345678, 0x87654321);\n * ```\n */\nexport function Maj(a, b, c) {\n    return (a & b) ^ (a & c) ^ (b & c);\n}\n/**\n * Merkle-Damgard hash construction base class.\n * Could be used to create MD5, RIPEMD, SHA1, SHA2.\n * Accepts only byte-aligned `Uint8Array` input, even when the underlying spec describes bit\n * strings with partial-byte tails.\n * @param blockLen - internal block size in bytes\n * @param outputLen - digest size in bytes\n * @param padOffset - trailing length field size in bytes\n * @param isLE - whether length and state words are encoded in little-endian\n * @example\n * Use a concrete subclass to get the shared Merkle-Damgard update/digest flow.\n * ```ts\n * import { _SHA1 } from '@noble/hashes/legacy.js';\n * const hash = new _SHA1();\n * hash.update(new Uint8Array([97, 98, 99]));\n * hash.digest();\n * ```\n */\nexport class HashMD {\n    blockLen;\n    outputLen;\n    canXOF = false;\n    padOffset;\n    isLE;\n    // For partial updates less than block size\n    buffer;\n    view;\n    finished = false;\n    length = 0;\n    pos = 0;\n    destroyed = false;\n    constructor(blockLen, outputLen, padOffset, isLE) {\n        this.blockLen = blockLen;\n        this.outputLen = outputLen;\n        this.padOffset = padOffset;\n        this.isLE = isLE;\n        this.buffer = new Uint8Array(blockLen);\n        this.view = createView(this.buffer);\n    }\n    update(data) {\n        aexists(this);\n        abytes(data);\n        const { view, buffer, blockLen } = this;\n        const len = data.length;\n        let processed = false;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            // Fast path only when there is no buffered partial block: `take === blockLen` implies\n            // `this.pos === 0`, so we can process full blocks directly from the input view.\n            if (take === blockLen) {\n                const dataView = createView(data);\n                for (; blockLen <= len - pos; pos += blockLen)\n                    this.process(dataView, pos);\n                processed = true;\n                continue;\n            }\n            // When the whole input is buffered in one go (common for short messages), passing `data`\n            // directly avoids allocating a subarray view.\n            buffer.set(pos === 0 && take === len ? data : data.subarray(pos, pos + take), this.pos);\n            this.pos += take;\n            pos += take;\n            if (this.pos === blockLen) {\n                this.process(view, 0);\n                this.pos = 0;\n                processed = true;\n            }\n        }\n        this.length += data.length;\n        // Shared schedule buffers only pick up input-derived words inside process(); if everything\n        // was buffered without processing, there is nothing to zero.\n        if (processed)\n            this.roundClean();\n        return this;\n    }\n    digestInto(out) {\n        aexists(this);\n        aoutput(out, this);\n        this.finished = true;\n        // Padding\n        // We can avoid allocation of buffer for padding completely if it\n        // was previously not allocated here. But it won't change performance.\n        const { buffer, view, blockLen, isLE } = this;\n        let { pos } = this;\n        // append the bit '1' to the message, then zero-pad the rest of the block\n        buffer[pos++] = 0b10000000;\n        buffer.fill(0, pos);\n        // we have less than padOffset left in buffer, so we cannot put length in\n        // current block, need process it and pad again\n        if (this.padOffset > blockLen - pos) {\n            this.process(view, 0);\n            buffer.fill(0);\n        }\n        // `padOffset` reserves the whole length field. For SHA-384/512 the high 64 bits stay zero from\n        // the padding fill above, and JS will overflow before user input can make that half non-zero.\n        // So we only need to write the low 64 bits here (`length * 8` only scales the exponent of an\n        // integer below 2**53, so the split inside the helper stays exact).\n        setU64FromNum(view, blockLen - 8, this.length * 8, isLE);\n        this.process(view, 0);\n        // The final block above is processed outside update(), so the shared message-schedule\n        // buffers (e.g. SHA256_W) would otherwise retain input-derived words after digest().\n        this.roundClean();\n        // digest() passes our own `buffer` as `out`; reuse its cached view instead of allocating one.\n        const oview = out === buffer ? view : createView(out);\n        const len = this.outputLen;\n        // NOTE: we do division by 4 later, which must be fused in single op with modulo by JIT\n        const outLen = len / 4;\n        const state = this.get();\n        // Subclass-misconfiguration invariant: outputLen must be 32-bit aligned and fit the state.\n        if (len % 4 || outLen > state.length)\n            throw new Error('invalid outputLen');\n        for (let i = 0; i < outLen; i++)\n            oview.setUint32(4 * i, state[i], isLE);\n    }\n    digest() {\n        const { buffer, outputLen } = this;\n        this.digestInto(buffer);\n        // Copy before destroy(): subclasses wipe `buffer` during cleanup, but `digest()` must return\n        // fresh bytes to the caller.\n        const res = buffer.slice(0, outputLen);\n        this.destroy();\n        return res;\n    }\n    _cloneIntoMeta(to) {\n        const { buffer, length, finished, destroyed, pos } = this;\n        to.destroyed = destroyed;\n        to.finished = finished;\n        to.length = length;\n        to.pos = pos;\n        // Only partial-block bytes need copying: when `length % blockLen === 0`, `pos === 0` and\n        // later `update()` / `digestInto()` overwrite `to.buffer` from the start before reading it.\n        if (pos)\n            to.buffer.set(buffer); // Avoid a hot modulo guard.\n        return to;\n    }\n    clone() {\n        return this._cloneInto();\n    }\n}\n/**\n * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.\n * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.\n */\n/** Initial SHA256 state from RFC 6234 §6.1: the first 32 bits of the fractional parts of the\n * square roots of the first eight prime numbers. Exported as a shared table; callers must treat\n * it as read-only because constructors copy words from it by index. */\nexport const SHA256_IV = /* @__PURE__ */ Uint32Array.from([\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,\n]);\n/** Initial SHA224 state `H(0)` from RFC 6234 §6.1. Exported as a shared table; callers must\n * treat it as read-only because constructors copy words from it by index. */\nexport const SHA224_IV = /* @__PURE__ */ Uint32Array.from([\n    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,\n]);\n/** Initial SHA384 state from RFC 6234 §6.3: eight RFC 64-bit `H(0)` words stored as sixteen\n * big-endian 32-bit halves. Derived from the fractional parts of the square roots of the ninth\n * through sixteenth prime numbers. Exported as a shared table; callers must treat it as read-only\n * because constructors copy halves from it by index. */\nexport const SHA384_IV = /* @__PURE__ */ Uint32Array.from([\n    0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939,\n    0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4,\n]);\n/** Initial SHA512 state from RFC 6234 §6.3: eight RFC 64-bit `H(0)` words stored as sixteen\n * big-endian 32-bit halves. Derived from the fractional parts of the square roots of the first\n * eight prime numbers. Exported as a shared table; callers must treat it as read-only because\n * constructors copy halves from it by index. */\nexport const SHA512_IV = /* @__PURE__ */ Uint32Array.from([\n    0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,\n    0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,\n]);\n","/**\n * blake2b (64-bit) & blake2s (8 to 32-bit) hash functions.\n * b could have been faster, but there is no fast u64 in js, so s is 1.5x faster.\n * @module\n */\nimport { BSIGMA, G1s, G2s } from \"./_blake.js\";\nimport { SHA256_IV } from \"./_md.js\";\nimport * as u64 from \"./_u64.js\";\n// prettier-ignore\nimport { abytes, aexists, anumber, aoutput, checkOpts, clean, copyBytes, createHasher, swap32IfBE, swap8IfBE, u32 } from \"./utils.js\";\n// Same IV words as `SHA512_IV`, but endian-swapped into LE u32 low/high halves\n// for the BLAKE2b u64 helpers below.\nconst B2B_IV = /* @__PURE__ */ Uint32Array.from([\n    0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372, 0x5f1d36f1, 0xa54ff53a,\n    0xade682d1, 0x510e527f, 0x2b3e6c1f, 0x9b05688c, 0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19,\n]);\n// Shared synchronous BLAKE2b work vector as LE u32 low/high halves.\nconst BBUF = /* @__PURE__ */ new Uint32Array(32);\n// BLAKE2b G mix split into two half-rounds over LE u32 low/high limbs.\nfunction G1b(a, b, c, d, msg, x) {\n    // NOTE: V is LE here\n    const Xl = msg[x], Xh = msg[x + 1]; // prettier-ignore\n    let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1]; // prettier-ignore\n    let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1]; // prettier-ignore\n    let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1]; // prettier-ignore\n    let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1]; // prettier-ignore\n    // v[a] = (v[a] + v[b] + x) | 0;\n    const ll = u64.add3L(Al, Bl, Xl);\n    Ah = u64.add3H(ll, Ah, Bh, Xh);\n    Al = ll | 0;\n    // v[d] = rotr(v[d] ^ v[a], 32)\n    let xh = Dh ^ Ah, xl = Dl ^ Al; // prettier-ignore\n    Dh = u64.rotr32H(xh, xl);\n    Dl = u64.rotr32L(xh, xl);\n    // v[c] = (v[c] + v[d]) | 0;\n    ({ h: Ch, l: Cl } = u64.add(Ch, Cl, Dh, Dl));\n    // v[b] = rotr(v[b] ^ v[c], 24)\n    xh = Bh ^ Ch;\n    xl = Bl ^ Cl;\n    Bh = u64.rotrSH(xh, xl, 24);\n    Bl = u64.rotrSL(xh, xl, 24);\n    BBUF[2 * a] = Al;\n    BBUF[2 * a + 1] = Ah;\n    BBUF[2 * b] = Bl;\n    BBUF[2 * b + 1] = Bh;\n    BBUF[2 * c] = Cl;\n    BBUF[2 * c + 1] = Ch;\n    BBUF[2 * d] = Dl;\n    BBUF[2 * d + 1] = Dh;\n}\n// Second half-round of the same LE-limb BLAKE2b G mix; `x` is the message word offset.\nfunction G2b(a, b, c, d, msg, x) {\n    // NOTE: V is LE here\n    const Xl = msg[x], Xh = msg[x + 1]; // prettier-ignore\n    let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1]; // prettier-ignore\n    let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1]; // prettier-ignore\n    let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1]; // prettier-ignore\n    let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1]; // prettier-ignore\n    // v[a] = (v[a] + v[b] + x) | 0;\n    const ll = u64.add3L(Al, Bl, Xl);\n    Ah = u64.add3H(ll, Ah, Bh, Xh);\n    Al = ll | 0;\n    // v[d] = rotr(v[d] ^ v[a], 16)\n    let xh = Dh ^ Ah, xl = Dl ^ Al; // prettier-ignore\n    Dh = u64.rotrSH(xh, xl, 16);\n    Dl = u64.rotrSL(xh, xl, 16);\n    // v[c] = (v[c] + v[d]) | 0;\n    ({ h: Ch, l: Cl } = u64.add(Ch, Cl, Dh, Dl));\n    // v[b] = rotr(v[b] ^ v[c], 63)\n    xh = Bh ^ Ch;\n    xl = Bl ^ Cl;\n    Bh = u64.rotrBH(xh, xl, 63);\n    Bl = u64.rotrBL(xh, xl, 63);\n    BBUF[2 * a] = Al;\n    BBUF[2 * a + 1] = Ah;\n    BBUF[2 * b] = Bl;\n    BBUF[2 * b + 1] = Bh;\n    BBUF[2 * c] = Cl;\n    BBUF[2 * c + 1] = Ch;\n    BBUF[2 * d] = Dl;\n    BBUF[2 * d + 1] = Dh;\n}\nfunction checkBlake2Opts(outputLen, opts = {}, keyLen, saltLen, persLen) {\n    anumber(keyLen);\n    // RFC 7693 §2.1 requires digest length nn in 1..keyLen (keyLen doubles as\n    // the per-variant max for both key and digest lengths: 64 for b, 32 for s).\n    if (outputLen <= 0 || outputLen > keyLen)\n        throw new Error('\"dkLen\" must be 1..' + keyLen + ', got ' + outputLen);\n    const { key, salt, personalization } = opts;\n    // This API uses `undefined` for the RFC 7693 `kk = 0` case, so a provided key must be non-empty.\n    if (key !== undefined && (key.length < 1 || key.length > keyLen))\n        throw new Error('\"key\" expected to be undefined or of length=1..' + keyLen);\n    if (salt !== undefined)\n        abytes(salt, saltLen, 'salt');\n    if (personalization !== undefined)\n        abytes(personalization, persLen, 'personalization');\n}\n/** Internal base class for BLAKE2. */\nexport class _BLAKE2 {\n    buffer;\n    buffer32;\n    finished = false;\n    destroyed = false;\n    length = 0;\n    pos = 0;\n    blockLen;\n    outputLen;\n    canXOF = false;\n    constructor(blockLen, outputLen) {\n        anumber(blockLen);\n        anumber(outputLen);\n        this.blockLen = blockLen;\n        this.outputLen = outputLen;\n        this.buffer = new Uint8Array(blockLen);\n        this.buffer32 = u32(this.buffer);\n    }\n    update(data) {\n        aexists(this);\n        abytes(data);\n        // Main difference with other hashes: there is flag for last block,\n        // so we cannot process current block before we know that there\n        // is the next one. This significantly complicates logic and reduces ability\n        // to do zero-copy processing\n        const { blockLen, buffer, buffer32 } = this;\n        const len = data.length;\n        const offset = data.byteOffset;\n        const buf = data.buffer;\n        for (let pos = 0; pos < len;) {\n            // If buffer is full and we still have input (don't process last block, same as blake2s)\n            if (this.pos === blockLen) {\n                swap32IfBE(buffer32);\n                this.compress(buffer32, 0, false);\n                swap32IfBE(buffer32);\n                this.pos = 0;\n            }\n            const take = Math.min(blockLen - this.pos, len - pos);\n            const dataOffset = offset + pos;\n            // Zero-copy only for full, 4-byte-aligned, non-final blocks.\n            if (take === blockLen && !(dataOffset % 4) && pos + take < len) {\n                const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));\n                swap32IfBE(data32);\n                for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {\n                    this.length += blockLen;\n                    this.compress(data32, pos32, false);\n                }\n                swap32IfBE(data32);\n                continue;\n            }\n            // When the whole input is buffered in one go (common for short messages), passing `data`\n            // directly avoids allocating a subarray view.\n            buffer.set(pos === 0 && take === len ? data : data.subarray(pos, pos + take), this.pos);\n            this.pos += take;\n            this.length += take;\n            pos += take;\n        }\n        return this;\n    }\n    digestInto(out) {\n        aexists(this);\n        aoutput(out, this);\n        // Reject unaligned views explicitly instead of hiding them behind a full scratch copy.\n        if (out.byteOffset & 3)\n            throw new RangeError('\"output\" expected 4-byte aligned byteOffset, got ' + out.byteOffset);\n        const { pos, buffer32 } = this;\n        this.finished = true;\n        // Padding\n        this.buffer.fill(0, pos);\n        swap32IfBE(buffer32);\n        this.compress(buffer32, 0, true);\n        swap32IfBE(buffer32);\n        const state = this.get();\n        // digest() passes our own `buffer` as `out`; reuse its cached u32 view instead of allocating.\n        const out32 = out === this.buffer ? buffer32 : u32(out);\n        const full = Math.floor(this.outputLen / 4);\n        for (let i = 0; i < full; i++)\n            out32[i] = swap8IfBE(state[i]);\n        const tail = this.outputLen % 4;\n        if (!tail)\n            return;\n        const off = full * 4;\n        const word = state[full];\n        for (let i = 0; i < tail; i++)\n            out[off + i] = word >>> (8 * i);\n    }\n    digest() {\n        const { buffer, outputLen } = this;\n        this.digestInto(buffer);\n        // Return a copy so callers do not alias the instance scratch buffer used during finalization.\n        const res = buffer.slice(0, outputLen);\n        this.destroy();\n        return res;\n    }\n    _cloneInto(to) {\n        const { buffer, length, finished, destroyed, outputLen, pos } = this;\n        // Recreate only `dkLen`; key/salt/personalization are already absorbed into the copied state.\n        to ||= new this.constructor({ dkLen: outputLen });\n        to.set(...this.get());\n        // Last-block-aware lazy compression keeps the pending block live even when full.\n        to.buffer.set(buffer);\n        to.destroyed = destroyed;\n        to.finished = finished;\n        to.length = length;\n        to.pos = pos;\n        // @ts-ignore\n        to.outputLen = outputLen;\n        return to;\n    }\n    clone() {\n        return this._cloneInto();\n    }\n}\n/** Internal blake2b hash class with state stored as LE u32 low/high halves. */\nexport class _BLAKE2b extends _BLAKE2 {\n    // Same IV words as SHA-512 / BLAKE2b, encoded as LE u32 low/high halves.\n    v0l = B2B_IV[0] | 0;\n    v0h = B2B_IV[1] | 0;\n    v1l = B2B_IV[2] | 0;\n    v1h = B2B_IV[3] | 0;\n    v2l = B2B_IV[4] | 0;\n    v2h = B2B_IV[5] | 0;\n    v3l = B2B_IV[6] | 0;\n    v3h = B2B_IV[7] | 0;\n    v4l = B2B_IV[8] | 0;\n    v4h = B2B_IV[9] | 0;\n    v5l = B2B_IV[10] | 0;\n    v5h = B2B_IV[11] | 0;\n    v6l = B2B_IV[12] | 0;\n    v6h = B2B_IV[13] | 0;\n    v7l = B2B_IV[14] | 0;\n    v7h = B2B_IV[15] | 0;\n    constructor(opts = {}) {\n        opts = checkOpts({}, opts);\n        const olen = opts.dkLen === undefined ? 64 : opts.dkLen;\n        super(128, olen);\n        checkBlake2Opts(olen, opts, 64, 16, 16);\n        let { key, personalization, salt } = opts;\n        let keyLength = 0;\n        if (key !== undefined) {\n            abytes(key, undefined, 'key');\n            keyLength = key.length;\n        }\n        // RFC 7693 §2.5: xor `p[0] = 0x0101kknn` into the low 32 bits of `h[0]`;\n        // the high 32 bits stay at `IV[0]`.\n        this.v0l ^= this.outputLen | (keyLength << 8) | (0x01 << 16) | (0x01 << 24);\n        if (salt !== undefined) {\n            abytes(salt, undefined, 'salt');\n            // Copy: u32() would throw on views with byteOffset not divisible by 4.\n            const slt = u32(copyBytes(salt));\n            this.v4l ^= swap8IfBE(slt[0]);\n            this.v4h ^= swap8IfBE(slt[1]);\n            this.v5l ^= swap8IfBE(slt[2]);\n            this.v5h ^= swap8IfBE(slt[3]);\n        }\n        if (personalization !== undefined) {\n            abytes(personalization, undefined, 'personalization');\n            // Copy: u32() would throw on views with byteOffset not divisible by 4.\n            const pers = u32(copyBytes(personalization));\n            this.v6l ^= swap8IfBE(pers[0]);\n            this.v6h ^= swap8IfBE(pers[1]);\n            this.v7l ^= swap8IfBE(pers[2]);\n            this.v7h ^= swap8IfBE(pers[3]);\n        }\n        if (key !== undefined) {\n            // Pad to blockLen and update\n            const tmp = new Uint8Array(this.blockLen);\n            tmp.set(key);\n            this.update(tmp);\n            // The padded copy holds key material; buffer/state keep what they need.\n            clean(tmp);\n        }\n    }\n    // prettier-ignore\n    get() {\n        let { v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h } = this;\n        return [v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h];\n    }\n    // prettier-ignore\n    set(v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h) {\n        this.v0l = v0l | 0;\n        this.v0h = v0h | 0;\n        this.v1l = v1l | 0;\n        this.v1h = v1h | 0;\n        this.v2l = v2l | 0;\n        this.v2h = v2h | 0;\n        this.v3l = v3l | 0;\n        this.v3h = v3h | 0;\n        this.v4l = v4l | 0;\n        this.v4h = v4h | 0;\n        this.v5l = v5l | 0;\n        this.v5h = v5h | 0;\n        this.v6l = v6l | 0;\n        this.v6h = v6h | 0;\n        this.v7l = v7l | 0;\n        this.v7h = v7h | 0;\n    }\n    compress(msg, offset, isLast) {\n        // First half from state. Direct writes: get() would allocate an array +\n        // closure per block.\n        // prettier-ignore\n        const { v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h } = this;\n        // prettier-ignore\n        {\n            BBUF[0] = v0l;\n            BBUF[1] = v0h;\n            BBUF[2] = v1l;\n            BBUF[3] = v1h;\n            BBUF[4] = v2l;\n            BBUF[5] = v2h;\n            BBUF[6] = v3l;\n            BBUF[7] = v3h;\n            BBUF[8] = v4l;\n            BBUF[9] = v4h;\n            BBUF[10] = v5l;\n            BBUF[11] = v5h;\n            BBUF[12] = v6l;\n            BBUF[13] = v6h;\n            BBUF[14] = v7l;\n            BBUF[15] = v7h;\n        }\n        BBUF.set(B2B_IV, 16); // Second half from IV.\n        const l = u64.fromNumL(this.length);\n        const h = u64.fromNumH(this.length);\n        BBUF[24] = B2B_IV[8] ^ l; // Low word of the offset.\n        BBUF[25] = B2B_IV[9] ^ h; // High word.\n        // Invert all bits for last block\n        if (isLast) {\n            BBUF[28] = ~BBUF[28];\n            BBUF[29] = ~BBUF[29];\n        }\n        let j = 0;\n        const s = BSIGMA;\n        // SIGMA selects 64-bit message words; multiply by 2 because `msg` stores\n        // each word as [low32, high32].\n        for (let i = 0; i < 12; i++) {\n            G1b(0, 4, 8, 12, msg, offset + 2 * s[j++]);\n            G2b(0, 4, 8, 12, msg, offset + 2 * s[j++]);\n            G1b(1, 5, 9, 13, msg, offset + 2 * s[j++]);\n            G2b(1, 5, 9, 13, msg, offset + 2 * s[j++]);\n            G1b(2, 6, 10, 14, msg, offset + 2 * s[j++]);\n            G2b(2, 6, 10, 14, msg, offset + 2 * s[j++]);\n            G1b(3, 7, 11, 15, msg, offset + 2 * s[j++]);\n            G2b(3, 7, 11, 15, msg, offset + 2 * s[j++]);\n            G1b(0, 5, 10, 15, msg, offset + 2 * s[j++]);\n            G2b(0, 5, 10, 15, msg, offset + 2 * s[j++]);\n            G1b(1, 6, 11, 12, msg, offset + 2 * s[j++]);\n            G2b(1, 6, 11, 12, msg, offset + 2 * s[j++]);\n            G1b(2, 7, 8, 13, msg, offset + 2 * s[j++]);\n            G2b(2, 7, 8, 13, msg, offset + 2 * s[j++]);\n            G1b(3, 4, 9, 14, msg, offset + 2 * s[j++]);\n            G2b(3, 4, 9, 14, msg, offset + 2 * s[j++]);\n        }\n        this.v0l ^= BBUF[0] ^ BBUF[16];\n        this.v0h ^= BBUF[1] ^ BBUF[17];\n        this.v1l ^= BBUF[2] ^ BBUF[18];\n        this.v1h ^= BBUF[3] ^ BBUF[19];\n        this.v2l ^= BBUF[4] ^ BBUF[20];\n        this.v2h ^= BBUF[5] ^ BBUF[21];\n        this.v3l ^= BBUF[6] ^ BBUF[22];\n        this.v3h ^= BBUF[7] ^ BBUF[23];\n        this.v4l ^= BBUF[8] ^ BBUF[24];\n        this.v4h ^= BBUF[9] ^ BBUF[25];\n        this.v5l ^= BBUF[10] ^ BBUF[26];\n        this.v5h ^= BBUF[11] ^ BBUF[27];\n        this.v6l ^= BBUF[12] ^ BBUF[28];\n        this.v6h ^= BBUF[13] ^ BBUF[29];\n        this.v7l ^= BBUF[14] ^ BBUF[30];\n        this.v7h ^= BBUF[15] ^ BBUF[31];\n        clean(BBUF);\n    }\n    destroy() {\n        this.destroyed = true;\n        clean(this.buffer32);\n        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n    }\n}\n/**\n * Blake2b hash function. 64-bit. 1.5x slower than blake2s in JS.\n * @param msg - message that would be hashed\n * @param opts - Optional output, MAC, salt, and personalization settings.\n *   `dkLen` must be 1..64 bytes; `salt` and `personalization`, if present,\n *   must be 16 bytes each. See {@link Blake2Opts}.\n * @returns Digest bytes.\n * @example\n * Hash a message with Blake2b.\n * ```ts\n * blake2b(new Uint8Array([97, 98, 99]));\n * ```\n * @example\n * Hash a message with Blake2b while selecting output, MAC, salt, and personalization settings.\n * ```ts\n * blake2b(new Uint8Array([97, 98, 99]), {\n *   dkLen: 32,\n *   key: new Uint8Array(32),\n *   salt: new Uint8Array(16),\n *   personalization: new Uint8Array(16),\n * });\n * ```\n */\nexport const blake2b = /* @__PURE__ */ createHasher((opts) => new _BLAKE2b(opts));\n/**\n * BLAKE2-compress core method.\n * Runs only the round function over a caller-supplied local vector; callers initialize `v0..v15`\n * and apply the final `h[i] ^= v[i] ^ v[i + 8]` fold themselves.\n * @param s - flattened sigma schedule bytes\n * @param offset - starting word offset inside `msg`, not a byte offset\n * @param msg - message words\n * @param rounds - round count to execute\n * @param v0 - state word 0\n * @param v1 - state word 1\n * @param v2 - state word 2\n * @param v3 - state word 3\n * @param v4 - state word 4\n * @param v5 - state word 5\n * @param v6 - state word 6\n * @param v7 - state word 7\n * @param v8 - state word 8\n * @param v9 - state word 9\n * @param v10 - state word 10\n * @param v11 - state word 11\n * @param v12 - state word 12\n * @param v13 - state word 13\n * @param v14 - state word 14\n * @param v15 - state word 15\n * @returns Updated compression state words.\n * @example\n * Run the BLAKE2 compression core on zeroed state and message words.\n * ```ts\n * import { _compress } from '@noble/hashes/blake2.js';\n * const state = _compress(\n *   new Uint8Array(16),\n *   0,\n *   new Uint32Array(16),\n *   1,\n *   0, 0, 0, 0, 0, 0, 0, 0,\n *   0, 0, 0, 0, 0, 0, 0, 0\n * );\n * state.v0;\n * ```\n */\n// prettier-ignore\nexport function _compress(s, offset, msg, rounds, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) {\n    let j = 0;\n    for (let i = 0; i < rounds; i++) {\n        ({ a: v0, b: v4, c: v8, d: v12 } = G1s(v0, v4, v8, v12, msg[offset + s[j++]]));\n        ({ a: v0, b: v4, c: v8, d: v12 } = G2s(v0, v4, v8, v12, msg[offset + s[j++]]));\n        ({ a: v1, b: v5, c: v9, d: v13 } = G1s(v1, v5, v9, v13, msg[offset + s[j++]]));\n        ({ a: v1, b: v5, c: v9, d: v13 } = G2s(v1, v5, v9, v13, msg[offset + s[j++]]));\n        ({ a: v2, b: v6, c: v10, d: v14 } = G1s(v2, v6, v10, v14, msg[offset + s[j++]]));\n        ({ a: v2, b: v6, c: v10, d: v14 } = G2s(v2, v6, v10, v14, msg[offset + s[j++]]));\n        ({ a: v3, b: v7, c: v11, d: v15 } = G1s(v3, v7, v11, v15, msg[offset + s[j++]]));\n        ({ a: v3, b: v7, c: v11, d: v15 } = G2s(v3, v7, v11, v15, msg[offset + s[j++]]));\n        ({ a: v0, b: v5, c: v10, d: v15 } = G1s(v0, v5, v10, v15, msg[offset + s[j++]]));\n        ({ a: v0, b: v5, c: v10, d: v15 } = G2s(v0, v5, v10, v15, msg[offset + s[j++]]));\n        ({ a: v1, b: v6, c: v11, d: v12 } = G1s(v1, v6, v11, v12, msg[offset + s[j++]]));\n        ({ a: v1, b: v6, c: v11, d: v12 } = G2s(v1, v6, v11, v12, msg[offset + s[j++]]));\n        ({ a: v2, b: v7, c: v8, d: v13 } = G1s(v2, v7, v8, v13, msg[offset + s[j++]]));\n        ({ a: v2, b: v7, c: v8, d: v13 } = G2s(v2, v7, v8, v13, msg[offset + s[j++]]));\n        ({ a: v3, b: v4, c: v9, d: v14 } = G1s(v3, v4, v9, v14, msg[offset + s[j++]]));\n        ({ a: v3, b: v4, c: v9, d: v14 } = G2s(v3, v4, v9, v14, msg[offset + s[j++]]));\n    }\n    return { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };\n}\n// Blake2s reuses the SHA-256 IV words as-is.\nconst B2S_IV = /* @__PURE__ */ SHA256_IV.slice();\n/** Internal blake2s hash class. */\nexport class _BLAKE2s extends _BLAKE2 {\n    // Internal state, same as SHA-256\n    v0 = B2S_IV[0] | 0;\n    v1 = B2S_IV[1] | 0;\n    v2 = B2S_IV[2] | 0;\n    v3 = B2S_IV[3] | 0;\n    v4 = B2S_IV[4] | 0;\n    v5 = B2S_IV[5] | 0;\n    v6 = B2S_IV[6] | 0;\n    v7 = B2S_IV[7] | 0;\n    constructor(opts = {}) {\n        opts = checkOpts({}, opts);\n        const olen = opts.dkLen === undefined ? 32 : opts.dkLen;\n        super(64, olen);\n        checkBlake2Opts(olen, opts, 32, 8, 8);\n        let { key, personalization, salt } = opts;\n        let keyLength = 0;\n        if (key !== undefined) {\n            abytes(key, undefined, 'key');\n            keyLength = key.length;\n        }\n        // RFC 7693 §2.5: xor `p[0] = 0x0101kknn` directly into `h[0]`, since\n        // BLAKE2s stores each state word as one `u32`.\n        this.v0 ^= this.outputLen | (keyLength << 8) | (0x01 << 16) | (0x01 << 24);\n        if (salt !== undefined) {\n            abytes(salt, undefined, 'salt');\n            // Copy: u32() would throw on views with byteOffset not divisible by 4.\n            const slt = u32(copyBytes(salt));\n            this.v4 ^= swap8IfBE(slt[0]);\n            this.v5 ^= swap8IfBE(slt[1]);\n        }\n        if (personalization !== undefined) {\n            abytes(personalization, undefined, 'personalization');\n            // Copy: u32() would throw on views with byteOffset not divisible by 4.\n            const pers = u32(copyBytes(personalization));\n            this.v6 ^= swap8IfBE(pers[0]);\n            this.v7 ^= swap8IfBE(pers[1]);\n        }\n        if (key !== undefined) {\n            // Pad to blockLen and update\n            const tmp = new Uint8Array(this.blockLen);\n            tmp.set(key);\n            this.update(tmp);\n            // The padded copy holds key material; buffer/state keep what they need.\n            clean(tmp);\n        }\n    }\n    get() {\n        const { v0, v1, v2, v3, v4, v5, v6, v7 } = this;\n        return [v0, v1, v2, v3, v4, v5, v6, v7];\n    }\n    // prettier-ignore\n    set(v0, v1, v2, v3, v4, v5, v6, v7) {\n        this.v0 = v0 | 0;\n        this.v1 = v1 | 0;\n        this.v2 = v2 | 0;\n        this.v3 = v3 | 0;\n        this.v4 = v4 | 0;\n        this.v5 = v5 | 0;\n        this.v6 = v6 | 0;\n        this.v7 = v7 | 0;\n    }\n    compress(msg, offset, isLast) {\n        const l = u64.fromNumL(this.length);\n        const h = u64.fromNumH(this.length);\n        // Seed v8..v15 from the IV, xor the low/high 32-bit byte counter into\n        // v12/v13, and invert v14 on the final block.\n        // prettier-ignore\n        const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = _compress(BSIGMA, offset, msg, 10, this.v0, this.v1, this.v2, this.v3, this.v4, this.v5, this.v6, this.v7, B2S_IV[0], B2S_IV[1], B2S_IV[2], B2S_IV[3], l ^ B2S_IV[4], h ^ B2S_IV[5], isLast ? ~B2S_IV[6] : B2S_IV[6], B2S_IV[7]);\n        this.v0 ^= v0 ^ v8;\n        this.v1 ^= v1 ^ v9;\n        this.v2 ^= v2 ^ v10;\n        this.v3 ^= v3 ^ v11;\n        this.v4 ^= v4 ^ v12;\n        this.v5 ^= v5 ^ v13;\n        this.v6 ^= v6 ^ v14;\n        this.v7 ^= v7 ^ v15;\n    }\n    destroy() {\n        this.destroyed = true;\n        clean(this.buffer32);\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n    }\n}\n/**\n * Blake2s hash function. Focuses on 8-bit to 32-bit platforms. 1.5x faster than blake2b in JS.\n * @param msg - message that would be hashed\n * @param opts - Optional output, MAC, salt, and personalization settings.\n *   `dkLen` must be 1..32 bytes; `salt` and `personalization`, if present,\n *   must be 8 bytes each. See {@link Blake2Opts}.\n * @returns Digest bytes.\n * @example\n * Hash a message with Blake2s.\n * ```ts\n * blake2s(new Uint8Array([97, 98, 99]));\n * ```\n * @example\n * Hash a message with Blake2s while selecting output, MAC, salt, and personalization settings.\n * ```ts\n * blake2s(new Uint8Array([97, 98, 99]), {\n *   dkLen: 16,\n *   key: new Uint8Array(32),\n *   salt: new Uint8Array(8),\n *   personalization: new Uint8Array(8),\n * });\n * ```\n */\nexport const blake2s = /* @__PURE__ */ createHasher((opts) => new _BLAKE2s(opts));\n","/**\n * Argon2 KDF from RFC 9106. Can be used to create a key from password and salt.\n * We suggest to use Scrypt. JS Argon is 2-10x slower than native code because of 64-bitness:\n * * argon uses uint64, but JS doesn't have fast uint64array\n * * uint64 multiplication is 1/3 of time\n * * `P` function would be very nice with u64, because most of value will be in registers,\n *   hovewer with u32 it will require 32 registers, which is too much.\n * * JS arrays do slow bound checks, so reading from `A2_BUF` slows it down\n * @module\n */\nimport { rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL } from \"./_u64.js\";\nimport { blake2b } from \"./blake2.js\";\nimport { anumber, checkOpts, clean, kdfInputToBytes, nextTick, swap32IfBE, swap8IfBE, u32, u8, } from \"./utils.js\";\n// RFC 9106 §3.1 type `y`: 0 = Argon2d, 1 = Argon2i, 2 = Argon2id. The numeric values are the\n// spec-bound part here; the object keys are internal labels.\nconst AT = { Argon2d: 0, Argon2i: 1, Argon2id: 2 };\n// RFC 9106 sync points constant `SL = 4`, fixed by the design rather than exposed as a tuning knob.\nconst ARGON2_SYNC_POINTS = 4;\n// Preserve Argon2's `LE32(len(X)) || X` encoding for omitted\n// optional fields by emitting empty bytes.\nconst abytesOrZero = (buf, errorTitle = '') => {\n    if (buf === undefined)\n        return Uint8Array.of();\n    return kdfInputToBytes(buf, errorTitle);\n};\n// Unsigned `u32 * u32 = { h, l }`, returned as split 64-bit halves.\nfunction mul(a, b) {\n    // Split into 16-bit limbs so each partial product stays exact under `Math.imul`.\n    const aL = a & 0xffff;\n    const aH = a >>> 16;\n    const bL = b & 0xffff;\n    const bH = b >>> 16;\n    const ll = Math.imul(aL, bL);\n    const hl = Math.imul(aH, bL);\n    const lh = Math.imul(aL, bH);\n    const hh = Math.imul(aH, bH);\n    const carry = (ll >>> 16) + (hl & 0xffff) + lh;\n    const high = (hh + (hl >>> 16) + (carry >>> 16)) | 0;\n    const low = (carry << 16) | (ll & 0xffff);\n    return { h: high, l: low };\n}\n// High 32 bits of unsigned u32 multiply, via the same 16-bit limb split as `mul` below.\n// Kept single-purpose and number-returning so V8 inlines it (object-returning\n// helpers here cost 2.2x of the whole derivation, measured; small helpers\n// returning one number are free — see rotr* usage everywhere).\nfunction mulHi(a, b) {\n    const aL = a & 0xffff, aH = a >>> 16, bL = b & 0xffff, bH = b >>> 16; // prettier-ignore\n    const carry = (Math.imul(aL, bL) >>> 16) + (Math.imul(aH, bL) & 0xffff) + Math.imul(aL, bH);\n    return (Math.imul(aH, bH) + (Math.imul(aH, bL) >>> 16) + (carry >>> 16)) | 0;\n}\n// Temporary block buffer.\n// 1024-byte block: 256 u32 = 128 interleaved low/high halves = RFC's\n// 8x8 matrix of 16-byte registers.\nconst A2_BUF = new Uint32Array(256);\n// Quarter-round over 64-bit word indices into `A2_BUF`; each index maps to adjacent low/high u32s.\n// Each BlaMka step `X = X + Y + 2 * trunc(X) * trunc(Y)` (trunc = low 32 bits) is three lines:\n// `Math.imul` is the low product half, `mulHi` the high half, then a split 64-bit add with the\n// doubling folded in. RFC 9106 Figure 19 GB rotates by 32, 24, 16, and 63 bits after each XOR.\nfunction G(a, b, c, d) {\n    let Al = A2_BUF[2 * a], Ah = A2_BUF[2 * a + 1]; // prettier-ignore\n    let Bl = A2_BUF[2 * b], Bh = A2_BUF[2 * b + 1]; // prettier-ignore\n    let Cl = A2_BUF[2 * c], Ch = A2_BUF[2 * c + 1]; // prettier-ignore\n    let Dl = A2_BUF[2 * d], Dh = A2_BUF[2 * d + 1]; // prettier-ignore\n    let ml = 0, mh = 0, rl = 0, xh = 0, xl = 0; // prettier-ignore\n    // A = blamka(A, B); D = rotr64(D ^ A, 32)\n    ml = Math.imul(Al, Bl);\n    mh = mulHi(Al, Bl); // prettier-ignore\n    rl = (Al >>> 0) + (Bl >>> 0) + ((ml << 1) >>> 0);\n    Ah = (Ah + Bh + ((mh << 1) | (ml >>> 31)) + ((rl / 0x100000000) | 0)) | 0;\n    Al = rl | 0; // prettier-ignore\n    xh = Dh ^ Ah;\n    xl = Dl ^ Al; // prettier-ignore\n    Dh = rotr32H(xh, xl);\n    Dl = rotr32L(xh, xl); // prettier-ignore\n    // C = blamka(C, D); B = rotr64(B ^ C, 24)\n    ml = Math.imul(Cl, Dl);\n    mh = mulHi(Cl, Dl); // prettier-ignore\n    rl = (Cl >>> 0) + (Dl >>> 0) + ((ml << 1) >>> 0);\n    Ch = (Ch + Dh + ((mh << 1) | (ml >>> 31)) + ((rl / 0x100000000) | 0)) | 0;\n    Cl = rl | 0; // prettier-ignore\n    xh = Bh ^ Ch;\n    xl = Bl ^ Cl; // prettier-ignore\n    Bh = rotrSH(xh, xl, 24);\n    Bl = rotrSL(xh, xl, 24); // prettier-ignore\n    // A = blamka(A, B); D = rotr64(D ^ A, 16)\n    ml = Math.imul(Al, Bl);\n    mh = mulHi(Al, Bl); // prettier-ignore\n    rl = (Al >>> 0) + (Bl >>> 0) + ((ml << 1) >>> 0);\n    Ah = (Ah + Bh + ((mh << 1) | (ml >>> 31)) + ((rl / 0x100000000) | 0)) | 0;\n    Al = rl | 0; // prettier-ignore\n    xh = Dh ^ Ah;\n    xl = Dl ^ Al; // prettier-ignore\n    Dh = rotrSH(xh, xl, 16);\n    Dl = rotrSL(xh, xl, 16); // prettier-ignore\n    // C = blamka(C, D); B = rotr64(B ^ C, 63)\n    ml = Math.imul(Cl, Dl);\n    mh = mulHi(Cl, Dl); // prettier-ignore\n    rl = (Cl >>> 0) + (Dl >>> 0) + ((ml << 1) >>> 0);\n    Ch = (Ch + Dh + ((mh << 1) | (ml >>> 31)) + ((rl / 0x100000000) | 0)) | 0;\n    Cl = rl | 0; // prettier-ignore\n    xh = Bh ^ Ch;\n    xl = Bl ^ Cl; // prettier-ignore\n    Bh = rotrBH(xh, xl, 63);\n    Bl = rotrBL(xh, xl, 63); // prettier-ignore\n    ((A2_BUF[2 * a] = Al), (A2_BUF[2 * a + 1] = Ah));\n    ((A2_BUF[2 * b] = Bl), (A2_BUF[2 * b + 1] = Bh));\n    ((A2_BUF[2 * c] = Cl), (A2_BUF[2 * c + 1] = Ch));\n    ((A2_BUF[2 * d] = Dl), (A2_BUF[2 * d + 1] = Dh));\n}\n// Argon2 permutation over 16 register indices into `A2_BUF`, not the register values themselves.\n// RFC 9106 Figure 17: these arguments are the 16 `v0..v15` 64-bit word\n// indices inside eight 16-byte inputs, not copied word values.\n// prettier-ignore\nfunction P(v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11, v12, v13, v14, v15) {\n    // RFC 9106 Figure 18: first apply GB across rows, then across columns of the 8x8 register matrix.\n    G(v00, v04, v08, v12);\n    G(v01, v05, v09, v13);\n    G(v02, v06, v10, v14);\n    G(v03, v07, v11, v15);\n    G(v00, v05, v10, v15);\n    G(v01, v06, v11, v12);\n    G(v02, v07, v08, v13);\n    G(v03, v04, v09, v14);\n}\nfunction block(x, xPos, yPos, outPos, needXor) {\n    for (let i = 0; i < 256; i++)\n        A2_BUF[i] = x[xPos + i] ^ x[yPos + i];\n    // rows (8 consecutive 16-register groups)\n    for (let i = 0; i < 128; i += 16) {\n        // prettier-ignore\n        P(i, i + 1, i + 2, i + 3, i + 4, i + 5, i + 6, i + 7, i + 8, i + 9, i + 10, i + 11, i + 12, i + 13, i + 14, i + 15);\n    }\n    // columns (8 strided 16-register groups)\n    for (let i = 0; i < 16; i += 2) {\n        // prettier-ignore\n        P(i, i + 1, i + 16, i + 17, i + 32, i + 33, i + 48, i + 49, i + 64, i + 65, i + 80, i + 81, i + 96, i + 97, i + 112, i + 113);\n    }\n    // RFC 9106 step 6: passes after the first XOR the old destination block into the new G(X, Y).\n    if (needXor)\n        for (let i = 0; i < 256; i++)\n            x[outPos + i] ^= A2_BUF[i] ^ x[xPos + i] ^ x[yPos + i];\n    else\n        for (let i = 0; i < 256; i++)\n            x[outPos + i] = A2_BUF[i] ^ x[xPos + i] ^ x[yPos + i];\n    clean(A2_BUF);\n}\n// Variable-Length Hash Function H'\n// Returns bytes, not words; 1024-byte block callers explicitly reinterpret with `u32(...)`.\nfunction Hp(A, dkLen) {\n    const A8 = u8(A);\n    const T = new Uint32Array(1);\n    const T8 = u8(T);\n    // Argon2 H' prefixes dkLen as LE32; native Uint32Array writes would serialize as BE on s390x.\n    T[0] = swap8IfBE(dkLen);\n    // Fast path\n    if (dkLen <= 64)\n        return blake2b.create({ dkLen }).update(T8).update(A8).digest();\n    const out = new Uint8Array(dkLen);\n    let V = blake2b.create({}).update(T8).update(A8).digest();\n    let pos = 0;\n    // RFC 9106 Figure 8: each intermediate `V_i` contributes only `W_i`, its first 32 bytes; only\n    // `V_{r+1}` is emitted in full at the remaining length.\n    out.set(V.subarray(0, 32));\n    pos += 32;\n    // Rest blocks\n    for (; dkLen - pos > 64; pos += 32) {\n        const Vh = blake2b.create({}).update(V);\n        Vh.digestInto(V);\n        Vh.destroy();\n        out.set(V.subarray(0, 32), pos);\n    }\n    // Last block\n    out.set(blake2b(V, { dkLen: dkLen - pos }), pos);\n    clean(V, T);\n    // H' is byte-oriented; returning `u32(out)` would silently drop dkLen % 4 tail bytes.\n    return out;\n}\n// Used only inside argon2Blocks!\nfunction indexAlpha(r, s, laneLen, segmentLen, index, randL, sameLane = false) {\n    // RFC 9106 §3.4.2 Figures 12-13: map `J1` / `J2` into the current lane's reference area `W`.\n    let area;\n    if (r === 0) {\n        if (s === 0)\n            area = index - 1;\n        else if (sameLane)\n            area = s * segmentLen + index - 1;\n        else\n            area = s * segmentLen + (index == 0 ? -1 : 0);\n    }\n    else if (sameLane)\n        area = laneLen - segmentLen + index - 1;\n    else\n        area = laneLen - segmentLen + (index == 0 ? -1 : 0);\n    const startPos = r !== 0 && s !== ARGON2_SYNC_POINTS - 1 ? (s + 1) * segmentLen : 0;\n    // RFC 9106 Figure 13: `mul(randL, randL).h` is `floor(J_1^2 / 2^32)`, and the outer high-half\n    // multiply computes `floor(|W| * x / 2^32)` without floating-point math.\n    const rel = area - 1 - mul(area, mul(randL, randL).h).h;\n    return (startPos + rel) % laneLen;\n}\n// Exclusive `2^32` sentinel used by `isU32(...)`, not the inclusive maximum u32 value.\nconst maxUint32 = Math.pow(2, 32);\n// Validate safe JS integers in `[0, 2^32 - 1]`.\nfunction isU32(num) {\n    return Number.isSafeInteger(num) && num >= 0 && num < maxUint32;\n}\nfunction argon2Opts(opts) {\n    opts = checkOpts({}, opts);\n    const merged = {\n        version: 0x13,\n        dkLen: 32,\n        maxmem: maxUint32 - 1,\n        asyncTick: 10,\n    };\n    // Unknown keys are copied through unchanged here and later ignored unless\n    // destructuring consumes them.\n    for (let [k, v] of Object.entries(opts))\n        if (v !== undefined)\n            merged[k] = v;\n    const { dkLen, p, m, t, version, onProgress, asyncTick } = merged;\n    // RFC 9106 §3.1: tag length `T` MUST be an integer number of bytes from 4 to 2^32-1.\n    if (!isU32(dkLen) || dkLen < 4)\n        throw new Error('\"dkLen\" must be 4..');\n    if (!isU32(p) || p < 1 || p >= Math.pow(2, 24))\n        throw new Error('\"p\" must be 1..2^24');\n    if (!isU32(m))\n        throw new Error('\"m\" must be 0..2^32');\n    if (!isU32(t) || t < 1)\n        throw new Error('\"t\" (iterations) must be 1..2^32');\n    if (onProgress !== undefined && typeof onProgress !== 'function')\n        throw new Error('\"onProgress\" must be a function');\n    anumber(asyncTick, 'asyncTick');\n    /*\n    Memory size m MUST be an integer number of kibibytes from 8*p\n    to 2^(32)-1. The actual number of blocks is m', which is m\n    rounded down to the nearest multiple of 4*p.\n    */\n    if (!isU32(m) || m < 8 * p)\n        throw new Error('\"m\" (memory) must be at least 8*p bytes');\n    // Accept legacy `0x10` for compatibility even though RFC 9106 profiles standardize `0x13`.\n    if (version !== 0x10 && version !== 0x13)\n        throw new Error('\"version\" must be 0x10 or 0x13, got ' + version);\n    return merged;\n}\nfunction argon2Init(password, salt, type, opts) {\n    password = kdfInputToBytes(password, 'password');\n    salt = kdfInputToBytes(salt, 'salt');\n    if (!isU32(password.length))\n        throw new Error('\"password\" must be less of length 1..4Gb');\n    // RFC 9106 §3.1 only requires S <= 2^32-1 bytes and says 16 bytes is RECOMMENDED for password\n    // hashing; this library intentionally takes the stricter common >=8-byte salt path.\n    if (!isU32(salt.length) || salt.length < 8)\n        throw new Error('\"salt\" must be of length 8..4Gb');\n    if (!Object.values(AT).includes(type))\n        throw new Error('\"type\" was invalid');\n    let { p, dkLen, m, t, version, key, personalization, maxmem, onProgress, asyncTick } = argon2Opts(opts);\n    // Validation\n    key = abytesOrZero(key, 'key');\n    personalization = abytesOrZero(personalization, 'personalization');\n    // H_0 = H^(64)(LE32(p) || LE32(T) || LE32(m) || LE32(t) ||\n    //       LE32(v) || LE32(y) || LE32(length(P)) || P ||\n    //       LE32(length(S)) || S ||  LE32(length(K)) || K ||\n    //       LE32(length(X)) || X)\n    const h = blake2b.create();\n    const BUF = new Uint32Array(1);\n    const BUF8 = u8(BUF);\n    for (let item of [p, dkLen, m, t, version, type]) {\n        // RFC 9106 H0 encodes these scalars as LE32, so normalize the host word before exposing bytes.\n        BUF[0] = swap8IfBE(item);\n        h.update(BUF8);\n    }\n    for (let i of [password, salt, key, personalization]) {\n        BUF[0] = swap8IfBE(i.length); // BUF is u32 array, this is valid once normalized to LE bytes\n        h.update(BUF8).update(i);\n    }\n    // Reserve two extra LE32 words after the 64-byte `H_0` so Figures 3-4 can append\n    // `LE32(0 or 1) || LE32(i)` in place for the lane-starting blocks.\n    const H0 = new Uint32Array(18);\n    const H0_8 = u8(H0);\n    h.digestInto(H0_8);\n    // 256 u32 = 1024 (BLOCK_SIZE), fills A2_BUF on processing\n    // Params\n    const lanes = p;\n    // m' = 4 * p * floor (m / 4p)\n    const mP = 4 * p * Math.floor(m / (ARGON2_SYNC_POINTS * p));\n    //q = m' / p columns\n    const laneLen = Math.floor(mP / p);\n    const segmentLen = Math.floor(laneLen / ARGON2_SYNC_POINTS);\n    // `maxmem` is documented in bytes; compare against the actual 1024-byte block allocation.\n    const memUsed = mP * 1024;\n    if (!isU32(maxmem))\n        throw new Error('\"maxmem\" expected <2**32, got ' + maxmem);\n    if (memUsed > maxmem)\n        throw new Error('\"maxmem\" limit was hit: memUsed(mP*1024)=' + memUsed + ', maxmem=' + maxmem);\n    const B = new Uint32Array(memUsed / 4);\n    // Fill first blocks\n    for (let l = 0; l < p; l++) {\n        const i = 256 * laneLen * l;\n        // B[i][0] = H'^(1024)(H_0 || LE32(0) || LE32(i))\n        H0[17] = swap8IfBE(l);\n        H0[16] = swap8IfBE(0);\n        B.set(swap32IfBE(u32(Hp(H0, 1024))), i);\n        // B[i][1] = H'^(1024)(H_0 || LE32(1) || LE32(i))\n        H0[16] = swap8IfBE(1);\n        B.set(swap32IfBE(u32(Hp(H0, 1024))), i + 256);\n    }\n    let perBlock = () => { };\n    if (onProgress) {\n        // The first segment of the first pass skips two preinitialized blocks per lane.\n        const totalBlock = t * ARGON2_SYNC_POINTS * p * segmentLen - 2 * p;\n        // Invoke callback if progress changes from 10.01 to 10.02\n        // Allows to draw smooth progress bar on up to 8K screen\n        const callbackPer = Math.max(Math.floor(totalBlock / 10000), 1);\n        let blockCnt = 0;\n        perBlock = () => {\n            blockCnt++;\n            if (onProgress && (!(blockCnt % callbackPer) || blockCnt === totalBlock))\n                onProgress(blockCnt / totalBlock);\n        };\n    }\n    clean(BUF, H0);\n    return { type, mP, p, t, version, B, laneLen, lanes, segmentLen, dkLen, perBlock, asyncTick };\n}\nfunction argon2Output(B, p, laneLen, dkLen) {\n    const B_final = new Uint32Array(256);\n    for (let l = 0; l < p; l++)\n        for (let j = 0; j < 256; j++)\n            B_final[j] ^= B[256 * (laneLen * l + laneLen - 1) + j];\n    // RFC 9106 steps 7-8 feed the byte string `C` into `H'^T(C)`, so normalize the xor'ed words\n    // back to spec byte order before `Hp(...)` reinterprets them as bytes.\n    const res = Hp(swap32IfBE(B_final), dkLen);\n    // Wipe both the xor scratch and the full working matrix once final digest bytes exist.\n    // JS cleanup is still only best-effort, but this local buffer is no longer needed here.\n    clean(B, B_final);\n    return res;\n}\n/**\n * Fills every Argon2 block for all passes / slices / lanes, yielding once per\n * processed block so callers control pacing: the sync driver just drains the\n * generator, while the async driver awaits `nextTick()` between time slices.\n */\nfunction* argon2Blocks(ctx) {\n    const { type, mP, p, t, version, B, laneLen, lanes, segmentLen, perBlock } = ctx;\n    // [address, input, zero_block] format so we can pass single U32 to block function\n    const address = new Uint32Array(3 * 256);\n    address[256 + 6] = mP;\n    address[256 + 8] = t;\n    address[256 + 10] = type;\n    for (let r = 0; r < t; r++) {\n        // RFC 9106 step 6 applies the XOR-on-later-passes rule only for version `0x13`; legacy\n        // `0x10` keeps the older overwrite behavior used by the v16 test vectors.\n        const needXor = r !== 0 && version === 0x13;\n        address[256 + 0] = r;\n        for (let s = 0; s < ARGON2_SYNC_POINTS; s++) {\n            address[256 + 4] = s;\n            // RFC 9106 §3.4.1.3: Argon2id uses Argon2i's data-independent `J1` / `J2` generation only\n            // in pass 0, slices 0 and 1; Argon2i uses it in every segment.\n            const dataIndependent = type == AT.Argon2i || (type == AT.Argon2id && r === 0 && s < 2);\n            for (let l = 0; l < p; l++) {\n                address[256 + 2] = l;\n                address[256 + 12] = 0;\n                let startPos = 0;\n                if (r === 0 && s === 0) {\n                    startPos = 2;\n                    if (dataIndependent) {\n                        address[256 + 12]++;\n                        block(address, 256, 2 * 256, 0, false);\n                        block(address, 0, 2 * 256, 0, false);\n                    }\n                }\n                // current block position\n                let offset = l * laneLen + s * segmentLen + startPos;\n                for (let index = startPos; index < segmentLen; index++, offset++) {\n                    perBlock();\n                    // Previous block position: wraps to the lane's last block only at lane start,\n                    // which can happen here only for the first block of slice 0 on passes > 0.\n                    const prev = offset % laneLen ? offset - 1 : offset + laneLen - 1;\n                    let randL, randH;\n                    if (dataIndependent) {\n                        let i128 = index % 128;\n                        // RFC 9106 §3.4.1.2: each 1024-byte address block yields 128 `(J1, J2)` pairs, so\n                        // regenerate it whenever the segment index crosses a multiple of 128.\n                        if (i128 === 0) {\n                            address[256 + 12]++;\n                            block(address, 256, 2 * 256, 0, false);\n                            block(address, 0, 2 * 256, 0, false);\n                        }\n                        randL = address[2 * i128];\n                        randH = address[2 * i128 + 1];\n                    }\n                    else {\n                        const T = 256 * prev;\n                        randL = B[T];\n                        randH = B[T + 1];\n                    }\n                    // Address-block path selects `J1` / `J2`, then maps them to the reference\n                    // lane/block per RFC 9106 §3.4.\n                    const refLane = r === 0 && s === 0 ? l : randH % lanes;\n                    const refPos = indexAlpha(r, s, laneLen, segmentLen, index, randL, refLane == l);\n                    const refBlock = laneLen * refLane + refPos;\n                    // B[i][j] = G(B[i][j-1], B[l][z])\n                    block(B, 256 * prev, 256 * refBlock, offset * 256, needXor);\n                    yield;\n                }\n            }\n        }\n    }\n    clean(address);\n}\nfunction argon2(type, password, salt, opts) {\n    const ctx = argon2Init(password, salt, type, opts);\n    const blocks = argon2Blocks(ctx);\n    while (!blocks.next().done) { }\n    return argon2Output(ctx.B, ctx.p, ctx.laneLen, ctx.dkLen);\n}\n/**\n * Argon2d GPU-resistant version.\n * @param password - password or input key material\n * @param salt - unique salt value\n * @param opts - Argon2 cost and optional tuning parameters. See {@link ArgonOpts}.\n * @returns Derived key bytes.\n * @throws If the Argon2 input or cost parameters are invalid. {@link Error}\n * @example\n * Derive a key with Argon2d.\n * ```ts\n * argon2d('password', 'salt1234', { t: 1, m: 8, p: 1, dkLen: 32 });\n * ```\n * @example\n * Derive a key with optional secret and scheduler controls.\n * ```ts\n * const progressLog: number[] = [];\n * argon2d('password', 'salt1234', {\n *   t: 1,\n *   m: 8,\n *   p: 1,\n *   dkLen: 32,\n *   version: 0x13,\n *   key: 'secret',\n *   personalization: 'application',\n *   maxmem: 1024 * 1024,\n *   asyncTick: 1,\n *   onProgress(progress) {\n *     progressLog.push(progress);\n *   },\n * });\n * ```\n */\nexport const argon2d = (password, salt, opts) => argon2(AT.Argon2d, password, salt, opts);\n/**\n * Argon2i side-channel-resistant version.\n * @param password - password or input key material\n * @param salt - unique salt value\n * @param opts - Argon2 cost and optional tuning parameters. See {@link ArgonOpts}.\n * @returns Derived key bytes.\n * @throws If the Argon2 input or cost parameters are invalid. {@link Error}\n * @example\n * Derive a key with Argon2i.\n * ```ts\n * argon2i('password', 'salt1234', { t: 1, m: 8, p: 1, dkLen: 32 });\n * ```\n */\nexport const argon2i = (password, salt, opts) => argon2(AT.Argon2i, password, salt, opts);\n/**\n * Argon2id, combining i+d, the most popular version from RFC 9106.\n * @param password - password or input key material\n * @param salt - unique salt value\n * @param opts - Argon2 cost and optional tuning parameters. See {@link ArgonOpts}.\n * @returns Derived key bytes.\n * @throws If the Argon2 input or cost parameters are invalid. {@link Error}\n * @example\n * Derive a key with Argon2id.\n * ```ts\n * argon2id('password', 'salt1234', { t: 1, m: 8, p: 1, dkLen: 32 });\n * ```\n */\nexport const argon2id = (password, salt, opts) => argon2(AT.Argon2id, password, salt, opts);\nasync function argon2Async(type, password, salt, opts) {\n    const ctx = argon2Init(password, salt, type, opts);\n    const blocks = argon2Blocks(ctx);\n    let ts = Date.now();\n    while (!blocks.next().done) {\n        // Date.now() is not monotonic. If the clock goes backwards,\n        // still yield control.\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < ctx.asyncTick)\n            continue;\n        await nextTick();\n        ts += diff;\n    }\n    return argon2Output(ctx.B, ctx.p, ctx.laneLen, ctx.dkLen);\n}\n/**\n * Argon2d async GPU-resistant version.\n * @param password - password or input key material\n * @param salt - unique salt value\n * @param opts - Argon2 cost and optional tuning parameters. See {@link ArgonOpts}.\n * @returns Promise resolving to derived key bytes.\n * @throws If the Argon2 input or cost parameters are invalid. {@link Error}\n * @example\n * Derive a key with Argon2d asynchronously.\n * ```ts\n * await argon2dAsync('password', 'salt1234', { t: 1, m: 8, p: 1, dkLen: 32 });\n * ```\n * @example\n * Derive a key asynchronously with optional secret and scheduler controls.\n * ```ts\n * await argon2dAsync('password', 'salt1234', {\n *   t: 1,\n *   m: 8,\n *   p: 1,\n *   dkLen: 32,\n *   version: 0x13,\n *   key: 'secret',\n *   personalization: 'application',\n *   maxmem: 1024 * 1024,\n *   asyncTick: 1,\n *   onProgress(progress) {\n *     if (progress > 1) throw new Error('invalid progress');\n *   },\n * });\n * ```\n */\nexport const argon2dAsync = (password, salt, opts) => argon2Async(AT.Argon2d, password, salt, opts);\n/**\n * Argon2i async side-channel-resistant version.\n * @param password - password or input key material\n * @param salt - unique salt value\n * @param opts - Argon2 cost and optional tuning parameters. See {@link ArgonOpts}.\n * @returns Promise resolving to derived key bytes.\n * @throws If the Argon2 input or cost parameters are invalid. {@link Error}\n * @example\n * Derive a key with Argon2i asynchronously.\n * ```ts\n * await argon2iAsync('password', 'salt1234', { t: 1, m: 8, p: 1, dkLen: 32 });\n * ```\n */\nexport const argon2iAsync = (password, salt, opts) => argon2Async(AT.Argon2i, password, salt, opts);\n/**\n * Argon2id async, combining i+d, the most popular version from RFC 9106.\n * @param password - password or input key material\n * @param salt - unique salt value\n * @param opts - Argon2 cost and optional tuning parameters. See {@link ArgonOpts}.\n * @returns Promise resolving to derived key bytes.\n * @throws If the Argon2 input or cost parameters are invalid. {@link Error}\n * @example\n * Derive a key with Argon2id asynchronously.\n * ```ts\n * await argon2idAsync('password', 'salt1234', { t: 1, m: 8, p: 1, dkLen: 32 });\n * ```\n */\nexport const argon2idAsync = (password, salt, opts) => argon2Async(AT.Argon2id, password, salt, opts);\n","import {\n  argon2d as nobleArgon2d,\n  argon2i as nobleArgon2i,\n  argon2id as nobleArgon2id,\n} from '@noble/hashes/argon2.js';\nimport type { KdfComponent, PresetComponent } from '@jscrypto/core';\n\ndeclare const TextEncoder: {\n  new(): { encode(input: string): Uint8Array };\n};\n\nexport type Argon2Mode = 'id' | 'i' | 'd';\n\nexport interface Argon2Params {\n  input: Uint8Array | string;\n  salt: Uint8Array | string;\n  length: number;\n  mode?: Argon2Mode;\n  t: number;\n  m: number;\n  p: number;\n  maxmem?: number;\n}\n\ntype Argon2Impl = (input: Uint8Array, salt: Uint8Array, options: {\n  t: number;\n  m: number;\n  p: number;\n  dkLen: number;\n  maxmem?: number;\n}) => Uint8Array;\n\nconst ARGON2_IMPL: Record<Argon2Mode, Argon2Impl> = {\n  id: nobleArgon2id,\n  i: nobleArgon2i,\n  d: nobleArgon2d,\n};\n\nexport const argon2: KdfComponent<'Argon2'> = {\n  kind: 'kdf',\n  name: 'Argon2',\n  derive(params) {\n    return deriveArgon2(params as Argon2Params);\n  },\n};\n\nexport const argon2Preset: PresetComponent<'argon2'> = {\n  kind: 'preset',\n  name: 'argon2',\n  components() {\n    return [argon2];\n  },\n};\n\nexport function deriveArgon2(params: Argon2Params): Uint8Array {\n  if (params === undefined || params === null || typeof params !== 'object') {\n    throw new TypeError('Argon2 requires params.');\n  }\n  if (params.input === undefined || params.input === null) {\n    throw new TypeError('Argon2 requires input.');\n  }\n  if (params.salt === undefined || params.salt === null) {\n    throw new TypeError('Argon2 requires salt.');\n  }\n\n  const mode = params.mode ?? 'id';\n  const impl = ARGON2_IMPL[mode];\n  if (!impl) {\n    throw new RangeError(\"Argon2 mode must be 'id', 'i', or 'd'.\");\n  }\n\n  assertPositiveInteger(params.length, 'Argon2 length');\n  assertPositiveInteger(params.t, 'Argon2 t');\n  assertPositiveInteger(params.m, 'Argon2 m');\n  assertPositiveInteger(params.p, 'Argon2 p');\n\n  const options: {\n    t: number;\n    m: number;\n    p: number;\n    dkLen: number;\n    maxmem?: number;\n  } = {\n    t: params.t,\n    m: params.m,\n    p: params.p,\n    dkLen: params.length,\n  };\n  if (params.maxmem !== undefined) {\n    assertPositiveInteger(params.maxmem, 'Argon2 maxmem');\n    options.maxmem = params.maxmem;\n  }\n\n  return impl(toBytes(params.input), toBytes(params.salt), options);\n}\n\nfunction toBytes(input: Uint8Array | string): Uint8Array {\n  return typeof input === 'string' ? new TextEncoder().encode(input) : input;\n}\n\nfunction assertPositiveInteger(value: number, label: string): void {\n  if (!Number.isInteger(value) || value <= 0) {\n    throw new RangeError(`${label} must be a positive integer.`);\n  }\n}\n","import { concatBytes } from '@jscrypto/core';\nimport type { HashComponent, KdfComponent, PresetComponent } from '@jscrypto/core';\n\ndeclare const TextEncoder: {\n  new(): { encode(input: string): Uint8Array };\n};\n\nexport interface EvpKdfParams {\n  input: Uint8Array | string;\n  salt: Uint8Array | string;\n  iterations?: number;\n  length: number;\n  hash?: string;\n}\n\nexport interface DeriveEvpKdfParams extends Omit<EvpKdfParams, 'hash'> {\n  hash: HashComponent;\n}\n\nexport const evpKdf: KdfComponent<'EvpKDF'> = {\n  kind: 'kdf',\n  name: 'EvpKDF',\n  derive(params, context) {\n    const options = params as EvpKdfParams;\n    return deriveEvpKdf({\n      ...options,\n      hash: context.getHash(options.hash ?? 'MD5'),\n    });\n  },\n};\n\nexport const evpKdfPreset: PresetComponent<'evpkdf'> = {\n  kind: 'preset',\n  name: 'evpkdf',\n  components() {\n    return [evpKdf];\n  },\n};\n\nexport function deriveEvpKdf(params: DeriveEvpKdfParams): Uint8Array {\n  assertPositiveInteger(params.length, 'EvpKDF length');\n  if (params.iterations !== undefined) {\n    assertPositiveInteger(params.iterations, 'EvpKDF iterations');\n  }\n  if (params.input === undefined || params.input === null) {\n    throw new TypeError('EvpKDF requires input.');\n  }\n  if (params.salt === undefined || params.salt === null) {\n    throw new TypeError('EvpKDF requires salt.');\n  }\n\n  const password = toBytes(params.input);\n  const salt = toBytes(params.salt);\n  const blocks: Uint8Array[] = [];\n  let previous = new Uint8Array(0);\n  let length = 0;\n\n  while (length < params.length) {\n    let block = params.hash.hash(concatBytes(previous, password, salt));\n    for (let i = 1; i < (params.iterations ?? 1); i++) {\n      block = params.hash.hash(block);\n    }\n    blocks.push(block);\n    previous = new Uint8Array(block);\n    length += block.length;\n  }\n\n  return concatBytes(...blocks).slice(0, params.length);\n}\n\nfunction toBytes(input: Uint8Array | string): Uint8Array {\n  return typeof input === 'string' ? new TextEncoder().encode(input) : input;\n}\n\nfunction assertPositiveInteger(value: number, label: string): void {\n  if (!Number.isInteger(value) || value <= 0) {\n    throw new RangeError(`${label} must be a positive integer.`);\n  }\n}\n","import { concatBytes } from '@jscrypto/core';\nimport type { HashComponent, KdfComponent, PresetComponent } from '@jscrypto/core';\n\ndeclare const TextEncoder: {\n  new(): { encode(input: string): Uint8Array };\n};\n\nexport interface HkdfParams {\n  input: Uint8Array | string;\n  salt?: Uint8Array | string;\n  info?: Uint8Array | string;\n  hash: string;\n  length: number;\n}\n\nexport interface HkdfExtractParams {\n  input: Uint8Array | string;\n  salt?: Uint8Array | string;\n  hash: HashComponent;\n}\n\nexport interface HkdfExpandParams {\n  input: Uint8Array | string;\n  info?: Uint8Array | string;\n  hash: HashComponent;\n  length: number;\n}\n\nexport interface DeriveHkdfParams {\n  input: Uint8Array | string;\n  salt?: Uint8Array | string;\n  info?: Uint8Array | string;\n  hash: HashComponent;\n  length: number;\n}\n\nexport const hkdf: KdfComponent<'HKDF'> = {\n  kind: 'kdf',\n  name: 'HKDF',\n  derive(params, context) {\n    const options = params as HkdfParams;\n    return deriveHkdf({\n      ...options,\n      hash: resolveHash(options.hash, context, 'HKDF'),\n    });\n  },\n};\n\nexport const hkdfExtract: KdfComponent<'HKDF-Extract'> = {\n  kind: 'kdf',\n  name: 'HKDF-Extract',\n  derive(params, context) {\n    const options = params as {\n      input: Uint8Array | string;\n      salt?: Uint8Array | string;\n      hash: string;\n    };\n    return extractHkdf({\n      input: options.input,\n      salt: options.salt,\n      hash: resolveHash(options.hash, context, 'HKDF-Extract'),\n    });\n  },\n};\n\nexport const hkdfExpand: KdfComponent<'HKDF-Expand'> = {\n  kind: 'kdf',\n  name: 'HKDF-Expand',\n  derive(params, context) {\n    const options = params as {\n      input: Uint8Array | string;\n      info?: Uint8Array | string;\n      hash: string;\n      length: number;\n    };\n    return expandHkdf({\n      input: options.input,\n      info: options.info,\n      length: options.length,\n      hash: resolveHash(options.hash, context, 'HKDF-Expand'),\n    });\n  },\n};\n\nexport const hkdfPreset: PresetComponent<'hkdf'> = {\n  kind: 'preset',\n  name: 'hkdf',\n  components() {\n    return [hkdf, hkdfExtract, hkdfExpand];\n  },\n};\n\nexport function extractHkdf(params: HkdfExtractParams): Uint8Array {\n  requireInput(params.input, 'HKDF');\n  requireHash(params.hash, 'HKDF');\n  if (params.salt !== undefined) {\n    assertBytesOrString(params.salt, 'salt');\n  }\n\n  const hashLen = params.hash.digestSize;\n  return extract(params.hash, toBytes(params.input), normalizeSalt(params.salt, hashLen));\n}\n\nexport function expandHkdf(params: HkdfExpandParams): Uint8Array {\n  return expandFromParams(params, 'HKDF-Expand');\n}\n\nexport function deriveHkdf(params: DeriveHkdfParams): Uint8Array {\n  const prk = extractHkdf(params);\n  return expandFromParams({\n    input: prk,\n    info: params.info,\n    hash: params.hash,\n    length: params.length,\n  }, 'HKDF');\n}\n\nfunction resolveHash(\n  hash: string | undefined,\n  context: { getHash(name: string): HashComponent },\n  label: string,\n): HashComponent {\n  if (typeof hash !== 'string' || hash.length === 0) {\n    throw new TypeError(`${label} requires hash.`);\n  }\n  return context.getHash(hash);\n}\n\nfunction expandFromParams(params: HkdfExpandParams, label: string): Uint8Array {\n  requireInput(params.input, label);\n  requireHash(params.hash, label);\n  assertNonNegativeInteger(params.length, `${label} length`);\n\n  const hashLen = params.hash.digestSize;\n  const prk = toBytes(params.input);\n  if (prk.length < hashLen) {\n    throw new RangeError(`${label} input must be at least ${hashLen} bytes.`);\n  }\n\n  const maxLength = 255 * hashLen;\n  if (params.length > maxLength) {\n    throw new RangeError(`${label} length must be <= ${maxLength}.`);\n  }\n\n  if (params.info !== undefined) {\n    assertBytesOrString(params.info, 'info');\n  }\n\n  if (params.length === 0) {\n    return new Uint8Array(0);\n  }\n\n  const info = params.info === undefined ? new Uint8Array(0) : toBytes(params.info);\n  return expand(params.hash, prk, info, params.length);\n}\n\nfunction extract(hash: HashComponent, input: Uint8Array, salt: Uint8Array): Uint8Array {\n  return hmac(hash, salt, input);\n}\n\nfunction expand(\n  hash: HashComponent,\n  prk: Uint8Array,\n  info: Uint8Array,\n  length: number,\n): Uint8Array {\n  const hashLen = hash.digestSize;\n  const blockCount = Math.ceil(length / hashLen);\n  const blocks: Uint8Array[] = [];\n  let previous: Uint8Array = new Uint8Array(0);\n\n  for (let index = 1; index <= blockCount; index++) {\n    previous = hmac(hash, prk, concatBytes(previous, info, new Uint8Array([index])));\n    blocks.push(previous);\n  }\n\n  return concatBytes(...blocks).slice(0, length);\n}\n\nfunction hmac(hash: HashComponent, key: Uint8Array, input: Uint8Array): Uint8Array {\n  const normalizedKey = key.length > hash.blockSize ? hash.hash(key) : key;\n  const innerKey = new Uint8Array(hash.blockSize);\n  const outerKey = new Uint8Array(hash.blockSize);\n  innerKey.set(normalizedKey);\n  outerKey.set(normalizedKey);\n\n  for (let i = 0; i < hash.blockSize; i++) {\n    innerKey[i] = (innerKey[i] as number) ^ 0x36;\n    outerKey[i] = (outerKey[i] as number) ^ 0x5c;\n  }\n\n  return hash.hash(concatBytes(outerKey, hash.hash(concatBytes(innerKey, input))));\n}\n\nfunction normalizeSalt(salt: Uint8Array | string | undefined, hashLen: number): Uint8Array {\n  if (salt === undefined) {\n    return new Uint8Array(hashLen);\n  }\n  const bytes = toBytes(salt);\n  return bytes.length === 0 ? new Uint8Array(hashLen) : bytes;\n}\n\nfunction toBytes(input: Uint8Array | string): Uint8Array {\n  return typeof input === 'string' ? new TextEncoder().encode(input) : input;\n}\n\nfunction requireInput(value: unknown, label: string): asserts value is Uint8Array | string {\n  if (value === undefined || value === null) {\n    throw new TypeError(`${label} requires input.`);\n  }\n  assertBytesOrString(value, 'input');\n}\n\nfunction requireHash(value: unknown, label: string): asserts value is HashComponent {\n  if (value === undefined || value === null) {\n    throw new TypeError(`${label} requires hash.`);\n  }\n}\n\nfunction assertBytesOrString(value: unknown, name: string): asserts value is Uint8Array | string {\n  if (typeof value === 'string') {\n    return;\n  }\n  if (value instanceof Uint8Array) {\n    return;\n  }\n  throw new TypeError(`HKDF ${name} must be a Uint8Array or string.`);\n}\n\nfunction assertNonNegativeInteger(value: number, label: string): void {\n  if (!Number.isInteger(value) || value < 0) {\n    throw new RangeError(`${label} must be a non-negative integer.`);\n  }\n}\n","import { concatBytes } from '@jscrypto/core';\nimport type { HashComponent } from '@jscrypto/core';\n\nexport function hmac(hash: HashComponent, key: Uint8Array, input: Uint8Array): Uint8Array {\n  const normalizedKey = key.length > hash.blockSize ? hash.hash(key) : key;\n  const innerKey = new Uint8Array(hash.blockSize);\n  const outerKey = new Uint8Array(hash.blockSize);\n  innerKey.set(normalizedKey);\n  outerKey.set(normalizedKey);\n\n  for (let i = 0; i < hash.blockSize; i++) {\n    innerKey[i] ^= 0x36;\n    outerKey[i] ^= 0x5c;\n  }\n\n  return hash.hash(concatBytes(outerKey, hash.hash(concatBytes(innerKey, input))));\n}\n","import { concatBytes } from '@jscrypto/core';\nimport type { HashComponent, KdfComponent, PresetComponent } from '@jscrypto/core';\nimport { hmac } from './hmac.js';\n\ndeclare const TextEncoder: {\n  new(): { encode(input: string): Uint8Array };\n};\n\nexport interface Pbkdf2Params {\n  input: Uint8Array | string;\n  salt: Uint8Array | string;\n  iterations: number;\n  length: number;\n  hash?: string;\n}\n\nexport interface DerivePbkdf2Params extends Omit<Pbkdf2Params, 'hash'> {\n  hash: HashComponent;\n}\n\nexport const pbkdf2: KdfComponent<'PBKDF2'> = {\n  kind: 'kdf',\n  name: 'PBKDF2',\n  derive(params, context) {\n    const options = params as Pbkdf2Params;\n    return derivePbkdf2({\n      ...options,\n      hash: context.getHash(options.hash ?? 'SHA256'),\n    });\n  },\n};\n\nexport const pbkdf2Preset: PresetComponent<'pbkdf2'> = {\n  kind: 'preset',\n  name: 'pbkdf2',\n  components() {\n    return [pbkdf2];\n  },\n};\n\nexport function derivePbkdf2(params: DerivePbkdf2Params): Uint8Array {\n  assertPositiveInteger(params.iterations, 'PBKDF2 iterations');\n  assertPositiveInteger(params.length, 'PBKDF2 length');\n  if (params.input === undefined || params.input === null) {\n    throw new TypeError('PBKDF2 requires input.');\n  }\n  if (params.salt === undefined || params.salt === null) {\n    throw new TypeError('PBKDF2 requires salt.');\n  }\n\n  const password = toBytes(params.input);\n  const salt = toBytes(params.salt);\n  const blocks: Uint8Array[] = [];\n  const blockCount = Math.ceil(params.length / params.hash.digestSize);\n\n  for (let index = 1; index <= blockCount; index++) {\n    const counter = new Uint8Array([\n      (index >>> 24) & 0xff,\n      (index >>> 16) & 0xff,\n      (index >>> 8) & 0xff,\n      index & 0xff,\n    ]);\n    let block = hmac(params.hash, password, concatBytes(salt, counter));\n    const result = block.slice();\n    for (let iteration = 1; iteration < params.iterations; iteration++) {\n      block = hmac(params.hash, password, block);\n      for (let i = 0; i < result.length; i++) {\n        result[i] ^= block[i];\n      }\n    }\n    blocks.push(result);\n  }\n\n  return concatBytes(...blocks).slice(0, params.length);\n}\n\nfunction toBytes(input: Uint8Array | string): Uint8Array {\n  return typeof input === 'string' ? new TextEncoder().encode(input) : input;\n}\n\nfunction assertPositiveInteger(value: number, label: string): void {\n  if (!Number.isInteger(value) || value <= 0) {\n    throw new RangeError(`${label} must be a positive integer.`);\n  }\n}\n","/**\n * HMAC: RFC2104 message authentication code.\n * @module\n */\nimport { abytes, aexists, ahash, aoutput, clean, } from \"./utils.js\";\n/**\n * Internal class for HMAC.\n * Accepts any byte key, although RFC 2104 §3 recommends keys at least\n * `HashLen` bytes long.\n */\nexport class _HMAC {\n    oHash;\n    iHash;\n    blockLen;\n    outputLen;\n    canXOF = false;\n    finished = false;\n    destroyed = false;\n    constructor(hash, key) {\n        ahash(hash);\n        abytes(key, undefined, 'key');\n        this.iHash = hash.create();\n        if (typeof this.iHash.update !== 'function')\n            throw new Error('expected Hash instance');\n        this.blockLen = this.iHash.blockLen;\n        this.outputLen = this.iHash.outputLen;\n        const blockLen = this.blockLen;\n        const pad = new Uint8Array(blockLen);\n        // blockLen can be bigger than outputLen\n        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36;\n        this.iHash.update(pad);\n        // By doing update (processing of the first block) of the outer hash here,\n        // we can re-use it between multiple calls via clone.\n        this.oHash = hash.create();\n        // Undo internal XOR && apply outer XOR\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36 ^ 0x5c;\n        this.oHash.update(pad);\n        clean(pad);\n    }\n    update(buf) {\n        aexists(this);\n        this.iHash.update(buf);\n        return this;\n    }\n    digestInto(out) {\n        aexists(this);\n        aoutput(out, this);\n        this.finished = true;\n        const buf = out.subarray(0, this.outputLen);\n        // Reuse the first outputLen bytes for the inner digest; the outer hash consumes them before\n        // overwriting that same prefix with the final tag, leaving any oversized tail untouched.\n        this.iHash.digestInto(buf);\n        this.oHash.update(buf);\n        this.oHash.digestInto(buf);\n        this.destroy();\n    }\n    digest() {\n        const out = new Uint8Array(this.oHash.outputLen);\n        this.digestInto(out);\n        return out;\n    }\n    _cloneInto(to) {\n        // Create new instance without calling constructor since the key\n        // is already in state and we don't know it.\n        to ||= Object.create(Object.getPrototypeOf(this), {});\n        const { oHash, iHash, finished, destroyed, blockLen, outputLen, canXOF } = this;\n        to = to;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        to.blockLen = blockLen;\n        to.outputLen = outputLen;\n        to.canXOF = canXOF;\n        to.oHash = oHash._cloneInto(to.oHash);\n        to.iHash = iHash._cloneInto(to.iHash);\n        return to;\n    }\n    clone() {\n        return this._cloneInto();\n    }\n    destroy() {\n        this.destroyed = true;\n        this.oHash.destroy();\n        this.iHash.destroy();\n    }\n}\nexport const hmac = /* @__PURE__ */ (() => {\n    const hmac_ = ((hash, key, message) => new _HMAC(hash, key).update(message).digest());\n    hmac_.create = (hash, key) => new _HMAC(hash, key);\n    return hmac_;\n})();\n","/**\n * PBKDF (RFC 2898). Can be used to create a key from password and salt.\n * @module\n */\nimport { hmac } from \"./hmac.js\";\n// prettier-ignore\nimport { ahash, anumber, asyncLoop, checkOpts, clean, createView, kdfInputToBytes } from \"./utils.js\";\n// Common validation and per-call state setup for sync/async functions.\nfunction pbkdf2Init(hash, _password, _salt, _opts) {\n    ahash(hash);\n    const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);\n    const { c, dkLen, asyncTick } = opts;\n    anumber(c, 'c');\n    anumber(dkLen, 'dkLen');\n    anumber(asyncTick, 'asyncTick');\n    if (c < 1)\n        throw new Error('\"c\" (iterations) must be >= 1');\n    // RFC 8018 §5.2 defines `dkLen` as \"a positive integer\".\n    if (dkLen < 1)\n        throw new Error('\"dkLen\" must be >= 1');\n    // RFC 8018 §5.2 step 1 requires rejecting oversize `dkLen`\n    // before allocating the destination buffer.\n    if (dkLen > (2 ** 32 - 1) * hash.outputLen)\n        throw new Error('derived key too long');\n    const p = kdfInputToBytes(_password, 'password');\n    const s = kdfInputToBytes(_salt, 'salt');\n    // DK = PBKDF2(PRF, Password, Salt, c, dkLen);\n    const DK = new Uint8Array(dkLen);\n    const { iHash, oHash, outputLen } = hmac.create(hash, p);\n    // Drive keyed hashes directly; the wrapper is only needed to initialize their HMAC midstates.\n    const u = new Uint8Array(outputLen);\n    const eng = pbkdf2Engine(iHash, oHash, s, u);\n    return { c, dkLen, asyncTick, DK, outputLen, eng };\n}\n// Per-call PRF driver writes U1 into both `u` and `Ti`, then later digests into `u`;\n// shared by the sync and async variants.\nfunction pbkdf2Engine(iHash, oHash, salt, u) {\n    const counter = new Uint8Array(4);\n    const view = createView(counter);\n    // Full clones retain tree/config state; absorb salt before async yields without cloning input.\n    const salted = iHash._cloneInto().update(salt);\n    // u1() overwrites the worker before reading it. Seed from the outer midstate so a long salt\n    // cannot pre-populate a tree stack that the first reset would abandon without wiping.\n    const work = oHash._cloneInto();\n    const iClone = iHash._cloneInto; // Capture before mixed feedback can materialize state tuples.\n    const oClone = oHash._cloneInto;\n    return {\n        u1: (ti, Ti) => {\n            view.setInt32(0, ti, false);\n            salted._cloneInto(work).update(counter).digestInto(u);\n            oHash._cloneInto(work).update(u).digestInto(u);\n            Ti.set(u.subarray(0, Ti.length));\n        },\n        // Whole `F` inner loop for the sync variant: one optimized function owns the hot loop.\n        rounds: (c, Ti) => {\n            for (let ui = 1; ui < c; ui++) {\n                iClone.call(iHash, work).update(u).digestInto(u);\n                oClone.call(oHash, work).update(u).digestInto(u);\n                for (let i = 0; i < Ti.length; i++)\n                    Ti[i] ^= u[i];\n            }\n        },\n        output: (DK) => {\n            // Keyed templates and derived worker states are secret material.\n            iHash.destroy();\n            oHash.destroy();\n            salted.destroy();\n            work.destroy();\n            // Shared sync/async cleanup point: wipe transient PRF state\n            // while preserving the derived key buffer.\n            clean(u);\n            return DK;\n        },\n    };\n}\n/**\n * PBKDF2-HMAC: RFC 8018 key derivation function.\n * @param hash - hash function that would be used e.g. sha256\n * @param password - password from which a derived key is generated;\n *   JS string inputs are UTF-8 encoded first\n * @param salt - cryptographic salt; JS string inputs are UTF-8 encoded first\n * @param opts - PBKDF2 work factor and output settings. `dkLen`, if provided,\n *   must be `>= 1` per RFC 8018 §5.2. See {@link Pbkdf2Opt}.\n * @returns Derived key bytes.\n * @throws If the PBKDF2 iteration count or derived-key settings are invalid. {@link Error}\n * @example\n * PBKDF2-HMAC: RFC 2898 key derivation function.\n * ```ts\n * import { pbkdf2 } from '@noble/hashes/pbkdf2.js';\n * import { sha256 } from '@noble/hashes/sha2.js';\n * const key = pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: Math.pow(2, 18) });\n * ```\n */\nexport function pbkdf2(hash, password, salt, opts) {\n    const { c, dkLen, DK, outputLen, eng } = pbkdf2Init(hash, password, salt, opts);\n    // DK = T1 + T2 + ⋯ + Tdklen/hlen\n    for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += outputLen) {\n        // Ti = F(Password, Salt, c, i)\n        // The last Ti view can be shorter than hLen, which applies\n        // RFC 8018 §5.2 step 4's T_l<0..r-1> truncation without extra copies.\n        const Ti = DK.subarray(pos, pos + outputLen);\n        // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc\n        // U1 = PRF(Password, Salt + INT_32_BE(i))\n        eng.u1(ti, Ti);\n        // Uc = PRF(Password, Uc−1); Ti ^= Uc\n        eng.rounds(c, Ti);\n    }\n    return eng.output(DK);\n}\n/**\n * PBKDF2-HMAC: RFC 8018 key derivation function. Async version.\n * @param hash - hash function that would be used e.g. sha256\n * @param password - password from which a derived key is generated;\n *   JS string inputs are UTF-8 encoded first\n * @param salt - cryptographic salt; JS string inputs are UTF-8 encoded first\n * @param opts - PBKDF2 work factor and output settings. `dkLen`, if provided,\n *   must be `>= 1` per RFC 8018 §5.2. `asyncTick` is only a local\n *   scheduler-yield knob for this JS wrapper, not part of RFC 8018.\n *   See {@link Pbkdf2Opt}.\n * @returns Promise resolving to derived key bytes.\n * @throws If the PBKDF2 iteration count or derived-key settings are invalid. {@link Error}\n * @example\n * PBKDF2-HMAC: RFC 2898 key derivation function.\n * ```ts\n * import { pbkdf2Async } from '@noble/hashes/pbkdf2.js';\n * import { sha256 } from '@noble/hashes/sha2.js';\n * const key = await pbkdf2Async(sha256, 'password', 'salt', { dkLen: 32, c: 500_000 });\n * ```\n * @example\n * Tune the async PBKDF2 scheduler for short UI tasks.\n * ```ts\n * import { pbkdf2Async } from '@noble/hashes/pbkdf2.js';\n * import { sha256 } from '@noble/hashes/sha2.js';\n * const key = await pbkdf2Async(sha256, 'password', 'salt', {\n *   dkLen: 32,\n *   c: 32,\n *   asyncTick: 1,\n * });\n * ```\n */\nexport async function pbkdf2Async(hash, password, salt, opts) {\n    const { c, dkLen, asyncTick, DK, outputLen, eng } = pbkdf2Init(hash, password, salt, opts);\n    // DK = T1 + T2 + ⋯ + Tdklen/hlen\n    for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += outputLen) {\n        // Ti = F(Password, Salt, c, i)\n        // The last Ti view can be shorter than hLen, which applies\n        // RFC 8018 §5.2 step 4's T_l<0..r-1> truncation without extra copies.\n        const Ti = DK.subarray(pos, pos + outputLen);\n        // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc\n        // U1 = PRF(Password, Salt + INT_32_BE(i))\n        eng.u1(ti, Ti);\n        await asyncLoop(c - 1, asyncTick, () => {\n            // Uc = PRF(Password, Uc−1)\n            eng.rounds(2, Ti); // c=2 runs exactly one PRF iteration per callback.\n        });\n    }\n    return eng.output(DK);\n}\n","/**\n * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.\n * SHA256 is the fastest hash implementable in JS, even faster than Blake3.\n * Check out {@link https://www.rfc-editor.org/rfc/rfc4634 | RFC 4634} and\n * {@link https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf | FIPS 180-4}.\n * @module\n */\nimport { Chi, HashMD, Maj, SHA224_IV, SHA256_IV, SHA384_IV, SHA512_IV } from \"./_md.js\";\nimport * as u64 from \"./_u64.js\";\nimport { clean, createHasher, oidNist, rotr } from \"./utils.js\";\n/**\n * SHA-224 / SHA-256 round constants from RFC 6234 §5.1: the first 32 bits\n * of the cube roots of the first 64 primes (2..311).\n */\n// prettier-ignore\nconst SHA256_K = /* @__PURE__ */ Uint32Array.from([\n    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\n/** Reusable SHA-224 / SHA-256 message schedule buffer `W_t` from RFC 6234 §6.2 step 1. */\nconst SHA256_W = /* @__PURE__ */ new Uint32Array(64);\n/** Internal SHA-224 / SHA-256 compression engine from RFC 6234 §6.2. */\nclass SHA2_32B extends HashMD {\n    // We cannot use array here since array allows indexing by variable\n    // which means optimizer/compiler cannot use registers.\n    // Numeric initializers matter: starting the fields as `undefined` changes\n    // V8's field representation and makes sha256 3x slower (measured).\n    A = 0;\n    B = 0;\n    C = 0;\n    D = 0;\n    E = 0;\n    F = 0;\n    G = 0;\n    H = 0;\n    constructor(outputLen, IV) {\n        super(64, outputLen, 8, false);\n        this.A = IV[0] | 0;\n        this.B = IV[1] | 0;\n        this.C = IV[2] | 0;\n        this.D = IV[3] | 0;\n        this.E = IV[4] | 0;\n        this.F = IV[5] | 0;\n        this.G = IV[6] | 0;\n        this.H = IV[7] | 0;\n    }\n    get() {\n        const { A, B, C, D, E, F, G, H } = this;\n        return [A, B, C, D, E, F, G, H];\n    }\n    // prettier-ignore\n    set(A, B, C, D, E, F, G, H) {\n        this.A = A | 0;\n        this.B = B | 0;\n        this.C = C | 0;\n        this.D = D | 0;\n        this.E = E | 0;\n        this.F = F | 0;\n        this.G = G | 0;\n        this.H = H | 0;\n    }\n    _cloneInto(to) {\n        (to ||= new this.constructor()).set(...this.get());\n        return this._cloneIntoMeta(to);\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4)\n            SHA256_W[i] = view.getUint32(offset, false);\n        for (let i = 16; i < 64; i++) {\n            const W15 = SHA256_W[i - 15];\n            const W2 = SHA256_W[i - 2];\n            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);\n            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);\n            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;\n        }\n        // Compression function main loop, 64 rounds\n        let { A, B, C, D, E, F, G, H } = this;\n        for (let i = 0; i < 64; i++) {\n            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);\n            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);\n            const T2 = (sigma0 + Maj(A, B, C)) | 0;\n            H = G;\n            G = F;\n            F = E;\n            E = (D + T1) | 0;\n            D = C;\n            C = B;\n            B = A;\n            A = (T1 + T2) | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        A = (A + this.A) | 0;\n        B = (B + this.B) | 0;\n        C = (C + this.C) | 0;\n        D = (D + this.D) | 0;\n        E = (E + this.E) | 0;\n        F = (F + this.F) | 0;\n        G = (G + this.G) | 0;\n        H = (H + this.H) | 0;\n        this.set(A, B, C, D, E, F, G, H);\n    }\n    roundClean() {\n        clean(SHA256_W);\n    }\n    destroy() {\n        // HashMD callers route post-destroy usability through `destroyed`; zeroizing alone still leaves\n        // update()/digest() callable on reused instances.\n        this.destroyed = true;\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n        clean(this.buffer);\n    }\n}\n/** Internal SHA-256 hash class grounded in RFC 6234 §6.2. */\nexport class _SHA256 extends SHA2_32B {\n    constructor() {\n        super(32, SHA256_IV);\n    }\n}\n/** Internal SHA-224 hash class grounded in RFC 6234 §6.2 and §8.5. */\nexport class _SHA224 extends SHA2_32B {\n    constructor() {\n        super(28, SHA224_IV);\n    }\n}\n// SHA2-512 is slower than sha256 in js because u64 operations are slow.\n// SHA-384 / SHA-512 round constants from RFC 6234 §5.2:\n// 80 full 64-bit words split into high/low halves.\n// prettier-ignore\nconst K512 = /* @__PURE__ */ (() => u64.split([\n    '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',\n    '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',\n    '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',\n    '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',\n    '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',\n    '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',\n    '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',\n    '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',\n    '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',\n    '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',\n    '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',\n    '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',\n    '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',\n    '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',\n    '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',\n    '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',\n    '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',\n    '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',\n    '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',\n    '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'\n].map(n => BigInt(n))))();\nconst SHA512_Kh = /* @__PURE__ */ (() => K512[0])();\nconst SHA512_Kl = /* @__PURE__ */ (() => K512[1])();\n// Reusable high-half schedule buffer for the RFC 6234 §6.4 64-bit `W_t` words.\nconst SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);\n// Reusable low-half schedule buffer for the RFC 6234 §6.4 64-bit `W_t` words.\nconst SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);\n/** Internal SHA-384 / SHA-512 compression engine from RFC 6234 §6.4. */\nclass SHA2_64B extends HashMD {\n    // We cannot use array here since array allows indexing by variable\n    // which means optimizer/compiler cannot use registers.\n    // h -- high 32 bits, l -- low 32 bits\n    // Numeric initializers matter: starting the fields as `undefined` changes\n    // V8's field representation and slows hashing down (measured on sha256).\n    Ah = 0;\n    Al = 0;\n    Bh = 0;\n    Bl = 0;\n    Ch = 0;\n    Cl = 0;\n    Dh = 0;\n    Dl = 0;\n    Eh = 0;\n    El = 0;\n    Fh = 0;\n    Fl = 0;\n    Gh = 0;\n    Gl = 0;\n    Hh = 0;\n    Hl = 0;\n    constructor(outputLen, IV) {\n        super(128, outputLen, 16, false);\n        this.Ah = IV[0] | 0;\n        this.Al = IV[1] | 0;\n        this.Bh = IV[2] | 0;\n        this.Bl = IV[3] | 0;\n        this.Ch = IV[4] | 0;\n        this.Cl = IV[5] | 0;\n        this.Dh = IV[6] | 0;\n        this.Dl = IV[7] | 0;\n        this.Eh = IV[8] | 0;\n        this.El = IV[9] | 0;\n        this.Fh = IV[10] | 0;\n        this.Fl = IV[11] | 0;\n        this.Gh = IV[12] | 0;\n        this.Gl = IV[13] | 0;\n        this.Hh = IV[14] | 0;\n        this.Hl = IV[15] | 0;\n    }\n    // prettier-ignore\n    get() {\n        const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];\n    }\n    // prettier-ignore\n    set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {\n        this.Ah = Ah | 0;\n        this.Al = Al | 0;\n        this.Bh = Bh | 0;\n        this.Bl = Bl | 0;\n        this.Ch = Ch | 0;\n        this.Cl = Cl | 0;\n        this.Dh = Dh | 0;\n        this.Dl = Dl | 0;\n        this.Eh = Eh | 0;\n        this.El = El | 0;\n        this.Fh = Fh | 0;\n        this.Fl = Fl | 0;\n        this.Gh = Gh | 0;\n        this.Gl = Gl | 0;\n        this.Hh = Hh | 0;\n        this.Hl = Hl | 0;\n    }\n    _cloneInto(to) {\n        (to ||= new this.constructor()).set(...this.get());\n        return this._cloneIntoMeta(to);\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4) {\n            SHA512_W_H[i] = view.getUint32(offset);\n            SHA512_W_L[i] = view.getUint32((offset += 4));\n        }\n        for (let i = 16; i < 80; i++) {\n            // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)\n            const W15h = SHA512_W_H[i - 15] | 0;\n            const W15l = SHA512_W_L[i - 15] | 0;\n            const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);\n            const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);\n            // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)\n            const W2h = SHA512_W_H[i - 2] | 0;\n            const W2l = SHA512_W_L[i - 2] | 0;\n            const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);\n            const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);\n            // SHA512_W[i] = s0 + s1 + SHA512_W[i - 7] + SHA512_W[i - 16];\n            const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\n            const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);\n            SHA512_W_H[i] = SUMh | 0;\n            SHA512_W_L[i] = SUMl | 0;\n        }\n        let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        // Compression function main loop, 80 rounds\n        for (let i = 0; i < 80; i++) {\n            // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)\n            const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);\n            const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);\n            //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const CHIh = (Eh & Fh) ^ (~Eh & Gh);\n            const CHIl = (El & Fl) ^ (~El & Gl);\n            // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]\n            // prettier-ignore\n            const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\n            const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);\n            const T1l = T1ll | 0;\n            // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)\n            const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);\n            const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);\n            const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);\n            const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);\n            Hh = Gh | 0;\n            Hl = Gl | 0;\n            Gh = Fh | 0;\n            Gl = Fl | 0;\n            Fh = Eh | 0;\n            Fl = El | 0;\n            ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));\n            Dh = Ch | 0;\n            Dl = Cl | 0;\n            Ch = Bh | 0;\n            Cl = Bl | 0;\n            Bh = Ah | 0;\n            Bl = Al | 0;\n            const All = u64.add3L(T1l, sigma0l, MAJl);\n            Ah = u64.add3H(All, T1h, sigma0h, MAJh);\n            Al = All | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));\n        ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));\n        ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));\n        ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));\n        ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));\n        ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));\n        ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));\n        ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));\n        this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);\n    }\n    roundClean() {\n        clean(SHA512_W_H, SHA512_W_L);\n    }\n    destroy() {\n        // HashMD callers route post-destroy usability through `destroyed`; zeroizing alone still leaves\n        // update()/digest() callable on reused instances.\n        this.destroyed = true;\n        clean(this.buffer);\n        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n    }\n}\n/** Internal SHA-512 hash class grounded in RFC 6234 §6.3 and §6.4. */\nexport class _SHA512 extends SHA2_64B {\n    constructor() {\n        super(64, SHA512_IV);\n    }\n}\n/** Internal SHA-384 hash class grounded in RFC 6234 §6.3 and §6.4. */\nexport class _SHA384 extends SHA2_64B {\n    constructor() {\n        super(48, SHA384_IV);\n    }\n}\n/**\n * Truncated SHA512/256 and SHA512/224.\n * SHA512_IV is XORed with 0xa5a5a5a5a5a5a5a5, then used as \"intermediary\" IV of SHA512/t.\n * Then t hashes string to produce result IV.\n * See the repo-side derivation recipe in `test/misc/sha2-gen-iv.js`.\n * These IV literals are checked against that script rather than a dedicated\n * local RFC section.\n */\n/** SHA-512/224 IV derived by the SHA-512/t recipe in `test/misc/sha2-gen-iv.js` and\n * stored as sixteen big-endian 32-bit halves. */\nconst T224_IV = /* @__PURE__ */ Uint32Array.from([\n    0x8c3d37c8, 0x19544da2, 0x73e19966, 0x89dcd4d6, 0x1dfab7ae, 0x32ff9c82, 0x679dd514, 0x582f9fcf,\n    0x0f6d2b69, 0x7bd44da8, 0x77e36f73, 0x04c48942, 0x3f9d85a8, 0x6a1d36c8, 0x1112e6ad, 0x91d692a1,\n]);\n/** SHA-512/256 IV derived by the SHA-512/t recipe in `test/misc/sha2-gen-iv.js` and\n * stored as sixteen big-endian 32-bit halves. */\nconst T256_IV = /* @__PURE__ */ Uint32Array.from([\n    0x22312194, 0xfc2bf72c, 0x9f555fa3, 0xc84c64c2, 0x2393b86b, 0x6f53b151, 0x96387719, 0x5940eabd,\n    0x96283ee2, 0xa88effe3, 0xbe5e1e25, 0x53863992, 0x2b0199fc, 0x2c85b8aa, 0x0eb72ddc, 0x81c52ca2,\n]);\n/** Internal SHA-512/224 hash class using the derived `T224_IV` and the shared\n * RFC 6234 §6.4 compression engine. */\nexport class _SHA512_224 extends SHA2_64B {\n    constructor() {\n        super(28, T224_IV);\n    }\n}\n/** Internal SHA-512/256 hash class using the derived `T256_IV` and the shared\n * RFC 6234 §6.4 compression engine. */\nexport class _SHA512_256 extends SHA2_64B {\n    constructor() {\n        super(32, T256_IV);\n    }\n}\n/**\n * SHA2-256 hash function from RFC 4634. In JS it's the fastest: even faster than Blake3. Some info:\n *\n * - Trying 2^128 hashes would get 50% chance of collision, using birthday attack.\n * - BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.\n * - Each sha256 hash is executing 2^18 bit operations.\n * - Good 2024 ASICs can do 200Th/sec with 3500 watts of power, corresponding to 2^36 hashes/joule.\n * @param msg - message bytes to hash\n * @param opts - Reserved hash options.\n * @returns Digest bytes.\n * @example\n * Hash a message with SHA2-256.\n * ```ts\n * sha256(new Uint8Array([97, 98, 99]));\n * ```\n */\nexport const sha256 = /* @__PURE__ */ createHasher(() => new _SHA256(), \n/* @__PURE__ */ oidNist(0x01));\n/**\n * SHA2-224 hash function from RFC 4634.\n * @param msg - message bytes to hash\n * @param opts - Reserved hash options.\n * @returns Digest bytes.\n * @example\n * Hash a message with SHA2-224.\n * ```ts\n * sha224(new Uint8Array([97, 98, 99]));\n * ```\n */\nexport const sha224 = /* @__PURE__ */ createHasher(() => new _SHA224(), \n/* @__PURE__ */ oidNist(0x04));\n/**\n * SHA2-512 hash function from RFC 4634.\n * @param msg - message bytes to hash\n * @param opts - Reserved hash options.\n * @returns Digest bytes.\n * @example\n * Hash a message with SHA2-512.\n * ```ts\n * sha512(new Uint8Array([97, 98, 99]));\n * ```\n */\nexport const sha512 = /* @__PURE__ */ createHasher(() => new _SHA512(), \n/* @__PURE__ */ oidNist(0x03));\n/**\n * SHA2-384 hash function from RFC 4634.\n * @param msg - message bytes to hash\n * @param opts - Reserved hash options.\n * @returns Digest bytes.\n * @example\n * Hash a message with SHA2-384.\n * ```ts\n * sha384(new Uint8Array([97, 98, 99]));\n * ```\n */\nexport const sha384 = /* @__PURE__ */ createHasher(() => new _SHA384(), \n/* @__PURE__ */ oidNist(0x02));\n/**\n * SHA2-512/256 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on {@link https://eprint.iacr.org/2010/548.pdf | truncated SHA512}.\n * @param msg - message bytes to hash\n * @param opts - Reserved hash options.\n * @returns Digest bytes.\n * @example\n * Hash a message with SHA2-512/256.\n * ```ts\n * sha512_256(new Uint8Array([97, 98, 99]));\n * ```\n */\nexport const sha512_256 = /* @__PURE__ */ createHasher(() => new _SHA512_256(), \n/* @__PURE__ */ oidNist(0x06));\n/**\n * SHA2-512/224 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on {@link https://eprint.iacr.org/2010/548.pdf | truncated SHA512}.\n * @param msg - message bytes to hash\n * @param opts - Reserved hash options.\n * @returns Digest bytes.\n * @example\n * Hash a message with SHA2-512/224.\n * ```ts\n * sha512_224(new Uint8Array([97, 98, 99]));\n * ```\n */\nexport const sha512_224 = /* @__PURE__ */ createHasher(() => new _SHA512_224(), \n/* @__PURE__ */ oidNist(0x05));\n","/**\n * RFC 7914 Scrypt KDF. Can be used to create a key from password and salt.\n * @module\n */\nimport { pbkdf2 } from \"./pbkdf2.js\";\nimport { sha256 } from \"./sha2.js\";\n// prettier-ignore\nimport { anumber, asyncLoop, checkOpts, clean, rotl, swap32IfBE, u32 } from \"./utils.js\";\n// The main Scrypt loop: uses Salsa extensively.\n// Six versions of the function were tried, this is the fastest one.\n// RFC 7914 §3 / §4 step 2 applies Salsa20/8 to one 16-word (64-byte) block\n// after xor'ing two such blocks.\n// The local `y*` snapshot keeps the xor input stable even when `out` aliases `prev` or `input`.\n// prettier-ignore\nfunction XorAndSalsa(prev, pi, input, ii, out, oi) {\n    // Based on https://cr.yp.to/salsa20.html and RFC 7914's Salsa20/8 core.\n    // Xor blocks\n    let y00 = prev[pi++] ^ input[ii++], y01 = prev[pi++] ^ input[ii++];\n    let y02 = prev[pi++] ^ input[ii++], y03 = prev[pi++] ^ input[ii++];\n    let y04 = prev[pi++] ^ input[ii++], y05 = prev[pi++] ^ input[ii++];\n    let y06 = prev[pi++] ^ input[ii++], y07 = prev[pi++] ^ input[ii++];\n    let y08 = prev[pi++] ^ input[ii++], y09 = prev[pi++] ^ input[ii++];\n    let y10 = prev[pi++] ^ input[ii++], y11 = prev[pi++] ^ input[ii++];\n    let y12 = prev[pi++] ^ input[ii++], y13 = prev[pi++] ^ input[ii++];\n    let y14 = prev[pi++] ^ input[ii++], y15 = prev[pi++] ^ input[ii++];\n    // Save state to temporary variables (salsa)\n    let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;\n    // Main loop (salsa)\n    for (let i = 0; i < 8; i += 2) {\n        x04 ^= rotl(x00 + x12 | 0, 7);\n        x08 ^= rotl(x04 + x00 | 0, 9);\n        x12 ^= rotl(x08 + x04 | 0, 13);\n        x00 ^= rotl(x12 + x08 | 0, 18);\n        x09 ^= rotl(x05 + x01 | 0, 7);\n        x13 ^= rotl(x09 + x05 | 0, 9);\n        x01 ^= rotl(x13 + x09 | 0, 13);\n        x05 ^= rotl(x01 + x13 | 0, 18);\n        x14 ^= rotl(x10 + x06 | 0, 7);\n        x02 ^= rotl(x14 + x10 | 0, 9);\n        x06 ^= rotl(x02 + x14 | 0, 13);\n        x10 ^= rotl(x06 + x02 | 0, 18);\n        x03 ^= rotl(x15 + x11 | 0, 7);\n        x07 ^= rotl(x03 + x15 | 0, 9);\n        x11 ^= rotl(x07 + x03 | 0, 13);\n        x15 ^= rotl(x11 + x07 | 0, 18);\n        x01 ^= rotl(x00 + x03 | 0, 7);\n        x02 ^= rotl(x01 + x00 | 0, 9);\n        x03 ^= rotl(x02 + x01 | 0, 13);\n        x00 ^= rotl(x03 + x02 | 0, 18);\n        x06 ^= rotl(x05 + x04 | 0, 7);\n        x07 ^= rotl(x06 + x05 | 0, 9);\n        x04 ^= rotl(x07 + x06 | 0, 13);\n        x05 ^= rotl(x04 + x07 | 0, 18);\n        x11 ^= rotl(x10 + x09 | 0, 7);\n        x08 ^= rotl(x11 + x10 | 0, 9);\n        x09 ^= rotl(x08 + x11 | 0, 13);\n        x10 ^= rotl(x09 + x08 | 0, 18);\n        x12 ^= rotl(x15 + x14 | 0, 7);\n        x13 ^= rotl(x12 + x15 | 0, 9);\n        x14 ^= rotl(x13 + x12 | 0, 13);\n        x15 ^= rotl(x14 + x13 | 0, 18);\n    }\n    // Write output (salsa)\n    out[oi++] = (y00 + x00) | 0;\n    out[oi++] = (y01 + x01) | 0;\n    out[oi++] = (y02 + x02) | 0;\n    out[oi++] = (y03 + x03) | 0;\n    out[oi++] = (y04 + x04) | 0;\n    out[oi++] = (y05 + x05) | 0;\n    out[oi++] = (y06 + x06) | 0;\n    out[oi++] = (y07 + x07) | 0;\n    out[oi++] = (y08 + x08) | 0;\n    out[oi++] = (y09 + x09) | 0;\n    out[oi++] = (y10 + x10) | 0;\n    out[oi++] = (y11 + x11) | 0;\n    out[oi++] = (y12 + x12) | 0;\n    out[oi++] = (y13 + x13) | 0;\n    out[oi++] = (y14 + x14) | 0;\n    out[oi++] = (y15 + x15) | 0;\n}\nfunction BlockMix(input, ii, out, oi, r) {\n    // The block B is `r` 128-byte chunks, i.e. `2r` 16-word (64-byte) Salsa blocks.\n    let head = oi + 0;\n    let tail = oi + 16 * r;\n    for (let i = 0; i < 16; i++)\n        out[tail + i] = input[ii + (2 * r - 1) * 16 + i]; // X ← B[2r−1]\n    for (let i = 0; i < r; i++, head += 16, ii += 16) {\n        // RFC 7914 §4 step 3 outputs `Y[0], Y[2], ...` first, then `Y[1], Y[3], ...`;\n        // `head` and `tail` lay out those even/odd halves in place.\n        XorAndSalsa(out, tail, input, ii, out, head); // head[i] = Salsa(blockIn[2*i] ^ tail[i-1])\n        if (i > 0)\n            tail += 16; // First iteration overwrites tmp value in tail\n        // tail[i] = Salsa(blockIn[2*i+1] ^ head[i])\n        XorAndSalsa(out, head, input, (ii += 16), out, tail);\n    }\n}\n// Common prologue and epilogue for sync/async functions\nfunction scryptInit(password, salt, _opts) {\n    // Maxmem - 1GB+1KB by default\n    const opts = checkOpts({\n        dkLen: 32,\n        asyncTick: 10,\n        maxmem: 1024 ** 3 + 1024,\n    }, _opts);\n    const { N, r, p, dkLen, asyncTick, maxmem, onProgress } = opts;\n    anumber(N, 'N');\n    anumber(r, 'r');\n    anumber(p, 'p');\n    anumber(dkLen, 'dkLen');\n    anumber(asyncTick, 'asyncTick');\n    anumber(maxmem, 'maxmem');\n    if (onProgress !== undefined && typeof onProgress !== 'function')\n        throw new Error('\"onProgress\" must be a function');\n    // Without this, r=0 slips through: blockSize=0 turns the `p` upper bound into\n    // Infinity and the failure surfaces later as a confusing pbkdf2 dkLen error.\n    if (r < 1)\n        throw new Error('\"r\" expected integer >= 1');\n    const blockSize = 128 * r;\n    const blockSize32 = blockSize / 4;\n    // Max N is 2^32 (Integrify is 32-bit).\n    // Real limit can be 2^22: some JS engines limit Uint8Array to 4GB.\n    // Spec check `N >= 2^(blockSize / 8)` is not done for compat with popular libs,\n    // which used incorrect r: 1, p: 8. Also, the check seems to be a spec error:\n    // https://www.rfc-editor.org/errata_search.php?rfc=7914\n    const pow32 = Math.pow(2, 32);\n    if (N <= 1 || (N & (N - 1)) !== 0 || N > pow32)\n        throw new Error('\"N\" expected a power of 2, and 2^1 <= N <= 2^32');\n    if (p < 1 || p > ((pow32 - 1) * 32) / blockSize)\n        throw new Error('\"p\" expected integer 1..((2^32 - 1) * 32) / (128 * r)');\n    // RFC 7914 §2 defines `dkLen` as a positive integer.\n    if (dkLen < 1 || dkLen > (pow32 - 1) * 32)\n        throw new Error('\"dkLen\" expected integer 1..(2^32 - 1) * 32');\n    // Include the shared `tmp` scratch block so `maxmem` matches noble's actual temporary allocation.\n    // Node requires more headroom here, so this accounting is intentionally noble-specific.\n    const memUsed = blockSize * (N + p + 1);\n    if (memUsed > maxmem)\n        throw new Error('\"maxmem\" limit was hit: memUsed(128*r*(N+p+1))=' + memUsed + ', maxmem=' + maxmem);\n    // [B0...Bp−1] ← PBKDF2HMAC-SHA256(Passphrase, Salt, 1, blockSize*ParallelizationFactor)\n    // Since it has only one iteration there is no reason to use async variant\n    const B = pbkdf2(sha256, password, salt, { c: 1, dkLen: blockSize * p });\n    const B32 = u32(B);\n    // Re-used between parallel iterations. Array(iterations) of B\n    const V = u32(new Uint8Array(blockSize * N));\n    const tmp = u32(new Uint8Array(blockSize));\n    let blockMixCb = () => { };\n    if (onProgress) {\n        const totalBlockMix = 2 * N * p;\n        // Invoke callback if progress changes from 10.01 to 10.02\n        // Allows to draw smooth progress bar on up to 8K screen\n        const callbackPer = Math.max(Math.floor(totalBlockMix / 10000), 1);\n        let blockMixCnt = 0;\n        blockMixCb = () => {\n            blockMixCnt++;\n            if (onProgress && (!(blockMixCnt % callbackPer) || blockMixCnt === totalBlockMix)) {\n                // Wiping here instead of a try/catch around the main loops keeps them\n                // try-free: measured ~1% slower at N=2^21 with the loops inside a try.\n                // onProgress is the only user code that can throw mid-derivation.\n                try {\n                    onProgress(blockMixCnt / totalBlockMix);\n                }\n                catch (e) {\n                    clean(B, V, tmp);\n                    throw e;\n                }\n            }\n        };\n    }\n    return { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick };\n}\nfunction scryptOutput(password, dkLen, B, V, tmp) {\n    // Shared final PBKDF2-and-cleanup step: keep the derived key, wipe the scrypt workspace.\n    const res = pbkdf2(sha256, password, B, { c: 1, dkLen });\n    clean(B, V, tmp);\n    return res;\n}\n/**\n * Scrypt KDF from RFC 7914. See {@link ScryptOpts}.\n * @param password - password or key material to derive from;\n *   JS string inputs are UTF-8 encoded first\n * @param salt - unique salt bytes or string; JS string inputs are UTF-8 encoded first\n * @param opts - Scrypt cost and memory parameters. `dkLen`, if provided,\n *   must be `>= 1` per RFC 7914 §2. See {@link ScryptOpts}.\n * @returns Derived key bytes.\n * @throws If the Scrypt cost, memory, or callback options are invalid. {@link Error}\n * @example\n * Derive a key with scrypt.\n * ```ts\n * scrypt('password', 'salt', { N: 2**18, r: 8, p: 1, dkLen: 32 });\n * ```\n * @example\n * Derive a key with small demo costs and progress/memory controls.\n * ```ts\n * const progressLog: number[] = [];\n * scrypt('password', 'salt', {\n *   N: 16,\n *   r: 8,\n *   p: 1,\n *   dkLen: 32,\n *   maxmem: 1024 * 1024,\n *   asyncTick: 10,\n *   onProgress(progress) {\n *     progressLog.push(progress);\n *   },\n * });\n * ```\n */\nexport function scrypt(password, salt, opts) {\n    const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb } = scryptInit(password, salt, opts);\n    swap32IfBE(B32);\n    for (let pi = 0; pi < p; pi++) {\n        const Pi = blockSize32 * pi;\n        for (let i = 0; i < blockSize32; i++)\n            V[i] = B32[Pi + i]; // V[0] = B[i]\n        for (let i = 0, pos = 0; i < N - 1; i++) {\n            BlockMix(V, pos, V, (pos += blockSize32), r); // V[i] = BlockMix(V[i-1]);\n            blockMixCb();\n        }\n        BlockMix(V, (N - 1) * blockSize32, B32, Pi, r); // Process last element\n        blockMixCb();\n        for (let i = 0; i < N; i++) {\n            // First u32 of the last 64-byte block (u32 is LE)\n            // RFC 7914 Integerify(X) uses the whole last 64-byte block, but mod N\n            // only depends on the low word here because N is a power of two and\n            // this implementation caps N at 2^32.\n            // & (N - 1) is % N as N is a power of 2, N & (N - 1) = 0 is checked\n            // above; >>> 0 for unsigned, input fits in u32.\n            const j = (B32[Pi + blockSize32 - 16] & (N - 1)) >>> 0; // j = Integrify(X) % iterations\n            // tmp = B ^ V[j]\n            for (let k = 0; k < blockSize32; k++)\n                tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k];\n            BlockMix(tmp, 0, B32, Pi, r); // B = BlockMix(B ^ V[j])\n            blockMixCb();\n        }\n    }\n    swap32IfBE(B32);\n    return scryptOutput(password, dkLen, B, V, tmp);\n}\n/**\n * Scrypt KDF from RFC 7914. Async version. See {@link ScryptOpts}.\n * @param password - password or key material to derive from;\n *   JS string inputs are UTF-8 encoded first\n * @param salt - unique salt bytes or string; JS string inputs are UTF-8 encoded first\n * @param opts - Scrypt cost and memory parameters. `dkLen`, if provided,\n *   must be `>= 1` per RFC 7914 §2. `asyncTick` is only a local\n *   scheduler-yield control for this JS wrapper, not part of RFC 7914.\n *   See {@link ScryptOpts}.\n * @returns Promise resolving to derived key bytes.\n * @throws If the Scrypt cost, memory, or callback options are invalid. {@link Error}\n * @example\n * Derive a key with scrypt asynchronously.\n * ```ts\n * await scryptAsync('password', 'salt', { N: 2**18, r: 8, p: 1, dkLen: 32 });\n * ```\n * @example\n * Derive a key asynchronously with small demo costs and progress/memory controls.\n * ```ts\n * await scryptAsync('password', 'salt', {\n *   N: 16,\n *   r: 8,\n *   p: 1,\n *   dkLen: 32,\n *   maxmem: 1024 * 1024,\n *   asyncTick: 1,\n *   onProgress(progress) {\n *     if (progress > 1) throw new Error('invalid progress');\n *   },\n * });\n * ```\n */\nexport async function scryptAsync(password, salt, opts) {\n    const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick } = scryptInit(password, salt, opts);\n    swap32IfBE(B32);\n    for (let pi = 0; pi < p; pi++) {\n        const Pi = blockSize32 * pi;\n        for (let i = 0; i < blockSize32; i++)\n            V[i] = B32[Pi + i]; // V[0] = B[i]\n        let pos = 0;\n        await asyncLoop(N - 1, asyncTick, () => {\n            BlockMix(V, pos, V, (pos += blockSize32), r); // V[i] = BlockMix(V[i-1]);\n            blockMixCb();\n        });\n        BlockMix(V, (N - 1) * blockSize32, B32, Pi, r); // Process last element\n        blockMixCb();\n        await asyncLoop(N, asyncTick, () => {\n            // First u32 of the last 64-byte block (u32 is LE)\n            // RFC 7914 Integerify(X) uses the whole last 64-byte block, but mod N\n            // only depends on the low word here because N is a power of two and\n            // this implementation caps N at 2^32.\n            // & (N - 1) is % N as N is a power of 2, N & (N - 1) = 0 is checked\n            // above; >>> 0 for unsigned, input fits in u32.\n            const j = (B32[Pi + blockSize32 - 16] & (N - 1)) >>> 0; // j = Integrify(X) % iterations\n            // tmp = B ^ V[j]\n            for (let k = 0; k < blockSize32; k++)\n                tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k];\n            BlockMix(tmp, 0, B32, Pi, r); // B = BlockMix(B ^ V[j])\n            blockMixCb();\n        });\n    }\n    swap32IfBE(B32);\n    return scryptOutput(password, dkLen, B, V, tmp);\n}\n","import { scrypt as nobleScrypt } from '@noble/hashes/scrypt.js';\nimport type { KdfComponent, PresetComponent } from '@jscrypto/core';\n\ndeclare const TextEncoder: {\n  new(): { encode(input: string): Uint8Array };\n};\n\nexport interface ScryptParams {\n  input: Uint8Array | string;\n  salt: Uint8Array | string;\n  length: number;\n  N: number;\n  r: number;\n  p: number;\n  maxmem?: number;\n}\n\nexport const scrypt: KdfComponent<'Scrypt'> = {\n  kind: 'kdf',\n  name: 'Scrypt',\n  derive(params) {\n    return deriveScrypt(params as ScryptParams);\n  },\n};\n\nexport const scryptPreset: PresetComponent<'scrypt'> = {\n  kind: 'preset',\n  name: 'scrypt',\n  components() {\n    return [scrypt];\n  },\n};\n\nexport function deriveScrypt(params: ScryptParams): Uint8Array {\n  if (params === undefined || params === null || typeof params !== 'object') {\n    throw new TypeError('Scrypt requires params.');\n  }\n  if (params.input === undefined || params.input === null) {\n    throw new TypeError('Scrypt requires input.');\n  }\n  if (params.salt === undefined || params.salt === null) {\n    throw new TypeError('Scrypt requires salt.');\n  }\n\n  assertPositiveInteger(params.length, 'Scrypt length');\n  assertPositiveInteger(params.N, 'Scrypt N');\n  assertPositiveInteger(params.r, 'Scrypt r');\n  assertPositiveInteger(params.p, 'Scrypt p');\n  if ((params.N & (params.N - 1)) !== 0) {\n    throw new RangeError('Scrypt N must be a power of 2.');\n  }\n\n  const options: {\n    N: number;\n    r: number;\n    p: number;\n    dkLen: number;\n    maxmem?: number;\n  } = {\n    N: params.N,\n    r: params.r,\n    p: params.p,\n    dkLen: params.length,\n  };\n  if (params.maxmem !== undefined) {\n    assertPositiveInteger(params.maxmem, 'Scrypt maxmem');\n    options.maxmem = params.maxmem;\n  }\n\n  return nobleScrypt(toBytes(params.input), toBytes(params.salt), options);\n}\n\nfunction toBytes(input: Uint8Array | string): Uint8Array {\n  return typeof input === 'string' ? new TextEncoder().encode(input) : input;\n}\n\nfunction assertPositiveInteger(value: number, label: string): void {\n  if (!Number.isInteger(value) || value <= 0) {\n    throw new RangeError(`${label} must be a positive integer.`);\n  }\n}\n","import type { PresetComponent } from '@jscrypto/core';\nimport { argon2Preset } from './argon2.js';\nimport { evpKdfPreset } from './evpkdf.js';\nimport { hkdfPreset } from './hkdf.js';\nimport { pbkdf2Preset } from './pbkdf2.js';\nimport { scryptPreset } from './scrypt.js';\n\nexport function classicKdfsPreset(): PresetComponent<'classic-kdfs'> {\n  return {\n    kind: 'preset',\n    name: 'classic-kdfs',\n    components() {\n      return [pbkdf2Preset, evpKdfPreset];\n    },\n  };\n}\n\nexport function kdfsPreset(): PresetComponent<'kdfs'> {\n  return {\n    kind: 'preset',\n    name: 'kdfs',\n    components() {\n      return [classicKdfsPreset(), hkdfPreset, scryptPreset, argon2Preset];\n    },\n  };\n}\n"],"names":["u64.add3L","u64.add3H","u64.rotr32H","u64.rotr32L","u64.add","u64.rotrSH","u64.rotrSL","u64.rotrBH","u64.rotrBL","u64.fromNumL","u64.fromNumH","argon2","nobleArgon2id","nobleArgon2i","nobleArgon2d","assertPositiveInteger","toBytes","concatBytes","hmac","pbkdf2","scrypt","nobleScrypt"],"mappings":"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E,CAAC,EAAE,EAAE,EAAE,CAAC;AACxD,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;AACxD,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;AACxD,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;AACxD,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;AACxD,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC;AACxD,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;AACxD,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE;AACxD,IAAI,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AC;AACrC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,EAAE,CAAC;AACtC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,EAAE,CAAC;AACtC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,CAAC;AACrC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,CAAC;AACrC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,EAAE,CAAC;AACtC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,EAAE,CAAC;AACtC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,CAAC;AACrC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,CAAC;AACrC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,EAAE,CAAC;AACtC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,EAAE,CAAC;AACtC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,CAAC;AACrC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,CAAC;AACrC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,EAAE,CAAC;AACtC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,EAAE,CAAC;AACtC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,CAAC;AACrC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,CAAC;AACrC,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,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","x_google_ignoreList":[0,1,2,3,4,5,11,12,13,14]}