{"version":3,"file":"sha512.min.mjs","sources":["../../node_modules/@noble/hashes/esm/crypto.js","../../node_modules/@noble/hashes/esm/utils.js","../../node_modules/@noble/hashes/esm/_md.js","../../node_modules/@noble/hashes/esm/_u64.js","../../node_modules/@noble/hashes/esm/sha2.js","../../node_modules/@noble/hashes/esm/sha3.js","../../node_modules/@noble/hashes/esm/sha256.js","../../node_modules/@noble/hashes/esm/sha512.js"],"sourcesContent":["export const crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;\n//# sourceMappingURL=crypto.js.map","/**\n * Utilities for hex, bytes, CSPRNG.\n * @module\n */\n/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.\n// node.js versions earlier than v19 don't declare it in global scope.\n// For node.js, package.json#exports field mapping rewrites import\n// from `crypto` to `cryptoNode`, which imports native module.\n// Makes the utils un-importable in browsers without a bundler.\n// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.\nimport { crypto } from '@noble/hashes/crypto';\n/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */\nexport function isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n/** Asserts something is positive integer. */\nexport function anumber(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error('positive integer expected, got ' + n);\n}\n/** Asserts something is Uint8Array. */\nexport function abytes(b, ...lengths) {\n    if (!isBytes(b))\n        throw new Error('Uint8Array expected');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);\n}\n/** Asserts something is hash */\nexport function ahash(h) {\n    if (typeof h !== 'function' || typeof h.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.createHasher');\n    anumber(h.outputLen);\n    anumber(h.blockLen);\n}\n/** Asserts a hash instance has not been destroyed / finished */\nexport function aexists(instance, checkFinished = true) {\n    if (instance.destroyed)\n        throw new Error('Hash instance has been destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('Hash#digest() has already been called');\n}\n/** Asserts output is properly-sized byte array */\nexport function aoutput(out, instance) {\n    abytes(out);\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error('digestInto() expects output buffer of length at least ' + min);\n    }\n}\n/** Cast u8 / u16 / u32 to u8. */\nexport function u8(arr) {\n    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/** Cast u8 / u16 / u32 to u32. */\nexport function u32(arr) {\n    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n/** Zeroize a byte array. Warning: JS provides no guarantees. */\nexport function clean(...arrays) {\n    for (let i = 0; i < arrays.length; i++) {\n        arrays[i].fill(0);\n    }\n}\n/** Create DataView of an array for easy byte-level manipulation. */\nexport function createView(arr) {\n    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/** The rotate right (circular right shift) operation for uint32 */\nexport function rotr(word, shift) {\n    return (word << (32 - shift)) | (word >>> shift);\n}\n/** The rotate left (circular left shift) operation for uint32 */\nexport function rotl(word, shift) {\n    return (word << shift) | ((word >>> (32 - shift)) >>> 0);\n}\n/** Is current platform little-endian? Most are. Big-Endian platform: IBM */\nexport const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n/** The byte swap operation for uint32 */\nexport function byteSwap(word) {\n    return (((word << 24) & 0xff000000) |\n        ((word << 8) & 0xff0000) |\n        ((word >>> 8) & 0xff00) |\n        ((word >>> 24) & 0xff));\n}\n/** Conditionally byte swap if on a big-endian platform */\nexport const swap8IfBE = isLE\n    ? (n) => n\n    : (n) => byteSwap(n);\n/** @deprecated */\nexport const byteSwapIfBE = swap8IfBE;\n/** In place byte swap for Uint32Array */\nexport function byteSwap32(arr) {\n    for (let i = 0; i < arr.length; i++) {\n        arr[i] = byteSwap(arr[i]);\n    }\n    return arr;\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. Uses built-in function, when available.\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\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// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };\nfunction asciiToBase16(ch) {\n    if (ch >= asciis._0 && ch <= asciis._9)\n        return ch - asciis._0; // '2' => 50-48\n    if (ch >= asciis.A && ch <= asciis.F)\n        return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n    if (ch >= asciis.a && ch <= asciis.f)\n        return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n    return;\n}\n/**\n * Convert hex string to byte array. Uses built-in function, when available.\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    // @ts-ignore\n    if (hasHexBuiltin)\n        return Uint8Array.fromHex(hex);\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new Error('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));\n        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n        if (n1 === undefined || n2 === undefined) {\n            const char = hex[hi] + hex[hi + 1];\n            throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n        }\n        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n    }\n    return array;\n}\n/**\n * There is no setImmediate in browser and setTimeout is slow.\n * Call of async fn will return Promise, which will be fullfiled only on\n * next scheduler queue processing step and this is exactly what we need.\n */\nexport const nextTick = async () => { };\n/** Returns control to thread each 'tick' ms to avoid blocking. */\nexport async function asyncLoop(iters, tick, cb) {\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        ts += diff;\n    }\n}\n/**\n * Converts string to bytes using UTF8 encoding.\n * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error('string expected');\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Converts bytes to string using UTF8 encoding.\n * @example bytesToUtf8(Uint8Array.from([97, 98, 99])) // 'abc'\n */\nexport function bytesToUtf8(bytes) {\n    return new TextDecoder().decode(bytes);\n}\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    abytes(data);\n    return data;\n}\n/**\n * Helper for KDFs: consumes uint8array or string.\n * When string is passed, does utf8 decoding, using TextDecoder.\n */\nexport function kdfInputToBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    abytes(data);\n    return data;\n}\n/** Copies several Uint8Arrays into one. */\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}\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')\n        throw new Error('options should be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\n/** For runtime check if class implements interface */\nexport class Hash {\n}\n/** Wraps hash function, creating an interface on top of it */\nexport function createHasher(hashCons) {\n    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();\n    const tmp = hashCons();\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = () => hashCons();\n    return hashC;\n}\nexport function createOptHasher(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport function createXOFer(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport const wrapConstructor = createHasher;\nexport const wrapConstructorWithOpts = createOptHasher;\nexport const wrapXOFConstructorWithOpts = createXOFer;\n/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */\nexport function randomBytes(bytesLength = 32) {\n    if (crypto && typeof crypto.getRandomValues === 'function') {\n        return crypto.getRandomValues(new Uint8Array(bytesLength));\n    }\n    // Legacy Node.js compatibility\n    if (crypto && typeof crypto.randomBytes === 'function') {\n        return Uint8Array.from(crypto.randomBytes(bytesLength));\n    }\n    throw new Error('crypto.getRandomValues must be defined');\n}\n//# sourceMappingURL=utils.js.map","/**\n * Internal Merkle-Damgard hash utils.\n * @module\n */\nimport { Hash, abytes, aexists, aoutput, clean, createView, toBytes } from \"./utils.js\";\n/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */\nexport function setBigUint64(view, byteOffset, value, isLE) {\n    if (typeof view.setBigUint64 === 'function')\n        return view.setBigUint64(byteOffset, value, isLE);\n    const _32n = BigInt(32);\n    const _u32_max = BigInt(0xffffffff);\n    const wh = Number((value >> _32n) & _u32_max);\n    const wl = Number(value & _u32_max);\n    const h = isLE ? 4 : 0;\n    const l = isLE ? 0 : 4;\n    view.setUint32(byteOffset + h, wh, isLE);\n    view.setUint32(byteOffset + l, wl, isLE);\n}\n/** Choice: a ? b : c */\nexport function Chi(a, b, c) {\n    return (a & b) ^ (~a & c);\n}\n/** Majority function, true if any two inputs is true. */\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 */\nexport class HashMD extends Hash {\n    constructor(blockLen, outputLen, padOffset, isLE) {\n        super();\n        this.finished = false;\n        this.length = 0;\n        this.pos = 0;\n        this.destroyed = false;\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        data = toBytes(data);\n        abytes(data);\n        const { view, buffer, blockLen } = this;\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            // Fast path: we have at least one block in input, cast it to view and process\n            if (take === blockLen) {\n                const dataView = createView(data);\n                for (; blockLen <= len - pos; pos += blockLen)\n                    this.process(dataView, pos);\n                continue;\n            }\n            buffer.set(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            }\n        }\n        this.length += data.length;\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\n        buffer[pos++] = 0b10000000;\n        clean(this.buffer.subarray(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            pos = 0;\n        }\n        // Pad until full block byte with zeros\n        for (let i = pos; i < blockLen; i++)\n            buffer[i] = 0;\n        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\n        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.\n        // So we just write lowest 64 bits of that value.\n        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);\n        this.process(view, 0);\n        const oview = createView(out);\n        const len = this.outputLen;\n        // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT\n        if (len % 4)\n            throw new Error('_sha2: outputLen should be aligned to 32bit');\n        const outLen = len / 4;\n        const state = this.get();\n        if (outLen > state.length)\n            throw new Error('_sha2: outputLen bigger than state');\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        const res = buffer.slice(0, outputLen);\n        this.destroy();\n        return res;\n    }\n    _cloneInto(to) {\n        to || (to = new this.constructor());\n        to.set(...this.get());\n        const { blockLen, buffer, length, finished, destroyed, pos } = this;\n        to.destroyed = destroyed;\n        to.finished = finished;\n        to.length = length;\n        to.pos = pos;\n        if (length % blockLen)\n            to.buffer.set(buffer);\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. Bits 0..32 of frac part of sqrt of primes 2..19 */\nexport const SHA256_IV = /* @__PURE__ */ Uint32Array.from([\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,\n]);\n/** Initial SHA224 state. Bits 32..64 of frac part of sqrt of primes 23..53 */\nexport const SHA224_IV = /* @__PURE__ */ Uint32Array.from([\n    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,\n]);\n/** Initial SHA384 state. Bits 0..64 of frac part of sqrt of primes 23..53 */\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. Bits 0..64 of frac part of sqrt of primes 2..19 */\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//# sourceMappingURL=_md.js.map","/**\n * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.\n * @todo re-check https://issues.chromium.org/issues/42212588\n * @module\n */\nconst U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);\nconst _32n = /* @__PURE__ */ BigInt(32);\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}\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}\nconst toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);\n// for Shift in [0, 32)\nconst shrSH = (h, _l, s) => h >>> s;\nconst shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in [1, 32)\nconst rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));\nconst rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));\nconst rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));\n// Right rotate for shift===32 (just swaps l&h)\nconst rotr32H = (_h, l) => l;\nconst rotr32L = (h, _l) => h;\n// Left rotate for Shift in [1, 32)\nconst rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));\nconst rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));\n// Left rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));\nconst rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));\n// JS uses 32-bit signed integers for bitwise operations which means we cannot\n// simple take carry out of low bit sum by shift, we need to 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\nconst add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);\nconst add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;\nconst add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);\nconst add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;\nconst add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);\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, rotlBH, rotlBL, rotlSH, rotlSL, rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL, shrSH, shrSL, split, toBig };\n// prettier-ignore\nconst u64 = {\n    fromBig, split, toBig,\n    shrSH, shrSL,\n    rotrSH, rotrSL, rotrBH, rotrBL,\n    rotr32H, rotr32L,\n    rotlSH, rotlSL, rotlBH, rotlBL,\n    add, add3L, add3H, add4L, add4H, add5H, add5L,\n};\nexport default u64;\n//# sourceMappingURL=_u64.js.map","/**\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 [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and\n * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).\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, rotr } from \"./utils.js\";\n/**\n * Round constants:\n * First 32 bits of fractional parts 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 temporary buffer. \"W\" comes straight from spec. */\nconst SHA256_W = /* @__PURE__ */ new Uint32Array(64);\nexport class SHA256 extends HashMD {\n    constructor(outputLen = 32) {\n        super(64, outputLen, 8, false);\n        // We cannot use array here since array allows indexing by variable\n        // which means optimizer/compiler cannot use registers.\n        this.A = SHA256_IV[0] | 0;\n        this.B = SHA256_IV[1] | 0;\n        this.C = SHA256_IV[2] | 0;\n        this.D = SHA256_IV[3] | 0;\n        this.E = SHA256_IV[4] | 0;\n        this.F = SHA256_IV[5] | 0;\n        this.G = SHA256_IV[6] | 0;\n        this.H = SHA256_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    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        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n        clean(this.buffer);\n    }\n}\nexport class SHA224 extends SHA256 {\n    constructor() {\n        super(28);\n        this.A = SHA224_IV[0] | 0;\n        this.B = SHA224_IV[1] | 0;\n        this.C = SHA224_IV[2] | 0;\n        this.D = SHA224_IV[3] | 0;\n        this.E = SHA224_IV[4] | 0;\n        this.F = SHA224_IV[5] | 0;\n        this.G = SHA224_IV[6] | 0;\n        this.H = SHA224_IV[7] | 0;\n    }\n}\n// SHA2-512 is slower than sha256 in js because u64 operations are slow.\n// Round contants\n// First 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409\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 temporary buffers\nconst SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);\nconst SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);\nexport class SHA512 extends HashMD {\n    constructor(outputLen = 64) {\n        super(128, outputLen, 16, false);\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        this.Ah = SHA512_IV[0] | 0;\n        this.Al = SHA512_IV[1] | 0;\n        this.Bh = SHA512_IV[2] | 0;\n        this.Bl = SHA512_IV[3] | 0;\n        this.Ch = SHA512_IV[4] | 0;\n        this.Cl = SHA512_IV[5] | 0;\n        this.Dh = SHA512_IV[6] | 0;\n        this.Dl = SHA512_IV[7] | 0;\n        this.Eh = SHA512_IV[8] | 0;\n        this.El = SHA512_IV[9] | 0;\n        this.Fh = SHA512_IV[10] | 0;\n        this.Fl = SHA512_IV[11] | 0;\n        this.Gh = SHA512_IV[12] | 0;\n        this.Gl = SHA512_IV[13] | 0;\n        this.Hh = SHA512_IV[14] | 0;\n        this.Hl = SHA512_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    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            // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_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        clean(this.buffer);\n        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n    }\n}\nexport class SHA384 extends SHA512 {\n    constructor() {\n        super(48);\n        this.Ah = SHA384_IV[0] | 0;\n        this.Al = SHA384_IV[1] | 0;\n        this.Bh = SHA384_IV[2] | 0;\n        this.Bl = SHA384_IV[3] | 0;\n        this.Ch = SHA384_IV[4] | 0;\n        this.Cl = SHA384_IV[5] | 0;\n        this.Dh = SHA384_IV[6] | 0;\n        this.Dl = SHA384_IV[7] | 0;\n        this.Eh = SHA384_IV[8] | 0;\n        this.El = SHA384_IV[9] | 0;\n        this.Fh = SHA384_IV[10] | 0;\n        this.Fl = SHA384_IV[11] | 0;\n        this.Gh = SHA384_IV[12] | 0;\n        this.Gl = SHA384_IV[13] | 0;\n        this.Hh = SHA384_IV[14] | 0;\n        this.Hl = SHA384_IV[15] | 0;\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 `test/misc/sha2-gen-iv.js`.\n */\n/** SHA512/224 IV */\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/** SHA512/256 IV */\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]);\nexport class SHA512_224 extends SHA512 {\n    constructor() {\n        super(28);\n        this.Ah = T224_IV[0] | 0;\n        this.Al = T224_IV[1] | 0;\n        this.Bh = T224_IV[2] | 0;\n        this.Bl = T224_IV[3] | 0;\n        this.Ch = T224_IV[4] | 0;\n        this.Cl = T224_IV[5] | 0;\n        this.Dh = T224_IV[6] | 0;\n        this.Dl = T224_IV[7] | 0;\n        this.Eh = T224_IV[8] | 0;\n        this.El = T224_IV[9] | 0;\n        this.Fh = T224_IV[10] | 0;\n        this.Fl = T224_IV[11] | 0;\n        this.Gh = T224_IV[12] | 0;\n        this.Gl = T224_IV[13] | 0;\n        this.Hh = T224_IV[14] | 0;\n        this.Hl = T224_IV[15] | 0;\n    }\n}\nexport class SHA512_256 extends SHA512 {\n    constructor() {\n        super(32);\n        this.Ah = T256_IV[0] | 0;\n        this.Al = T256_IV[1] | 0;\n        this.Bh = T256_IV[2] | 0;\n        this.Bl = T256_IV[3] | 0;\n        this.Ch = T256_IV[4] | 0;\n        this.Cl = T256_IV[5] | 0;\n        this.Dh = T256_IV[6] | 0;\n        this.Dl = T256_IV[7] | 0;\n        this.Eh = T256_IV[8] | 0;\n        this.El = T256_IV[9] | 0;\n        this.Fh = T256_IV[10] | 0;\n        this.Fl = T256_IV[11] | 0;\n        this.Gh = T256_IV[12] | 0;\n        this.Gl = T256_IV[13] | 0;\n        this.Hh = T256_IV[14] | 0;\n        this.Hl = T256_IV[15] | 0;\n    }\n}\n/**\n * SHA2-256 hash function from RFC 4634.\n *\n * It is the fastest JS hash, even faster than Blake3.\n * To break sha256 using birthday attack, attackers need to try 2^128 hashes.\n * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.\n */\nexport const sha256 = /* @__PURE__ */ createHasher(() => new SHA256());\n/** SHA2-224 hash function from RFC 4634 */\nexport const sha224 = /* @__PURE__ */ createHasher(() => new SHA224());\n/** SHA2-512 hash function from RFC 4634. */\nexport const sha512 = /* @__PURE__ */ createHasher(() => new SHA512());\n/** SHA2-384 hash function from RFC 4634. */\nexport const sha384 = /* @__PURE__ */ createHasher(() => new SHA384());\n/**\n * SHA2-512/256 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_256 = /* @__PURE__ */ createHasher(() => new SHA512_256());\n/**\n * SHA2-512/224 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_224 = /* @__PURE__ */ createHasher(() => new SHA512_224());\n//# sourceMappingURL=sha2.js.map","/**\n * SHA3 (keccak) hash function, based on a new \"Sponge function\" design.\n * Different from older hashes, the internal state is bigger than output size.\n *\n * Check out [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),\n * [Website](https://keccak.team/keccak.html),\n * [the differences between SHA-3 and Keccak](https://crypto.stackexchange.com/questions/15727/what-are-the-key-differences-between-the-draft-sha-3-standard-and-the-keccak-sub).\n *\n * Check out `sha3-addons` module for cSHAKE, k12, and others.\n * @module\n */\nimport { rotlBH, rotlBL, rotlSH, rotlSL, split } from \"./_u64.js\";\n// prettier-ignore\nimport { abytes, aexists, anumber, aoutput, clean, createHasher, createXOFer, Hash, swap32IfBE, toBytes, u32 } from \"./utils.js\";\n// No __PURE__ annotations in sha3 header:\n// EVERYTHING is in fact used on every export.\n// Various per round constants calculations\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nconst _2n = BigInt(2);\nconst _7n = BigInt(7);\nconst _256n = BigInt(256);\nconst _0x71n = BigInt(0x71);\nconst SHA3_PI = [];\nconst SHA3_ROTL = [];\nconst _SHA3_IOTA = [];\nfor (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {\n    // Pi\n    [x, y] = [y, (2 * x + 3 * y) % 5];\n    SHA3_PI.push(2 * (5 * y + x));\n    // Rotational\n    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);\n    // Iota\n    let t = _0n;\n    for (let j = 0; j < 7; j++) {\n        R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;\n        if (R & _2n)\n            t ^= _1n << ((_1n << /* @__PURE__ */ BigInt(j)) - _1n);\n    }\n    _SHA3_IOTA.push(t);\n}\nconst IOTAS = split(_SHA3_IOTA, true);\nconst SHA3_IOTA_H = IOTAS[0];\nconst SHA3_IOTA_L = IOTAS[1];\n// Left rotation (without 0, 32, 64)\nconst rotlH = (h, l, s) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));\nconst rotlL = (h, l, s) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));\n/** `keccakf1600` internal function, additionally allows to adjust round count. */\nexport function keccakP(s, rounds = 24) {\n    const B = new Uint32Array(5 * 2);\n    // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)\n    for (let round = 24 - rounds; round < 24; round++) {\n        // Theta θ\n        for (let x = 0; x < 10; x++)\n            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];\n        for (let x = 0; x < 10; x += 2) {\n            const idx1 = (x + 8) % 10;\n            const idx0 = (x + 2) % 10;\n            const B0 = B[idx0];\n            const B1 = B[idx0 + 1];\n            const Th = rotlH(B0, B1, 1) ^ B[idx1];\n            const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];\n            for (let y = 0; y < 50; y += 10) {\n                s[x + y] ^= Th;\n                s[x + y + 1] ^= Tl;\n            }\n        }\n        // Rho (ρ) and Pi (π)\n        let curH = s[2];\n        let curL = s[3];\n        for (let t = 0; t < 24; t++) {\n            const shift = SHA3_ROTL[t];\n            const Th = rotlH(curH, curL, shift);\n            const Tl = rotlL(curH, curL, shift);\n            const PI = SHA3_PI[t];\n            curH = s[PI];\n            curL = s[PI + 1];\n            s[PI] = Th;\n            s[PI + 1] = Tl;\n        }\n        // Chi (χ)\n        for (let y = 0; y < 50; y += 10) {\n            for (let x = 0; x < 10; x++)\n                B[x] = s[y + x];\n            for (let x = 0; x < 10; x++)\n                s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];\n        }\n        // Iota (ι)\n        s[0] ^= SHA3_IOTA_H[round];\n        s[1] ^= SHA3_IOTA_L[round];\n    }\n    clean(B);\n}\n/** Keccak sponge function. */\nexport class Keccak extends Hash {\n    // NOTE: we accept arguments in bytes instead of bits here.\n    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {\n        super();\n        this.pos = 0;\n        this.posOut = 0;\n        this.finished = false;\n        this.destroyed = false;\n        this.enableXOF = false;\n        this.blockLen = blockLen;\n        this.suffix = suffix;\n        this.outputLen = outputLen;\n        this.enableXOF = enableXOF;\n        this.rounds = rounds;\n        // Can be passed from user as dkLen\n        anumber(outputLen);\n        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes\n        // 0 < blockLen < 200\n        if (!(0 < blockLen && blockLen < 200))\n            throw new Error('only keccak-f1600 function is supported');\n        this.state = new Uint8Array(200);\n        this.state32 = u32(this.state);\n    }\n    clone() {\n        return this._cloneInto();\n    }\n    keccak() {\n        swap32IfBE(this.state32);\n        keccakP(this.state32, this.rounds);\n        swap32IfBE(this.state32);\n        this.posOut = 0;\n        this.pos = 0;\n    }\n    update(data) {\n        aexists(this);\n        data = toBytes(data);\n        abytes(data);\n        const { blockLen, state } = this;\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            for (let i = 0; i < take; i++)\n                state[this.pos++] ^= data[pos++];\n            if (this.pos === blockLen)\n                this.keccak();\n        }\n        return this;\n    }\n    finish() {\n        if (this.finished)\n            return;\n        this.finished = true;\n        const { state, suffix, pos, blockLen } = this;\n        // Do the padding\n        state[pos] ^= suffix;\n        if ((suffix & 0x80) !== 0 && pos === blockLen - 1)\n            this.keccak();\n        state[blockLen - 1] ^= 0x80;\n        this.keccak();\n    }\n    writeInto(out) {\n        aexists(this, false);\n        abytes(out);\n        this.finish();\n        const bufferOut = this.state;\n        const { blockLen } = this;\n        for (let pos = 0, len = out.length; pos < len;) {\n            if (this.posOut >= blockLen)\n                this.keccak();\n            const take = Math.min(blockLen - this.posOut, len - pos);\n            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);\n            this.posOut += take;\n            pos += take;\n        }\n        return out;\n    }\n    xofInto(out) {\n        // Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF\n        if (!this.enableXOF)\n            throw new Error('XOF is not possible for this instance');\n        return this.writeInto(out);\n    }\n    xof(bytes) {\n        anumber(bytes);\n        return this.xofInto(new Uint8Array(bytes));\n    }\n    digestInto(out) {\n        aoutput(out, this);\n        if (this.finished)\n            throw new Error('digest() was already called');\n        this.writeInto(out);\n        this.destroy();\n        return out;\n    }\n    digest() {\n        return this.digestInto(new Uint8Array(this.outputLen));\n    }\n    destroy() {\n        this.destroyed = true;\n        clean(this.state);\n    }\n    _cloneInto(to) {\n        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;\n        to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));\n        to.state32.set(this.state32);\n        to.pos = this.pos;\n        to.posOut = this.posOut;\n        to.finished = this.finished;\n        to.rounds = rounds;\n        // Suffix can change in cSHAKE\n        to.suffix = suffix;\n        to.outputLen = outputLen;\n        to.enableXOF = enableXOF;\n        to.destroyed = this.destroyed;\n        return to;\n    }\n}\nconst gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));\n/** SHA3-224 hash function. */\nexport const sha3_224 = /* @__PURE__ */ (() => gen(0x06, 144, 224 / 8))();\n/** SHA3-256 hash function. Different from keccak-256. */\nexport const sha3_256 = /* @__PURE__ */ (() => gen(0x06, 136, 256 / 8))();\n/** SHA3-384 hash function. */\nexport const sha3_384 = /* @__PURE__ */ (() => gen(0x06, 104, 384 / 8))();\n/** SHA3-512 hash function. */\nexport const sha3_512 = /* @__PURE__ */ (() => gen(0x06, 72, 512 / 8))();\n/** keccak-224 hash function. */\nexport const keccak_224 = /* @__PURE__ */ (() => gen(0x01, 144, 224 / 8))();\n/** keccak-256 hash function. Different from SHA3-256. */\nexport const keccak_256 = /* @__PURE__ */ (() => gen(0x01, 136, 256 / 8))();\n/** keccak-384 hash function. */\nexport const keccak_384 = /* @__PURE__ */ (() => gen(0x01, 104, 384 / 8))();\n/** keccak-512 hash function. */\nexport const keccak_512 = /* @__PURE__ */ (() => gen(0x01, 72, 512 / 8))();\nconst genShake = (suffix, blockLen, outputLen) => createXOFer((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true));\n/** SHAKE128 XOF with 128-bit security. */\nexport const shake128 = /* @__PURE__ */ (() => genShake(0x1f, 168, 128 / 8))();\n/** SHAKE256 XOF with 256-bit security. */\nexport const shake256 = /* @__PURE__ */ (() => genShake(0x1f, 136, 256 / 8))();\n//# sourceMappingURL=sha3.js.map","/**\n * SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.\n *\n * To break sha256 using birthday attack, attackers need to try 2^128 hashes.\n * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.\n *\n * Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).\n * @module\n * @deprecated\n */\nimport { SHA224 as SHA224n, sha224 as sha224n, SHA256 as SHA256n, sha256 as sha256n, } from \"./sha2.js\";\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const SHA256 = SHA256n;\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const sha256 = sha256n;\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const SHA224 = SHA224n;\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const sha224 = sha224n;\n//# sourceMappingURL=sha256.js.map","/**\n * SHA2-512 a.k.a. sha512 and sha384. It is slower than sha256 in js because u64 operations are slow.\n *\n * Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and\n * [the paper on truncated SHA512/256](https://eprint.iacr.org/2010/548.pdf).\n * @module\n * @deprecated\n */\nimport { SHA384 as SHA384n, sha384 as sha384n, sha512_224 as sha512_224n, SHA512_224 as SHA512_224n, sha512_256 as sha512_256n, SHA512_256 as SHA512_256n, SHA512 as SHA512n, sha512 as sha512n, } from \"./sha2.js\";\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const SHA512 = SHA512n;\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const sha512 = sha512n;\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const SHA384 = SHA384n;\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const sha384 = sha384n;\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const SHA512_224 = SHA512_224n;\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const sha512_224 = sha512_224n;\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const SHA512_256 = SHA512_256n;\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const sha512_256 = sha512_256n;\n//# sourceMappingURL=sha512.js.map"],"names":["crypto","globalThis","undefined","isBytes","a","Uint8Array","ArrayBuffer","isView","constructor","name","anumber","n","Number","isSafeInteger","Error","abytes","b","lengths","length","includes","ahash","h","create","outputLen","blockLen","aexists","instance","checkFinished","destroyed","finished","aoutput","out","min","clean","arrays","i","fill","createView","arr","DataView","buffer","byteOffset","byteLength","rotr","word","shift","rotl","swap32IfBE","Uint32Array","u","hasHexBuiltin","from","toHex","fromHex","hexes","Array","_","toString","padStart","bytesToHex","bytes","hex","asciis","asciiToBase16","ch","hexToBytes","hl","al","array","ai","hi","n1","charCodeAt","n2","char","toBytes","data","str","TextEncoder","encode","utf8ToBytes","concatBytes","sum","res","pad","set","Hash","createHasher","hashCons","hashC","msg","update","digest","tmp","wrapConstructor","randomBytes","bytesLength","getRandomValues","Chi","c","Maj","HashMD","padOffset","isLE","super","this","pos","view","len","take","Math","subarray","process","dataView","roundClean","digestInto","value","setBigUint64","_32n","BigInt","_u32_max","wh","wl","l","setUint32","oview","outLen","state","get","slice","destroy","_cloneInto","to","clone","SHA256_IV","SHA224_IV","SHA384_IV","SHA512_IV","U32_MASK64","fromBig","le","split","lst","Ah","Al","shrSH","_l","s","shrSL","rotrSH","rotrSL","rotrBH","rotrBL","add","Bh","Bl","add3L","Cl","add3H","low","Ch","add4L","Dl","add4H","Dh","add5L","El","add5H","Eh","SHA256_K","SHA256_W","SHA256","A","B","C","D","E","F","G","H","offset","getUint32","W15","W2","s0","s1","T1","T2","SHA224","K512","u64.split","map","SHA512_Kh","SHA512_Kl","SHA512_W_H","SHA512_W_L","SHA512","Fh","Fl","Gh","Gl","Hh","Hl","W15h","W15l","s0h","u64.rotrSH","u64.shrSH","s0l","u64.rotrSL","u64.shrSL","W2h","W2l","s1h","u64.rotrBH","s1l","u64.rotrBL","SUMl","u64.add4L","SUMh","u64.add4H","sigma1h","sigma1l","CHIh","T1ll","u64.add5L","T1h","u64.add5H","T1l","sigma0h","sigma0l","MAJh","MAJl","u64.add","All","u64.add3L","u64.add3H","SHA384","sha256","sha224","sha512","sha384","_0n","_1n","_2n","_7n","_256n","_0x71n","SHA3_PI","SHA3_ROTL","_SHA3_IOTA","round","R","x","y","push","t","j","IOTAS","SHA3_IOTA_H","SHA3_IOTA_L","rotlH","rotlBH","rotlSH","rotlL","rotlBL","rotlSL","Keccak","suffix","enableXOF","rounds","posOut","state32","floor","keccak","idx1","idx0","B0","B1","Th","Tl","curH","curL","PI","keccakP","finish","writeInto","bufferOut","xofInto","xof","gen","sha3_256","sha3_512","genShake","opts","createXOFer","dkLen","shake256","sha256n","sha224n","sha512n","sha384n"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7]}