{"version":3,"file":"sha3-CSc33ASA.js","sources":["../../node_modules/@noble/hashes/esm/_assert.js","../../node_modules/@noble/hashes/esm/_u64.js","../../node_modules/@noble/hashes/esm/crypto.js","../../node_modules/@noble/hashes/esm/utils.js","../../node_modules/@noble/hashes/esm/sha3.js"],"sourcesContent":["/**\n * Internal assertion helpers.\n * @module\n */\n/** Asserts something is positive integer. */\nfunction anumber(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error('positive integer expected, got ' + n);\n}\n/** Is number an Uint8Array? Copied from utils for perf. */\nfunction isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n/** Asserts something is Uint8Array. */\nfunction 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 */\nfunction ahash(h) {\n    if (typeof h !== 'function' || typeof h.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.wrapConstructor');\n    anumber(h.outputLen);\n    anumber(h.blockLen);\n}\n/** Asserts a hash instance has not been destroyed / finished */\nfunction 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 */\nfunction 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}\nexport { anumber, abytes, ahash, aexists, aoutput };\n//# sourceMappingURL=_assert.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    let Ah = new Uint32Array(lst.length);\n    let Al = new Uint32Array(lst.length);\n    for (let i = 0; i < lst.length; 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 { fromBig, split, toBig, shrSH, shrSL, rotrSH, rotrSL, rotrBH, rotrBL, rotr32H, rotr32L, rotlSH, rotlSL, rotlBH, rotlBL, add, add3L, add3H, add4L, add4H, add5H, add5L, };\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","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';\nimport { abytes } from './_assert.js';\n// export { isBytes } from './_assert.js';\n// We can't reuse isBytes from _assert, because somehow this causes huge perf issues\nexport function isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n// Cast array to different type\nexport function u8(arr) {\n    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\nexport function u32(arr) {\n    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n// Cast array to view\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 byteSwapIfBE = isLE\n    ? (n) => n\n    : (n) => byteSwap(n);\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}\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 * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    abytes(bytes);\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.\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    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 * Convert JS string to byte array.\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error('utf8ToBytes expected string, got ' + typeof str);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\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 * Copies several Uint8Arrays into one.\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/** For runtime check if class implements interface */\nexport class Hash {\n    // Safe version that clones internal state\n    clone() {\n        return this._cloneInto();\n    }\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/** Wraps hash function, creating an interface on top of it */\nexport function wrapConstructor(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 wrapConstructorWithOpts(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 wrapXOFConstructorWithOpts(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}\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 crypto.randomBytes(bytesLength);\n    }\n    throw new Error('crypto.getRandomValues must be defined');\n}\n//# sourceMappingURL=utils.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 { abytes, aexists, anumber, aoutput } from './_assert.js';\nimport { rotlBH, rotlBL, rotlSH, rotlSL, split } from './_u64.js';\nimport { byteSwap32, Hash, isLE, toBytes, u32, wrapConstructor, wrapXOFConstructorWithOpts, } from './utils.js';\n// Various per round constants calculations\nconst SHA3_PI = [];\nconst SHA3_ROTL = [];\nconst _SHA3_IOTA = [];\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nconst _2n = /* @__PURE__ */ BigInt(2);\nconst _7n = /* @__PURE__ */ BigInt(7);\nconst _256n = /* @__PURE__ */ BigInt(256);\nconst _0x71n = /* @__PURE__ */ BigInt(0x71);\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 [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);\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    B.fill(0);\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.blockLen = blockLen;\n        this.suffix = suffix;\n        this.outputLen = outputLen;\n        this.enableXOF = enableXOF;\n        this.rounds = rounds;\n        this.pos = 0;\n        this.posOut = 0;\n        this.finished = false;\n        this.destroyed = false;\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 >= this.blockLen || this.blockLen >= 200)\n            throw new Error('Sha3 supports only keccak-f1600 function');\n        this.state = new Uint8Array(200);\n        this.state32 = u32(this.state);\n    }\n    keccak() {\n        if (!isLE)\n            byteSwap32(this.state32);\n        keccakP(this.state32, this.rounds);\n        if (!isLE)\n            byteSwap32(this.state32);\n        this.posOut = 0;\n        this.pos = 0;\n    }\n    update(data) {\n        aexists(this);\n        const { blockLen, state } = this;\n        data = toBytes(data);\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        this.state.fill(0);\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) => wrapConstructor(() => 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) => wrapXOFConstructorWithOpts((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"],"names":["e","n","anumber","isBytes","a","abytes","b","lengths","ahash","h","aexists","instance","checkFinished","aoutput","out","min","U32_MASK64","_32n","fromBig","le","split","lst","Ah","Al","i","l","rotlSH","s","rotlSL","rotlBH","rotlBL","crypto","u32","arr","createView","rotr","word","shift","isLE","byteSwap","byteSwap32","hexes","_","bytesToHex","bytes","hex","utf8ToBytes","str","toBytes","data","concatBytes","arrays","sum","res","pad","Hash","wrapConstructor","hashCons","hashC","msg","tmp","wrapXOFConstructorWithOpts","opts","randomBytes","bytesLength","SHA3_PI","SHA3_ROTL","_SHA3_IOTA","_0n","_1n","_2n","_7n","_256n","_0x71n","round","R","x","y","t","j","SHA3_IOTA_H","SHA3_IOTA_L","rotlH","rotlL","keccakP","rounds","B","idx1","idx0","B0","B1","Th","Tl","curH","curL","PI","Keccak","blockLen","suffix","outputLen","enableXOF","state","len","pos","take","bufferOut","to","gen","sha3_224","sha3_256","sha3_384","sha3_512","keccak_224","keccak_256","keccak_384","keccak_512","genShake","shake128","shake256"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4]}