@protontech/openpgp 6.1.1-patch.4 → 6.2.1

package/dist/lightweight/noble_post_quantum.min.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"noble_post_quantum.min.mjs","sources":["../../node_modules/@noble/post-quantum/esm/utils.js","../../node_modules/@noble/post-quantum/esm/_crystals.js","../../node_modules/@noble/post-quantum/esm/ml-kem.js","../../node_modules/@noble/post-quantum/esm/ml-dsa.js"],"sourcesContent":["/*! noble-post-quantum - MIT License (c) 2024 Paul Miller (paulmillr.com) */\nimport { bytes as abytes } from '@noble/hashes/_assert';\nimport { randomBytes as randb, concatBytes } from '@noble/hashes/utils';\nexport const ensureBytes = abytes;\nexport const randomBytes = randb;\nexport { concatBytes };\n// Compares 2 u8a-s in kinda constant time\nexport function equalBytes(a, b) {\n    if (a.length !== b.length)\n        return false;\n    let diff = 0;\n    for (let i = 0; i < a.length; i++)\n        diff |= a[i] ^ b[i];\n    return diff === 0;\n}\nexport function splitCoder(...lengths) {\n    const getLength = (c) => (typeof c === 'number' ? c : c.bytesLen);\n    const bytesLen = lengths.reduce((sum, a) => sum + getLength(a), 0);\n    return {\n        bytesLen,\n        encode: (bufs) => {\n            const res = new Uint8Array(bytesLen);\n            for (let i = 0, pos = 0; i < lengths.length; i++) {\n                const c = lengths[i];\n                const l = getLength(c);\n                const b = typeof c === 'number' ? bufs[i] : c.encode(bufs[i]);\n                ensureBytes(b, l);\n                res.set(b, pos);\n                if (typeof c !== 'number')\n                    b.fill(0); // clean\n                pos += l;\n            }\n            return res;\n        },\n        decode: (buf) => {\n            ensureBytes(buf, bytesLen);\n            const res = [];\n            for (const c of lengths) {\n                const l = getLength(c);\n                const b = buf.subarray(0, l);\n                res.push(typeof c === 'number' ? b : c.decode(b));\n                buf = buf.subarray(l);\n            }\n            return res;\n        },\n    };\n}\n// nano-packed.array (fixed size)\nexport function vecCoder(c, vecLen) {\n    const bytesLen = vecLen * c.bytesLen;\n    return {\n        bytesLen,\n        encode: (u) => {\n            if (u.length !== vecLen)\n                throw new Error(`vecCoder.encode: wrong length=${u.length}. Expected: ${vecLen}`);\n            const res = new Uint8Array(bytesLen);\n            for (let i = 0, pos = 0; i < u.length; i++) {\n                const b = c.encode(u[i]);\n                res.set(b, pos);\n                b.fill(0); // clean\n                pos += b.length;\n            }\n            return res;\n        },\n        decode: (a) => {\n            ensureBytes(a, bytesLen);\n            const r = [];\n            for (let i = 0; i < a.length; i += c.bytesLen)\n                r.push(c.decode(a.subarray(i, i + c.bytesLen)));\n            return r;\n        },\n    };\n}\n// cleanBytes(new Uint8Array(), [new Uint16Array(), new Uint32Array()])\nexport function cleanBytes(...list) {\n    for (const t of list) {\n        if (Array.isArray(t))\n            for (const b of t)\n                b.fill(0);\n        else\n            t.fill(0);\n    }\n}\nexport function getMask(bits) {\n    return (1 << bits) - 1; // 4 -> 0b1111\n}\n//# sourceMappingURL=utils.js.map","/*! noble-post-quantum - MIT License (c) 2024 Paul Miller (paulmillr.com) */\nimport { shake128, shake256 } from '@noble/hashes/sha3';\nimport { getMask } from './utils.js';\n// TODO: benchmark\nfunction bitReversal(n, bits = 8) {\n    const padded = n.toString(2).padStart(8, '0');\n    const sliced = padded.slice(-bits).padStart(7, '0');\n    const revrsd = sliced.split('').reverse().join('');\n    return Number.parseInt(revrsd, 2);\n}\nexport const genCrystals = (opts) => {\n    // isKyber: true means Kyber, false means Dilithium\n    const { newPoly, N, Q, F, ROOT_OF_UNITY, brvBits, isKyber } = opts;\n    const mod = (a, modulo = Q) => {\n        const result = a % modulo | 0;\n        return (result >= 0 ? result | 0 : (modulo + result) | 0) | 0;\n    };\n    // -(Q-1)/2 < a <= (Q-1)/2\n    const smod = (a, modulo = Q) => {\n        const r = mod(a, modulo) | 0;\n        return (r > modulo >> 1 ? (r - modulo) | 0 : r) | 0;\n    };\n    // Generate zettas\n    function getZettas() {\n        const out = newPoly(N);\n        for (let i = 0; i < N; i++) {\n            const b = bitReversal(i, brvBits);\n            const p = BigInt(ROOT_OF_UNITY) ** BigInt(b) % BigInt(Q);\n            out[i] = Number(p) | 0;\n        }\n        return out;\n    }\n    const nttZetas = getZettas();\n    // Number-Theoretic Transform\n    // Explained: https://electricdusk.com/ntt.html\n    // Kyber has slightly different params, since there is no 512th primitive root of unity mod q,\n    // only 256th primitive root of unity mod. Which also complicates MultiplyNTT.\n    // TODO: there should be less ugly way to define this.\n    const LEN1 = isKyber ? 128 : N;\n    const LEN2 = isKyber ? 1 : 0;\n    const NTT = {\n        encode: (r) => {\n            for (let k = 1, len = 128; len > LEN2; len >>= 1) {\n                for (let start = 0; start < N; start += 2 * len) {\n                    const zeta = nttZetas[k++];\n                    for (let j = start; j < start + len; j++) {\n                        const t = mod(zeta * r[j + len]);\n                        r[j + len] = mod(r[j] - t) | 0;\n                        r[j] = mod(r[j] + t) | 0;\n                    }\n                }\n            }\n            return r;\n        },\n        decode: (r) => {\n            for (let k = LEN1 - 1, len = 1 + LEN2; len < LEN1 + LEN2; len <<= 1) {\n                for (let start = 0; start < N; start += 2 * len) {\n                    const zeta = nttZetas[k--];\n                    for (let j = start; j < start + len; j++) {\n                        const t = r[j];\n                        r[j] = mod(t + r[j + len]);\n                        r[j + len] = mod(zeta * (r[j + len] - t));\n                    }\n                }\n            }\n            for (let i = 0; i < r.length; i++)\n                r[i] = mod(F * r[i]);\n            return r;\n        },\n    };\n    // Encode polynominal as bits\n    const bitsCoder = (d, c) => {\n        const mask = getMask(d);\n        const bytesLen = d * (N / 8);\n        return {\n            bytesLen,\n            encode: (poly) => {\n                const r = new Uint8Array(bytesLen);\n                for (let i = 0, buf = 0, bufLen = 0, pos = 0; i < poly.length; i++) {\n                    buf |= (c.encode(poly[i]) & mask) << bufLen;\n                    bufLen += d;\n                    for (; bufLen >= 8; bufLen -= 8, buf >>= 8)\n                        r[pos++] = buf & getMask(bufLen);\n                }\n                return r;\n            },\n            decode: (bytes) => {\n                const r = newPoly(N);\n                for (let i = 0, buf = 0, bufLen = 0, pos = 0; i < bytes.length; i++) {\n                    buf |= bytes[i] << bufLen;\n                    bufLen += 8;\n                    for (; bufLen >= d; bufLen -= d, buf >>= d)\n                        r[pos++] = c.decode(buf & mask);\n                }\n                return r;\n            },\n        };\n    };\n    return { mod, smod, nttZetas, NTT, bitsCoder };\n};\nconst createXofShake = (shake) => (seed, blockLen) => {\n    if (!blockLen)\n        blockLen = shake.blockLen;\n    // Optimizations that won't mater:\n    // - cached seed update (two .update(), on start and on the end)\n    // - another cache which cloned into working copy\n    // Faster than multiple updates, since seed less than blockLen\n    const _seed = new Uint8Array(seed.length + 2);\n    _seed.set(seed);\n    const seedLen = seed.length;\n    const buf = new Uint8Array(blockLen); // == shake128.blockLen\n    let h = shake.create({});\n    let calls = 0;\n    let xofs = 0;\n    return {\n        stats: () => ({ calls, xofs }),\n        get: (x, y) => {\n            _seed[seedLen + 0] = x;\n            _seed[seedLen + 1] = y;\n            h.destroy();\n            h = shake.create({}).update(_seed);\n            calls++;\n            return () => {\n                xofs++;\n                return h.xofInto(buf);\n            };\n        },\n        clean: () => {\n            h.destroy();\n            buf.fill(0);\n            _seed.fill(0);\n        },\n    };\n};\nexport const XOF128 = /* @__PURE__ */ createXofShake(shake128);\nexport const XOF256 = /* @__PURE__ */ createXofShake(shake256);\n//# sourceMappingURL=_crystals.js.map","/*! noble-post-quantum - MIT License (c) 2024 Paul Miller (paulmillr.com) */\nimport { sha3_256, sha3_512, shake256 } from '@noble/hashes/sha3';\nimport { u32 } from '@noble/hashes/utils';\nimport { genCrystals, XOF128 } from './_crystals.js';\nimport { cleanBytes, ensureBytes, equalBytes, randomBytes, splitCoder, vecCoder, } from './utils.js';\n/*\nLattice-based key encapsulation mechanism.\nSee [official site](https://www.pq-crystals.org/kyber/resources.shtml),\n[repo](https://github.com/pq-crystals/kyber),\n[spec](https://datatracker.ietf.org/doc/draft-cfrg-schwabe-kyber/).\n\nKey encapsulation is similar to DH / ECDH (think X25519), with important differences:\n\n- We can't verify if it was \"Bob\" who've sent the shared secret.\n  In ECDH, it's always verified\n- Kyber is probabalistic and relies on quality of randomness (CSPRNG).\n  ECDH doesn't (to this extent).\n- Kyber decapsulation never throws an error, even when shared secret was\n  encrypted by a different public key. It will just return a different\n  shared secret\n\nThere are some concerns with regards to security: see\n[djb blog](https://blog.cr.yp.to/20231003-countcorrectly.html) and\n[mailing list](https://groups.google.com/a/list.nist.gov/g/pqc-forum/c/W2VOzy0wz_E).\n\n*/\nconst N = 256; // Kyber (not FIPS-203) supports different lengths, but all std modes were using 256\nconst Q = 3329; // 13*(2**8)+1, modulo prime\nconst F = 3303; // 3303 ≡ 128**(−1) mod q (FIPS-203)\nconst ROOT_OF_UNITY = 17; // ζ = 17 ∈ Zq is a primitive 256-th root of unity modulo Q. ζ**128 ≡−1\nconst { mod, nttZetas, NTT, bitsCoder } = genCrystals({\n    N,\n    Q,\n    F,\n    ROOT_OF_UNITY,\n    newPoly: (n) => new Uint16Array(n),\n    brvBits: 7,\n    isKyber: true,\n});\n// prettier-ignore\nexport const PARAMS = {\n    512: { N, Q, K: 2, ETA1: 3, ETA2: 2, du: 10, dv: 4, RBGstrength: 128 },\n    768: { N, Q, K: 3, ETA1: 2, ETA2: 2, du: 10, dv: 4, RBGstrength: 192 },\n    1024: { N, Q, K: 4, ETA1: 2, ETA2: 2, du: 11, dv: 5, RBGstrength: 256 },\n};\n// FIPS-203: compress/decompress\nconst compress = (d) => {\n    // Special case, no need to compress, pass as is, but strip high bytes on compression\n    if (d >= 12)\n        return { encode: (i) => i, decode: (i) => i };\n    // NOTE: we don't use float arithmetic (forbidden by FIPS-203 and high chance of bugs).\n    // Comments map to python implementation in RFC (draft-cfrg-schwabe-kyber)\n    // const round = (i: number) => Math.floor(i + 0.5) | 0;\n    const a = 2 ** (d - 1);\n    return {\n        // const compress = (i: number) => round((2 ** d / Q) * i) % 2 ** d;\n        encode: (i) => ((i << d) + Q / 2) / Q,\n        // const decompress = (i: number) => round((Q / 2 ** d) * i);\n        decode: (i) => (i * Q + a) >>> d,\n    };\n};\n// NOTE: we merge encoding and compress because it is faster, also both require same d param\n// Converts between bytes and d-bits compressed representation. Kinda like convertRadix2 from @scure/base\n// decode(encode(t)) == t, but there is loss of information on encode(decode(t))\nconst polyCoder = (d) => bitsCoder(d, compress(d));\nfunction polyAdd(a, b) {\n    for (let i = 0; i < N; i++)\n        a[i] = mod(a[i] + b[i]); // a += b\n}\nfunction polySub(a, b) {\n    for (let i = 0; i < N; i++)\n        a[i] = mod(a[i] - b[i]); // a -= b\n}\n// FIPS-203: Computes the product of two degree-one polynomials with respect to a quadratic modulus\nfunction BaseCaseMultiply(a0, a1, b0, b1, zeta) {\n    const c0 = mod(a1 * b1 * zeta + a0 * b0);\n    const c1 = mod(a0 * b1 + a1 * b0);\n    return { c0, c1 };\n}\n// FIPS-203: Computes the product (in the ring Tq) of two NTT representations. NOTE: works inplace for f\n// NOTE: since multiply defined only for NTT representation, we need to convert to NTT, multiply and convert back\nfunction MultiplyNTTs(f, g) {\n    for (let i = 0; i < N / 2; i++) {\n        let z = nttZetas[64 + (i >> 1)];\n        if (i & 1)\n            z = -z;\n        const { c0, c1 } = BaseCaseMultiply(f[2 * i + 0], f[2 * i + 1], g[2 * i + 0], g[2 * i + 1], z);\n        f[2 * i + 0] = c0;\n        f[2 * i + 1] = c1;\n    }\n    return f;\n}\n// Return poly in NTT representation\nfunction SampleNTT(xof) {\n    const r = new Uint16Array(N);\n    for (let j = 0; j < N;) {\n        const b = xof();\n        if (b.length % 3)\n            throw new Error('SampleNTT: unaligned block');\n        for (let i = 0; j < N && i + 3 <= b.length; i += 3) {\n            const d1 = ((b[i + 0] >> 0) | (b[i + 1] << 8)) & 0xfff;\n            const d2 = ((b[i + 1] >> 4) | (b[i + 2] << 4)) & 0xfff;\n            if (d1 < Q)\n                r[j++] = d1;\n            if (j < N && d2 < Q)\n                r[j++] = d2;\n        }\n    }\n    return r;\n}\n// Sampling from the centered binomial distribution\n// Returns poly with small coefficients (noise/errors)\nfunction sampleCBD(PRF, seed, nonce, eta) {\n    const buf = PRF((eta * N) / 4, seed, nonce);\n    const r = new Uint16Array(N);\n    const b32 = u32(buf);\n    let len = 0;\n    for (let i = 0, p = 0, bb = 0, t0 = 0; i < b32.length; i++) {\n        let b = b32[i];\n        for (let j = 0; j < 32; j++) {\n            bb += b & 1;\n            b >>= 1;\n            len += 1;\n            if (len === eta) {\n                t0 = bb;\n                bb = 0;\n            }\n            else if (len === 2 * eta) {\n                r[p++] = mod(t0 - bb);\n                bb = 0;\n                len = 0;\n            }\n        }\n    }\n    if (len)\n        throw new Error(`sampleCBD: leftover bits: ${len}`);\n    return r;\n}\n// K-PKE\n// As per FIPS-203, it doesn't perform any input validation and can't be used in standalone fashion.\nconst genKPKE = (opts) => {\n    const { K, PRF, XOF, HASH512, ETA1, ETA2, du, dv } = opts;\n    const poly1 = polyCoder(1);\n    const polyV = polyCoder(dv);\n    const polyU = polyCoder(du);\n    const publicCoder = splitCoder(vecCoder(polyCoder(12), K), 32);\n    const secretCoder = vecCoder(polyCoder(12), K);\n    const cipherCoder = splitCoder(vecCoder(polyU, K), polyV);\n    const seedCoder = splitCoder(32, 32);\n    return {\n        secretCoder,\n        secretKeyLen: secretCoder.bytesLen,\n        publicKeyLen: publicCoder.bytesLen,\n        cipherTextLen: cipherCoder.bytesLen,\n        keygen: (seed) => {\n            const seedDst = new Uint8Array(33);\n            seedDst.set(seed);\n            seedDst[32] = K;\n            const seedHash = HASH512(seedDst);\n            const [rho, sigma] = seedCoder.decode(seedHash);\n            const sHat = [];\n            const tHat = [];\n            for (let i = 0; i < K; i++)\n                sHat.push(NTT.encode(sampleCBD(PRF, sigma, i, ETA1)));\n            const x = XOF(rho);\n            for (let i = 0; i < K; i++) {\n                const e = NTT.encode(sampleCBD(PRF, sigma, K + i, ETA1));\n                for (let j = 0; j < K; j++) {\n                    const aji = SampleNTT(x.get(j, i)); // A[j][i], inplace\n                    polyAdd(e, MultiplyNTTs(aji, sHat[j]));\n                }\n                tHat.push(e); // t ← A ◦ s + e\n            }\n            x.clean();\n            const res = {\n                publicKey: publicCoder.encode([tHat, rho]),\n                secretKey: secretCoder.encode(sHat),\n            };\n            cleanBytes(rho, sigma, sHat, tHat, seedDst, seedHash);\n            return res;\n        },\n        encrypt: (publicKey, msg, seed) => {\n            const [tHat, rho] = publicCoder.decode(publicKey);\n            const rHat = [];\n            for (let i = 0; i < K; i++)\n                rHat.push(NTT.encode(sampleCBD(PRF, seed, i, ETA1)));\n            const x = XOF(rho);\n            const tmp2 = new Uint16Array(N);\n            const u = [];\n            for (let i = 0; i < K; i++) {\n                const e1 = sampleCBD(PRF, seed, K + i, ETA2);\n                const tmp = new Uint16Array(N);\n                for (let j = 0; j < K; j++) {\n                    const aij = SampleNTT(x.get(i, j)); // A[i][j], inplace\n                    polyAdd(tmp, MultiplyNTTs(aij, rHat[j])); // t += aij * rHat[j]\n                }\n                polyAdd(e1, NTT.decode(tmp)); // e1 += tmp\n                u.push(e1);\n                polyAdd(tmp2, MultiplyNTTs(tHat[i], rHat[i])); // t2 += tHat[i] * rHat[i]\n                tmp.fill(0);\n            }\n            x.clean();\n            const e2 = sampleCBD(PRF, seed, 2 * K, ETA2);\n            polyAdd(e2, NTT.decode(tmp2)); // e2 += tmp2\n            const v = poly1.decode(msg); // encode plaintext m into polynomial v\n            polyAdd(v, e2); // v += e2\n            cleanBytes(tHat, rHat, tmp2, e2);\n            return cipherCoder.encode([u, v]);\n        },\n        decrypt: (cipherText, privateKey) => {\n            const [u, v] = cipherCoder.decode(cipherText);\n            const sk = secretCoder.decode(privateKey); // s  ← ByteDecode_12(dkPKE)\n            const tmp = new Uint16Array(N);\n            for (let i = 0; i < K; i++)\n                polyAdd(tmp, MultiplyNTTs(sk[i], NTT.encode(u[i]))); // tmp += sk[i] * u[i]\n            polySub(v, NTT.decode(tmp)); // v += tmp\n            cleanBytes(tmp, sk, u);\n            return poly1.encode(v);\n        },\n    };\n};\nfunction createKyber(opts) {\n    const KPKE = genKPKE(opts);\n    const { HASH256, HASH512, KDF } = opts;\n    const { secretCoder: KPKESecretCoder, cipherTextLen } = KPKE;\n    const publicKeyLen = KPKE.publicKeyLen; // 384*K+32\n    const secretCoder = splitCoder(KPKE.secretKeyLen, KPKE.publicKeyLen, 32, 32);\n    const secretKeyLen = secretCoder.bytesLen;\n    const msgLen = 32;\n    return {\n        publicKeyLen,\n        msgLen,\n        keygen: (seed = randomBytes(64)) => {\n            ensureBytes(seed, 64);\n            const { publicKey, secretKey: sk } = KPKE.keygen(seed.subarray(0, 32));\n            const publicKeyHash = HASH256(publicKey);\n            // (dkPKE||ek||H(ek)||z)\n            const secretKey = secretCoder.encode([sk, publicKey, publicKeyHash, seed.subarray(32)]);\n            cleanBytes(sk, publicKeyHash);\n            return { publicKey, secretKey };\n        },\n        encapsulate: (publicKey, msg = randomBytes(32)) => {\n            ensureBytes(publicKey, publicKeyLen);\n            ensureBytes(msg, msgLen);\n            // FIPS-203 includes additional verification check for modulus\n            const eke = publicKey.subarray(0, 384 * opts.K);\n            const ek = KPKESecretCoder.encode(KPKESecretCoder.decode(eke.slice())); // Copy because of inplace encoding\n            // (Modulus check.) Perform the computation ek ← ByteEncode12(ByteDecode12(eke)).\n            // If ek = ̸ eke, the input is invalid. (See Section 4.2.1.)\n            if (!equalBytes(ek, eke)) {\n                cleanBytes(ek);\n                throw new Error('ML-KEM.encapsulate: wrong publicKey modulus');\n            }\n            cleanBytes(ek);\n            const kr = HASH512.create().update(msg).update(HASH256(publicKey)).digest(); // derive randomness\n            const cipherText = KPKE.encrypt(publicKey, msg, kr.subarray(32, 64));\n            kr.subarray(32).fill(0);\n            return { cipherText, sharedSecret: kr.subarray(0, 32) };\n        },\n        decapsulate: (cipherText, secretKey) => {\n            ensureBytes(secretKey, secretKeyLen); // 768*k + 96\n            ensureBytes(cipherText, cipherTextLen); // 32(du*k + dv)\n            const [sk, publicKey, publicKeyHash, z] = secretCoder.decode(secretKey);\n            const msg = KPKE.decrypt(cipherText, sk);\n            const kr = HASH512.create().update(msg).update(publicKeyHash).digest(); // derive randomness, Khat, rHat = G(mHat || h)\n            const Khat = kr.subarray(0, 32);\n            const cipherText2 = KPKE.encrypt(publicKey, msg, kr.subarray(32, 64)); // re-encrypt using the derived randomness\n            const isValid = equalBytes(cipherText, cipherText2); // if ciphertexts do not match, “implicitly reject”\n            const Kbar = KDF.create({ dkLen: 32 }).update(z).update(cipherText).digest();\n            cleanBytes(msg, cipherText2, !isValid ? Khat : Kbar);\n            return isValid ? Khat : Kbar;\n        },\n    };\n}\nfunction shakePRF(dkLen, key, nonce) {\n    return shake256\n        .create({ dkLen })\n        .update(key)\n        .update(new Uint8Array([nonce]))\n        .digest();\n}\nconst opts = {\n    HASH256: sha3_256,\n    HASH512: sha3_512,\n    KDF: shake256,\n    XOF: XOF128,\n    PRF: shakePRF,\n};\n/**\n * FIPS-203 ML-KEM.\n */\nexport const ml_kem512 = /* @__PURE__ */ createKyber({\n    ...opts,\n    ...PARAMS[512],\n});\nexport const ml_kem768 = /* @__PURE__ */ createKyber({\n    ...opts,\n    ...PARAMS[768],\n});\nexport const ml_kem1024 = /* @__PURE__ */ createKyber({\n    ...opts,\n    ...PARAMS[1024],\n});\n//# sourceMappingURL=ml-kem.js.map","/*! noble-post-quantum - MIT License (c) 2024 Paul Miller (paulmillr.com) */\nimport { shake256 } from '@noble/hashes/sha3';\nimport { genCrystals, XOF128, XOF256 } from './_crystals.js';\nimport { cleanBytes, ensureBytes, equalBytes, randomBytes, splitCoder, vecCoder, concatBytes, } from './utils.js';\n/*\nLattice-based digital signature algorithm. See\n[official site](https://www.pq-crystals.org/dilithium/index.shtml),\n[repo](https://github.com/pq-crystals/dilithium).\nDilithium has similar internals to Kyber, but their keys and params are different.\n\n*/\n// Constants\nconst N = 256;\n// 2**23 − 2**13 + 1, 23 bits: multiply will be 46. We have enough precision in JS to avoid bigints\nconst Q = 8380417;\nconst ROOT_OF_UNITY = 1753;\n// f = 256**−1 mod q, pow(256, -1, q) = 8347681 (python3)\nconst F = 8347681;\nconst D = 13;\n// Dilithium is kinda parametrized over GAMMA2, but everything will break with any other value.\nconst GAMMA2_1 = Math.floor((Q - 1) / 88) | 0;\nconst GAMMA2_2 = Math.floor((Q - 1) / 32) | 0;\n// prettier-ignore\nexport const PARAMS = {\n    2: { K: 4, L: 4, D, GAMMA1: 2 ** 17, GAMMA2: GAMMA2_1, TAU: 39, ETA: 2, OMEGA: 80 },\n    3: { K: 6, L: 5, D, GAMMA1: 2 ** 19, GAMMA2: GAMMA2_2, TAU: 49, ETA: 4, OMEGA: 55 },\n    5: { K: 8, L: 7, D, GAMMA1: 2 ** 19, GAMMA2: GAMMA2_2, TAU: 60, ETA: 2, OMEGA: 75 },\n};\nconst newPoly = (n) => new Int32Array(n);\nconst { mod, smod, NTT, bitsCoder } = genCrystals({\n    N,\n    Q,\n    F,\n    ROOT_OF_UNITY,\n    newPoly,\n    isKyber: false,\n    brvBits: 8,\n});\nconst id = (n) => n;\nconst polyCoder = (d, compress = id, verify = id) => bitsCoder(d, {\n    encode: (i) => compress(verify(i)),\n    decode: (i) => verify(compress(i)),\n});\nconst polyAdd = (a, b) => {\n    for (let i = 0; i < a.length; i++)\n        a[i] = mod(a[i] + b[i]);\n    return a;\n};\nconst polySub = (a, b) => {\n    for (let i = 0; i < a.length; i++)\n        a[i] = mod(a[i] - b[i]);\n    return a;\n};\nconst polyShiftl = (p) => {\n    for (let i = 0; i < N; i++)\n        p[i] <<= D;\n    return p;\n};\nconst polyChknorm = (p, B) => {\n    // Not very sure about this, but FIPS204 doesn't provide any function for that :(\n    for (let i = 0; i < N; i++)\n        if (Math.abs(smod(p[i])) >= B)\n            return true;\n    return false;\n};\nconst MultiplyNTTs = (a, b) => {\n    // NOTE: we don't use montgomery reduction in code, since it requires 64 bit ints,\n    // which is not available in JS. mod(a[i] * b[i]) is ok, since Q is 23 bit,\n    // which means a[i] * b[i] is 46 bit, which is safe to use in JS. (number is 53 bits).\n    // Barrett reduction is slower than mod :(\n    const c = newPoly(N);\n    for (let i = 0; i < a.length; i++)\n        c[i] = mod(a[i] * b[i]);\n    return c;\n};\n// Return poly in NTT representation\nfunction RejNTTPoly(xof) {\n    // Samples a polynomial ∈ Tq.\n    const r = newPoly(N);\n    // NOTE: we can represent 3xu24 as 4xu32, but it doesn't improve perf :(\n    for (let j = 0; j < N;) {\n        const b = xof();\n        if (b.length % 3)\n            throw new Error('RejNTTPoly: unaligned block');\n        for (let i = 0; j < N && i <= b.length - 3; i += 3) {\n            const t = (b[i + 0] | (b[i + 1] << 8) | (b[i + 2] << 16)) & 0x7fffff; // 3 bytes\n            if (t < Q)\n                r[j++] = t;\n        }\n    }\n    return r;\n}\nconst EMPTY = new Uint8Array(0);\nfunction getDilithium(opts) {\n    const { K, L, GAMMA1, GAMMA2, TAU, ETA, OMEGA } = opts;\n    const { CRH_BYTES, TR_BYTES, C_TILDE_BYTES, XOF128, XOF256 } = opts;\n    if (![2, 4].includes(ETA))\n        throw new Error('Wrong ETA');\n    if (![1 << 17, 1 << 19].includes(GAMMA1))\n        throw new Error('Wrong GAMMA1');\n    if (![GAMMA2_1, GAMMA2_2].includes(GAMMA2))\n        throw new Error('Wrong GAMMA2');\n    const BETA = TAU * ETA;\n    const decompose = (r) => {\n        // Decomposes r into (r1, r0) such that r ≡ r1(2γ2) + r0 mod q.\n        const rPlus = mod(r);\n        const r0 = smod(rPlus, 2 * GAMMA2) | 0;\n        if (rPlus - r0 === Q - 1)\n            return { r1: 0 | 0, r0: (r0 - 1) | 0 };\n        const r1 = Math.floor((rPlus - r0) / (2 * GAMMA2)) | 0;\n        return { r1, r0 }; // r1 = HighBits, r0 = LowBits\n    };\n    const HighBits = (r) => decompose(r).r1;\n    const LowBits = (r) => decompose(r).r0;\n    const MakeHint = (z, r) => {\n        // Compute hint bit indicating whether adding z to r alters the high bits of r.\n        // From dilithium code\n        const res0 = z <= GAMMA2 || z > Q - GAMMA2 || (z === Q - GAMMA2 && r === 0) ? 0 : 1;\n        // from FIPS204:\n        // // const r1 = HighBits(r);\n        // // const v1 = HighBits(r + z);\n        // // const res1 = +(r1 !== v1);\n        // But they return different results! However, decompose is same.\n        // So, either there is a bug in Dilithium ref implementation or in FIPS204.\n        // For now, lets use dilithium one, so test vectors can be passed.\n        // See\n        // https://github.com/GiacomoPope/dilithium-py?tab=readme-ov-file#optimising-decomposition-and-making-hints\n        return res0;\n    };\n    const UseHint = (h, r) => {\n        // Returns the high bits of r adjusted according to hint h\n        const m = Math.floor((Q - 1) / (2 * GAMMA2));\n        const { r1, r0 } = decompose(r);\n        // 3: if h = 1 and r0 > 0 return (r1 + 1) mod m\n        // 4: if h = 1 and r0 ≤ 0 return (r1 − 1) mod m\n        if (h === 1)\n            return r0 > 0 ? mod(r1 + 1, m) | 0 : mod(r1 - 1, m) | 0;\n        return r1 | 0;\n    };\n    const Power2Round = (r) => {\n        // Decomposes r into (r1, r0) such that r ≡ r1*(2**d) + r0 mod q.\n        const rPlus = mod(r);\n        const r0 = smod(rPlus, 2 ** D) | 0;\n        return { r1: Math.floor((rPlus - r0) / 2 ** D) | 0, r0 };\n    };\n    const hintCoder = {\n        bytesLen: OMEGA + K,\n        encode: (h) => {\n            if (h === false)\n                throw new Error('hint.encode: hint is false'); // should never happen\n            const res = new Uint8Array(OMEGA + K);\n            for (let i = 0, k = 0; i < K; i++) {\n                for (let j = 0; j < N; j++)\n                    if (h[i][j] !== 0)\n                        res[k++] = j;\n                res[OMEGA + i] = k;\n            }\n            return res;\n        },\n        decode: (buf) => {\n            const h = [];\n            let k = 0;\n            for (let i = 0; i < K; i++) {\n                const hi = newPoly(N);\n                if (buf[OMEGA + i] < k || buf[OMEGA + i] > OMEGA)\n                    return false;\n                for (let j = k; j < buf[OMEGA + i]; j++) {\n                    if (j > k && buf[j] <= buf[j - 1])\n                        return false;\n                    hi[buf[j]] = 1;\n                }\n                k = buf[OMEGA + i];\n                h.push(hi);\n            }\n            for (let j = k; j < OMEGA; j++)\n                if (buf[j] !== 0)\n                    return false;\n            return h;\n        },\n    };\n    const ETACoder = polyCoder(ETA === 2 ? 3 : 4, (i) => ETA - i, (i) => {\n        if (!(-ETA <= i && i <= ETA))\n            throw new Error(`malformed key s1/s3 ${i} outside of ETA range [${-ETA}, ${ETA}]`);\n        return i;\n    });\n    const T0Coder = polyCoder(13, (i) => (1 << (D - 1)) - i);\n    const T1Coder = polyCoder(10);\n    // Requires smod. Need to fix!\n    const ZCoder = polyCoder(GAMMA1 === 1 << 17 ? 18 : 20, (i) => smod(GAMMA1 - i));\n    const W1Coder = polyCoder(GAMMA2 === GAMMA2_1 ? 6 : 4);\n    const W1Vec = vecCoder(W1Coder, K);\n    // Main structures\n    const publicCoder = splitCoder(32, vecCoder(T1Coder, K));\n    const secretCoder = splitCoder(32, 32, TR_BYTES, vecCoder(ETACoder, L), vecCoder(ETACoder, K), vecCoder(T0Coder, K));\n    const sigCoder = splitCoder(C_TILDE_BYTES, vecCoder(ZCoder, L), hintCoder);\n    const CoefFromHalfByte = ETA === 2\n        ? (n) => (n < 15 ? 2 - (n % 5) : false)\n        : (n) => (n < 9 ? 4 - n : false);\n    // Return poly in NTT representation\n    function RejBoundedPoly(xof) {\n        // Samples an element a ∈ Rq with coeffcients in [−η, η] computed via rejection sampling from ρ.\n        const r = newPoly(N);\n        for (let j = 0; j < N;) {\n            const b = xof();\n            for (let i = 0; j < N && i < b.length; i += 1) {\n                // half byte. Should be superfast with vector instructions. But very slow with js :(\n                const d1 = CoefFromHalfByte(b[i] & 0x0f);\n                const d2 = CoefFromHalfByte((b[i] >> 4) & 0x0f);\n                if (d1 !== false)\n                    r[j++] = d1;\n                if (j < N && d2 !== false)\n                    r[j++] = d2;\n            }\n        }\n        return r;\n    }\n    const SampleInBall = (seed) => {\n        // Samples a polynomial c ∈ Rq with coeffcients from {−1, 0, 1} and Hamming weight τ\n        const pre = newPoly(N);\n        const s = shake256.create({}).update(seed);\n        const buf = new Uint8Array(shake256.blockLen);\n        s.xofInto(buf);\n        const masks = buf.slice(0, 8);\n        for (let i = N - TAU, pos = 8, maskPos = 0, maskBit = 0; i < N; i++) {\n            let b = i + 1;\n            for (; b > i;) {\n                b = buf[pos++];\n                if (pos < shake256.blockLen)\n                    continue;\n                s.xofInto(buf);\n                pos = 0;\n            }\n            pre[i] = pre[b];\n            pre[b] = 1 - (((masks[maskPos] >> maskBit++) & 1) << 1);\n            if (maskBit >= 8) {\n                maskPos++;\n                maskBit = 0;\n            }\n        }\n        return pre;\n    };\n    const polyPowerRound = (p) => {\n        const res0 = newPoly(N);\n        const res1 = newPoly(N);\n        for (let i = 0; i < p.length; i++) {\n            const { r0, r1 } = Power2Round(p[i]);\n            res0[i] = r0;\n            res1[i] = r1;\n        }\n        return { r0: res0, r1: res1 };\n    };\n    const polyUseHint = (u, h) => {\n        for (let i = 0; i < N; i++)\n            u[i] = UseHint(h[i], u[i]);\n        return u;\n    };\n    const polyMakeHint = (a, b) => {\n        const v = newPoly(N);\n        let cnt = 0;\n        for (let i = 0; i < N; i++) {\n            const h = MakeHint(a[i], b[i]);\n            v[i] = h;\n            cnt += h;\n        }\n        return { v, cnt };\n    };\n    const signRandBytes = 32;\n    const seedCoder = splitCoder(32, 64, 32);\n    // API & argument positions are exactly as in FIPS204.\n    const internal = {\n        signRandBytes,\n        keygen: (seed = randomBytes(32)) => {\n            // H(𝜉||IntegerToBytes(𝑘, 1)||IntegerToBytes(ℓ, 1), 128) 2: ▷ expand seed\n            const seedDst = new Uint8Array(32 + 2);\n            seedDst.set(seed);\n            seedDst[32] = K;\n            seedDst[33] = L;\n            const [rho, rhoPrime, K_] = seedCoder.decode(shake256(seedDst, { dkLen: seedCoder.bytesLen }));\n            const xofPrime = XOF256(rhoPrime);\n            const s1 = [];\n            for (let i = 0; i < L; i++)\n                s1.push(RejBoundedPoly(xofPrime.get(i & 0xff, (i >> 8) & 0xff)));\n            const s2 = [];\n            for (let i = L; i < L + K; i++)\n                s2.push(RejBoundedPoly(xofPrime.get(i & 0xff, (i >> 8) & 0xff)));\n            const s1Hat = s1.map((i) => NTT.encode(i.slice()));\n            const t0 = [];\n            const t1 = [];\n            const xof = XOF128(rho);\n            const t = newPoly(N);\n            for (let i = 0; i < K; i++) {\n                // t ← NTT−1(A*NTT(s1)) + s2\n                t.fill(0); // don't-reallocate\n                for (let j = 0; j < L; j++) {\n                    const aij = RejNTTPoly(xof.get(j, i)); // super slow!\n                    polyAdd(t, MultiplyNTTs(aij, s1Hat[j]));\n                }\n                NTT.decode(t);\n                const { r0, r1 } = polyPowerRound(polyAdd(t, s2[i])); // (t1, t0) ← Power2Round(t, d)\n                t0.push(r0);\n                t1.push(r1);\n            }\n            const publicKey = publicCoder.encode([rho, t1]); // pk ← pkEncode(ρ, t1)\n            const tr = shake256(publicKey, { dkLen: TR_BYTES }); // tr ← H(BytesToBits(pk), 512)\n            const secretKey = secretCoder.encode([rho, K_, tr, s1, s2, t0]); // sk ← skEncode(ρ, K,tr, s1, s2, t0)\n            xof.clean();\n            xofPrime.clean();\n            // STATS\n            // Kyber512:  { calls: 4, xofs: 12 }, Kyber768: { calls: 9, xofs: 27 }, Kyber1024: { calls: 16, xofs: 48 }\n            // DSA44:    { calls: 24, xofs: 24 }, DSA65:    { calls: 41, xofs: 41 }, DSA87:    { calls: 71, xofs: 71 }\n            cleanBytes(rho, rhoPrime, K_, s1, s2, s1Hat, t, t0, t1, tr, seedDst);\n            return { publicKey, secretKey };\n        },\n        // NOTE: random is optional.\n        sign: (secretKey, msg, random) => {\n            // This part can be pre-cached per secretKey, but there is only minor performance improvement,\n            // since we re-use a lot of variables to computation.\n            const [rho, _K, tr, s1, s2, t0] = secretCoder.decode(secretKey); // (ρ, K,tr, s1, s2, t0) ← skDecode(sk)\n            // Cache matrix to avoid re-compute later\n            const A = []; // A ← ExpandA(ρ)\n            const xof = XOF128(rho);\n            for (let i = 0; i < K; i++) {\n                const pv = [];\n                for (let j = 0; j < L; j++)\n                    pv.push(RejNTTPoly(xof.get(j, i)));\n                A.push(pv);\n            }\n            xof.clean();\n            for (let i = 0; i < L; i++)\n                NTT.encode(s1[i]); // sˆ1 ← NTT(s1)\n            for (let i = 0; i < K; i++) {\n                NTT.encode(s2[i]); // sˆ2 ← NTT(s2)\n                NTT.encode(t0[i]); // tˆ0 ← NTT(t0)\n            }\n            // This part is per msg\n            const mu = shake256.create({ dkLen: CRH_BYTES }).update(tr).update(msg).digest(); // 6: µ ← H(tr||M, 512) ▷ Compute message representative µ\n            // Compute private random seed\n            const rnd = random ? random : new Uint8Array(32);\n            ensureBytes(rnd);\n            const rhoprime = shake256\n                .create({ dkLen: CRH_BYTES })\n                .update(_K)\n                .update(rnd)\n                .update(mu)\n                .digest(); // ρ′← H(K||rnd||µ, 512)\n            ensureBytes(rhoprime, CRH_BYTES);\n            const x256 = XOF256(rhoprime, ZCoder.bytesLen);\n            //  Rejection sampling loop\n            main_loop: for (let kappa = 0;;) {\n                const y = [];\n                // y ← ExpandMask(ρ , κ)\n                for (let i = 0; i < L; i++, kappa++)\n                    y.push(ZCoder.decode(x256.get(kappa & 0xff, kappa >> 8)()));\n                const z = y.map((i) => NTT.encode(i.slice()));\n                const w = [];\n                for (let i = 0; i < K; i++) {\n                    // w ← NTT−1(A ◦ NTT(y))\n                    const wi = newPoly(N);\n                    for (let j = 0; j < L; j++)\n                        polyAdd(wi, MultiplyNTTs(A[i][j], z[j]));\n                    NTT.decode(wi);\n                    w.push(wi);\n                }\n                const w1 = w.map((j) => j.map(HighBits)); // w1 ← HighBits(w)\n                // Commitment hash: c˜ ∈{0, 1 2λ } ← H(µ||w1Encode(w1), 2λ)\n                const cTilde = shake256\n                    .create({ dkLen: C_TILDE_BYTES })\n                    .update(mu)\n                    .update(W1Vec.encode(w1))\n                    .digest();\n                // Verifer’s challenge\n                const cHat = NTT.encode(SampleInBall(cTilde)); // c ← SampleInBall(c˜1); cˆ ← NTT(c)\n                // ⟨⟨cs1⟩⟩ ← NTT−1(cˆ◦ sˆ1)\n                const cs1 = s1.map((i) => MultiplyNTTs(i, cHat));\n                for (let i = 0; i < L; i++) {\n                    polyAdd(NTT.decode(cs1[i]), y[i]); // z ← y + ⟨⟨cs1⟩⟩\n                    if (polyChknorm(cs1[i], GAMMA1 - BETA))\n                        continue main_loop; // ||z||∞ ≥ γ1 − β\n                }\n                // cs1 is now z (▷ Signer’s response)\n                let cnt = 0;\n                const h = [];\n                for (let i = 0; i < K; i++) {\n                    const cs2 = NTT.decode(MultiplyNTTs(s2[i], cHat)); // ⟨⟨cs2⟩⟩ ← NTT−1(cˆ◦ sˆ2)\n                    const r0 = polySub(w[i], cs2).map(LowBits); // r0 ← LowBits(w − ⟨⟨cs2⟩⟩)\n                    if (polyChknorm(r0, GAMMA2 - BETA))\n                        continue main_loop; // ||r0||∞ ≥ γ2 − β\n                    const ct0 = NTT.decode(MultiplyNTTs(t0[i], cHat)); // ⟨⟨ct0⟩⟩ ← NTT−1(cˆ◦ tˆ0)\n                    if (polyChknorm(ct0, GAMMA2))\n                        continue main_loop;\n                    polyAdd(r0, ct0);\n                    // ▷ Signer’s hint\n                    const hint = polyMakeHint(r0, w1[i]); // h ← MakeHint(−⟨⟨ct0⟩⟩, w− ⟨⟨cs2⟩⟩ + ⟨⟨ct0⟩⟩)\n                    h.push(hint.v);\n                    cnt += hint.cnt;\n                }\n                if (cnt > OMEGA)\n                    continue; // the number of 1’s in h is greater than ω\n                x256.clean();\n                const res = sigCoder.encode([cTilde, cs1, h]); // σ ← sigEncode(c˜, z mod±q, h)\n                // rho, _K, tr is subarray of secretKey, cannot clean.\n                cleanBytes(cTilde, cs1, h, cHat, w1, w, z, y, rhoprime, mu, s1, s2, t0, ...A);\n                return res;\n            }\n            // @ts-ignore\n            throw new Error('Unreachable code path reached, report this error');\n        },\n        verify: (publicKey, msg, sig) => {\n            // ML-DSA.Verify(pk, M, σ): Verifes a signature σ for a message M.\n            const [rho, t1] = publicCoder.decode(publicKey); // (ρ, t1) ← pkDecode(pk)\n            const tr = shake256(publicKey, { dkLen: TR_BYTES }); // 6: tr ← H(BytesToBits(pk), 512)\n            if (sig.length !== sigCoder.bytesLen)\n                return false; // return false instead of exception\n            const [cTilde, z, h] = sigCoder.decode(sig); // (c˜, z, h) ← sigDecode(σ), ▷ Signer’s commitment hash c ˜, response z and hint\n            if (h === false)\n                return false; // if h = ⊥ then return false\n            for (let i = 0; i < L; i++)\n                if (polyChknorm(z[i], GAMMA1 - BETA))\n                    return false;\n            const mu = shake256.create({ dkLen: CRH_BYTES }).update(tr).update(msg).digest(); // 7: µ ← H(tr||M, 512)\n            // Compute verifer’s challenge from c˜\n            const c = NTT.encode(SampleInBall(cTilde)); // c ← SampleInBall(c˜1)\n            const zNtt = z.map((i) => i.slice()); // zNtt = NTT(z)\n            for (let i = 0; i < L; i++)\n                NTT.encode(zNtt[i]);\n            const wTick1 = [];\n            const xof = XOF128(rho);\n            for (let i = 0; i < K; i++) {\n                const ct12d = MultiplyNTTs(NTT.encode(polyShiftl(t1[i])), c); //c * t1 * (2**d)\n                const Az = newPoly(N); // // A * z\n                for (let j = 0; j < L; j++) {\n                    const aij = RejNTTPoly(xof.get(j, i)); // A[i][j] inplace\n                    polyAdd(Az, MultiplyNTTs(aij, zNtt[j]));\n                }\n                // wApprox = A*z - c*t1 * (2**d)\n                const wApprox = NTT.decode(polySub(Az, ct12d));\n                // Reconstruction of signer’s commitment\n                wTick1.push(polyUseHint(wApprox, h[i])); // w ′ ← UseHint(h, w'approx )\n            }\n            xof.clean();\n            // c˜′← H (µ||w1Encode(w′1), 2λ),  Hash it; this should match c˜\n            const c2 = shake256\n                .create({ dkLen: C_TILDE_BYTES })\n                .update(mu)\n                .update(W1Vec.encode(wTick1))\n                .digest();\n            // Additional checks in FIPS-204:\n            // [[ ||z||∞ < γ1 − β ]] and [[c ˜ = c˜′]] and [[number of 1’s in h is ≤ ω]]\n            for (const t of h) {\n                const sum = t.reduce((acc, i) => acc + i, 0);\n                if (!(sum <= OMEGA))\n                    return false;\n            }\n            for (const t of z)\n                if (polyChknorm(t, GAMMA1 - BETA))\n                    return false;\n            return equalBytes(cTilde, c2);\n        },\n    };\n    const getMessage = (msg, ctx = EMPTY) => {\n        ensureBytes(msg);\n        ensureBytes(ctx);\n        if (ctx.length > 255)\n            throw new Error('context should be less than 255 bytes');\n        return concatBytes(new Uint8Array([0, ctx.length]), ctx, msg);\n    };\n    // TODO: no hash-dsa vectors for now, so we don't implement it yet\n    return {\n        internal,\n        keygen: internal.keygen,\n        signRandBytes: internal.signRandBytes,\n        sign: (secretKey, msg, ctx = EMPTY, random) => {\n            const M = getMessage(msg, ctx);\n            const res = internal.sign(secretKey, M, random);\n            M.fill(0);\n            return res;\n        },\n        verify: (publicKey, msg, sig, ctx = EMPTY) => {\n            return internal.verify(publicKey, getMessage(msg, ctx), sig);\n        },\n    };\n}\n// ML-DSA\nexport const ml_dsa44 = /* @__PURE__ */ getDilithium({\n    ...PARAMS[2],\n    CRH_BYTES: 64,\n    TR_BYTES: 64,\n    C_TILDE_BYTES: 32,\n    XOF128,\n    XOF256,\n});\nexport const ml_dsa65 = /* @__PURE__ */ getDilithium({\n    ...PARAMS[3],\n    CRH_BYTES: 64,\n    TR_BYTES: 64,\n    C_TILDE_BYTES: 48,\n    XOF128,\n    XOF256,\n});\nexport const ml_dsa87 = /* @__PURE__ */ getDilithium({\n    ...PARAMS[5],\n    CRH_BYTES: 64,\n    TR_BYTES: 64,\n    C_TILDE_BYTES: 64,\n    XOF128,\n    XOF256,\n});\n//# sourceMappingURL=ml-dsa.js.map"],"names":["ensureBytes","abytes","randomBytes","randb","equalBytes","a","b","length","diff","i","splitCoder","lengths","getLength","c","bytesLen","reduce","sum","encode","bufs","res","Uint8Array","pos","l","set","fill","decode","buf","subarray","push","vecCoder","vecLen","u","Error","r","cleanBytes","list","t","Array","isArray","getMask","bits","bitReversal","n","revrsd","toString","padStart","slice","split","reverse","join","Number","parseInt","genCrystals","opts","newPoly","N","Q","F","ROOT_OF_UNITY","brvBits","isKyber","mod","modulo","result","nttZetas","out","p","BigInt","getZettas","LEN1","LEN2","NTT","k","len","start","zeta","j","smod","bitsCoder","d","mask","poly","bufLen","bytes","createXofShake","shake","seed","blockLen","_seed","seedLen","h","create","calls","xofs","stats","get","x","y","destroy","update","xofInto","clean","XOF128","shake128","XOF256","shake256","Uint16Array","polyCoder","compress","polyAdd","MultiplyNTTs","f","g","z","c0","c1","a0","a1","b0","b1","SampleNTT","xof","d1","d2","sampleCBD","PRF","nonce","eta","b32","u32","bb","t0","genKPKE","K","XOF","HASH512","ETA1","ETA2","du","dv","poly1","polyV","polyU","publicCoder","secretCoder","cipherCoder","seedCoder","secretKeyLen","publicKeyLen","cipherTextLen","keygen","seedDst","seedHash","rho","sigma","sHat","tHat","e","publicKey","secretKey","encrypt","msg","rHat","tmp2","e1","tmp","e2","v","decrypt","cipherText","privateKey","sk","polySub","createKyber","KPKE","HASH256","KDF","KPKESecretCoder","msgLen","publicKeyHash","encapsulate","eke","ek","kr","digest","sharedSecret","decapsulate","Khat","cipherText2","isValid","Kbar","dkLen","ml_kem768","sha3_256","sha3_512","key","RBGstrength","D","GAMMA2_1","Math","floor","GAMMA2_2","PARAMS","L","GAMMA1","GAMMA2","TAU","ETA","OMEGA","Int32Array","id","verify","polyShiftl","polyChknorm","B","abs","RejNTTPoly","EMPTY","getDilithium","CRH_BYTES","TR_BYTES","C_TILDE_BYTES","includes","BETA","decompose","rPlus","r0","r1","HighBits","LowBits","UseHint","m","Power2Round","hintCoder","hi","ETACoder","T0Coder","T1Coder","ZCoder","W1Vec","sigCoder","CoefFromHalfByte","RejBoundedPoly","SampleInBall","pre","s","masks","maskPos","maskBit","polyPowerRound","res0","res1","polyUseHint","polyMakeHint","cnt","internal","signRandBytes","rhoPrime","K_","xofPrime","s1","s2","s1Hat","map","t1","aij","tr","sign","random","_K","A","pv","mu","rnd","rhoprime","x256","main_loop","kappa","w","wi","w1","cTilde","cHat","cs1","cs2","ct0","hint","sig","zNtt","wTick1","ct12d","Az","wApprox","c2","acc","getMessage","ctx","concatBytes","M","ml_dsa65"],"mappings":"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","x_google_ignoreList":[0,1,2,3]}
+{"version":3,"file":"noble_post_quantum.min.mjs","sources":["../../node_modules/@noble/post-quantum/node_modules/@noble/hashes/esm/_assert.js","../../node_modules/@noble/post-quantum/node_modules/@noble/hashes/esm/_u64.js","../../node_modules/@noble/post-quantum/node_modules/@noble/hashes/esm/crypto.js","../../node_modules/@noble/post-quantum/node_modules/@noble/hashes/esm/utils.js","../../node_modules/@noble/post-quantum/node_modules/@noble/hashes/esm/sha3.js","../../node_modules/@noble/post-quantum/esm/utils.js","../../node_modules/@noble/post-quantum/esm/_crystals.js","../../node_modules/@noble/post-quantum/esm/ml-kem.js","../../node_modules/@noble/post-quantum/esm/ml-dsa.js"],"sourcesContent":["function anumber(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error('positive integer expected, got ' + n);\n}\n// copied from utils\nfunction isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\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}\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}\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}\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, anumber as number, abytes, abytes as bytes, ahash, aexists, aoutput };\nconst assert = {\n    number: anumber,\n    bytes: abytes,\n    hash: ahash,\n    exists: aexists,\n    output: aoutput,\n};\nexport default assert;\n//# sourceMappingURL=_assert.js.map","const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);\nconst _32n = /* @__PURE__ */ BigInt(32);\n// BigUint64Array is too slow as per 2024, so we implement it using Uint32Array.\n// TODO: re-check https://issues.chromium.org/issues/42212588\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","/*! 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 const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexport const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n// Cast array to view\nexport const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n// The rotate right (circular right shift) operation for uint32\nexport const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);\n// The rotate left (circular left shift) operation for uint32\nexport const rotl = (word, shift) => (word << shift) | ((word >>> (32 - shift)) >>> 0);\nexport const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n// The byte swap operation for uint32\nexport const byteSwap = (word) => ((word << 24) & 0xff000000) |\n    ((word << 8) & 0xff0000) |\n    ((word >>> 8) & 0xff00) |\n    ((word >>> 24) & 0xff);\n// Conditionally byte swap if on a big-endian platform\nexport const byteSwapIfBE = isLE ? (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 * @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 * @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('padded 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// 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.\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 * @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}\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/**\n * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.\n */\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","import { abytes, aexists, anumber, aoutput } from './_assert.js';\nimport { rotlBH, rotlBL, rotlSH, rotlSL, split } from './_u64.js';\nimport { Hash, u32, toBytes, wrapConstructor, wrapXOFConstructorWithOpts, isLE, byteSwap32, } from './utils.js';\n// SHA3 (keccak) is based on a new design: basically, the internal state is bigger than output size.\n// It's called a sponge function.\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// Same as keccakf1600, but allows to skip some rounds\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}\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        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));\nexport const sha3_224 = /* @__PURE__ */ gen(0x06, 144, 224 / 8);\n/**\n * SHA3-256 hash function\n * @param message - that would be hashed\n */\nexport const sha3_256 = /* @__PURE__ */ gen(0x06, 136, 256 / 8);\nexport const sha3_384 = /* @__PURE__ */ gen(0x06, 104, 384 / 8);\nexport const sha3_512 = /* @__PURE__ */ gen(0x06, 72, 512 / 8);\nexport const keccak_224 = /* @__PURE__ */ gen(0x01, 144, 224 / 8);\n/**\n * keccak-256 hash function. Different from SHA3-256.\n * @param message - that would be hashed\n */\nexport const keccak_256 = /* @__PURE__ */ gen(0x01, 136, 256 / 8);\nexport const keccak_384 = /* @__PURE__ */ gen(0x01, 104, 384 / 8);\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));\nexport const shake128 = /* @__PURE__ */ genShake(0x1f, 168, 128 / 8);\nexport const shake256 = /* @__PURE__ */ genShake(0x1f, 136, 256 / 8);\n//# sourceMappingURL=sha3.js.map","/*! noble-post-quantum - MIT License (c) 2024 Paul Miller (paulmillr.com) */\nimport { bytes as abytes } from '@noble/hashes/_assert';\nimport { randomBytes as randb, concatBytes } from '@noble/hashes/utils';\nexport const ensureBytes = abytes;\nexport const randomBytes = randb;\nexport { concatBytes };\n// Compares 2 u8a-s in kinda constant time\nexport function equalBytes(a, b) {\n    if (a.length !== b.length)\n        return false;\n    let diff = 0;\n    for (let i = 0; i < a.length; i++)\n        diff |= a[i] ^ b[i];\n    return diff === 0;\n}\nexport function splitCoder(...lengths) {\n    const getLength = (c) => (typeof c === 'number' ? c : c.bytesLen);\n    const bytesLen = lengths.reduce((sum, a) => sum + getLength(a), 0);\n    return {\n        bytesLen,\n        encode: (bufs) => {\n            const res = new Uint8Array(bytesLen);\n            for (let i = 0, pos = 0; i < lengths.length; i++) {\n                const c = lengths[i];\n                const l = getLength(c);\n                const b = typeof c === 'number' ? bufs[i] : c.encode(bufs[i]);\n                ensureBytes(b, l);\n                res.set(b, pos);\n                if (typeof c !== 'number')\n                    b.fill(0); // clean\n                pos += l;\n            }\n            return res;\n        },\n        decode: (buf) => {\n            ensureBytes(buf, bytesLen);\n            const res = [];\n            for (const c of lengths) {\n                const l = getLength(c);\n                const b = buf.subarray(0, l);\n                res.push(typeof c === 'number' ? b : c.decode(b));\n                buf = buf.subarray(l);\n            }\n            return res;\n        },\n    };\n}\n// nano-packed.array (fixed size)\nexport function vecCoder(c, vecLen) {\n    const bytesLen = vecLen * c.bytesLen;\n    return {\n        bytesLen,\n        encode: (u) => {\n            if (u.length !== vecLen)\n                throw new Error(`vecCoder.encode: wrong length=${u.length}. Expected: ${vecLen}`);\n            const res = new Uint8Array(bytesLen);\n            for (let i = 0, pos = 0; i < u.length; i++) {\n                const b = c.encode(u[i]);\n                res.set(b, pos);\n                b.fill(0); // clean\n                pos += b.length;\n            }\n            return res;\n        },\n        decode: (a) => {\n            ensureBytes(a, bytesLen);\n            const r = [];\n            for (let i = 0; i < a.length; i += c.bytesLen)\n                r.push(c.decode(a.subarray(i, i + c.bytesLen)));\n            return r;\n        },\n    };\n}\n// cleanBytes(new Uint8Array(), [new Uint16Array(), new Uint32Array()])\nexport function cleanBytes(...list) {\n    for (const t of list) {\n        if (Array.isArray(t))\n            for (const b of t)\n                b.fill(0);\n        else\n            t.fill(0);\n    }\n}\nexport function getMask(bits) {\n    return (1 << bits) - 1; // 4 -> 0b1111\n}\n//# sourceMappingURL=utils.js.map","/*! noble-post-quantum - MIT License (c) 2024 Paul Miller (paulmillr.com) */\nimport { shake128, shake256 } from '@noble/hashes/sha3';\nimport { getMask } from './utils.js';\n// TODO: benchmark\nfunction bitReversal(n, bits = 8) {\n    const padded = n.toString(2).padStart(8, '0');\n    const sliced = padded.slice(-bits).padStart(7, '0');\n    const revrsd = sliced.split('').reverse().join('');\n    return Number.parseInt(revrsd, 2);\n}\nexport const genCrystals = (opts) => {\n    // isKyber: true means Kyber, false means Dilithium\n    const { newPoly, N, Q, F, ROOT_OF_UNITY, brvBits, isKyber } = opts;\n    const mod = (a, modulo = Q) => {\n        const result = a % modulo | 0;\n        return (result >= 0 ? result | 0 : (modulo + result) | 0) | 0;\n    };\n    // -(Q-1)/2 < a <= (Q-1)/2\n    const smod = (a, modulo = Q) => {\n        const r = mod(a, modulo) | 0;\n        return (r > modulo >> 1 ? (r - modulo) | 0 : r) | 0;\n    };\n    // Generate zettas\n    function getZettas() {\n        const out = newPoly(N);\n        for (let i = 0; i < N; i++) {\n            const b = bitReversal(i, brvBits);\n            const p = BigInt(ROOT_OF_UNITY) ** BigInt(b) % BigInt(Q);\n            out[i] = Number(p) | 0;\n        }\n        return out;\n    }\n    const nttZetas = getZettas();\n    // Number-Theoretic Transform\n    // Explained: https://electricdusk.com/ntt.html\n    // Kyber has slightly different params, since there is no 512th primitive root of unity mod q,\n    // only 256th primitive root of unity mod. Which also complicates MultiplyNTT.\n    // TODO: there should be less ugly way to define this.\n    const LEN1 = isKyber ? 128 : N;\n    const LEN2 = isKyber ? 1 : 0;\n    const NTT = {\n        encode: (r) => {\n            for (let k = 1, len = 128; len > LEN2; len >>= 1) {\n                for (let start = 0; start < N; start += 2 * len) {\n                    const zeta = nttZetas[k++];\n                    for (let j = start; j < start + len; j++) {\n                        const t = mod(zeta * r[j + len]);\n                        r[j + len] = mod(r[j] - t) | 0;\n                        r[j] = mod(r[j] + t) | 0;\n                    }\n                }\n            }\n            return r;\n        },\n        decode: (r) => {\n            for (let k = LEN1 - 1, len = 1 + LEN2; len < LEN1 + LEN2; len <<= 1) {\n                for (let start = 0; start < N; start += 2 * len) {\n                    const zeta = nttZetas[k--];\n                    for (let j = start; j < start + len; j++) {\n                        const t = r[j];\n                        r[j] = mod(t + r[j + len]);\n                        r[j + len] = mod(zeta * (r[j + len] - t));\n                    }\n                }\n            }\n            for (let i = 0; i < r.length; i++)\n                r[i] = mod(F * r[i]);\n            return r;\n        },\n    };\n    // Encode polynominal as bits\n    const bitsCoder = (d, c) => {\n        const mask = getMask(d);\n        const bytesLen = d * (N / 8);\n        return {\n            bytesLen,\n            encode: (poly) => {\n                const r = new Uint8Array(bytesLen);\n                for (let i = 0, buf = 0, bufLen = 0, pos = 0; i < poly.length; i++) {\n                    buf |= (c.encode(poly[i]) & mask) << bufLen;\n                    bufLen += d;\n                    for (; bufLen >= 8; bufLen -= 8, buf >>= 8)\n                        r[pos++] = buf & getMask(bufLen);\n                }\n                return r;\n            },\n            decode: (bytes) => {\n                const r = newPoly(N);\n                for (let i = 0, buf = 0, bufLen = 0, pos = 0; i < bytes.length; i++) {\n                    buf |= bytes[i] << bufLen;\n                    bufLen += 8;\n                    for (; bufLen >= d; bufLen -= d, buf >>= d)\n                        r[pos++] = c.decode(buf & mask);\n                }\n                return r;\n            },\n        };\n    };\n    return { mod, smod, nttZetas, NTT, bitsCoder };\n};\nconst createXofShake = (shake) => (seed, blockLen) => {\n    if (!blockLen)\n        blockLen = shake.blockLen;\n    // Optimizations that won't mater:\n    // - cached seed update (two .update(), on start and on the end)\n    // - another cache which cloned into working copy\n    // Faster than multiple updates, since seed less than blockLen\n    const _seed = new Uint8Array(seed.length + 2);\n    _seed.set(seed);\n    const seedLen = seed.length;\n    const buf = new Uint8Array(blockLen); // == shake128.blockLen\n    let h = shake.create({});\n    let calls = 0;\n    let xofs = 0;\n    return {\n        stats: () => ({ calls, xofs }),\n        get: (x, y) => {\n            _seed[seedLen + 0] = x;\n            _seed[seedLen + 1] = y;\n            h.destroy();\n            h = shake.create({}).update(_seed);\n            calls++;\n            return () => {\n                xofs++;\n                return h.xofInto(buf);\n            };\n        },\n        clean: () => {\n            h.destroy();\n            buf.fill(0);\n            _seed.fill(0);\n        },\n    };\n};\nexport const XOF128 = /* @__PURE__ */ createXofShake(shake128);\nexport const XOF256 = /* @__PURE__ */ createXofShake(shake256);\n//# sourceMappingURL=_crystals.js.map","/*! noble-post-quantum - MIT License (c) 2024 Paul Miller (paulmillr.com) */\nimport { sha3_256, sha3_512, shake256 } from '@noble/hashes/sha3';\nimport { u32 } from '@noble/hashes/utils';\nimport { genCrystals, XOF128 } from './_crystals.js';\nimport { cleanBytes, ensureBytes, equalBytes, randomBytes, splitCoder, vecCoder, } from './utils.js';\n/*\nLattice-based key encapsulation mechanism.\nSee [official site](https://www.pq-crystals.org/kyber/resources.shtml),\n[repo](https://github.com/pq-crystals/kyber),\n[spec](https://datatracker.ietf.org/doc/draft-cfrg-schwabe-kyber/).\n\nKey encapsulation is similar to DH / ECDH (think X25519), with important differences:\n\n- We can't verify if it was \"Bob\" who've sent the shared secret.\n  In ECDH, it's always verified\n- Kyber is probabalistic and relies on quality of randomness (CSPRNG).\n  ECDH doesn't (to this extent).\n- Kyber decapsulation never throws an error, even when shared secret was\n  encrypted by a different public key. It will just return a different\n  shared secret\n\nThere are some concerns with regards to security: see\n[djb blog](https://blog.cr.yp.to/20231003-countcorrectly.html) and\n[mailing list](https://groups.google.com/a/list.nist.gov/g/pqc-forum/c/W2VOzy0wz_E).\n\n*/\nconst N = 256; // Kyber (not FIPS-203) supports different lengths, but all std modes were using 256\nconst Q = 3329; // 13*(2**8)+1, modulo prime\nconst F = 3303; // 3303 ≡ 128**(−1) mod q (FIPS-203)\nconst ROOT_OF_UNITY = 17; // ζ = 17 ∈ Zq is a primitive 256-th root of unity modulo Q. ζ**128 ≡−1\nconst { mod, nttZetas, NTT, bitsCoder } = genCrystals({\n    N,\n    Q,\n    F,\n    ROOT_OF_UNITY,\n    newPoly: (n) => new Uint16Array(n),\n    brvBits: 7,\n    isKyber: true,\n});\n// prettier-ignore\nexport const PARAMS = {\n    512: { N, Q, K: 2, ETA1: 3, ETA2: 2, du: 10, dv: 4, RBGstrength: 128 },\n    768: { N, Q, K: 3, ETA1: 2, ETA2: 2, du: 10, dv: 4, RBGstrength: 192 },\n    1024: { N, Q, K: 4, ETA1: 2, ETA2: 2, du: 11, dv: 5, RBGstrength: 256 },\n};\n// FIPS-203: compress/decompress\nconst compress = (d) => {\n    // Special case, no need to compress, pass as is, but strip high bytes on compression\n    if (d >= 12)\n        return { encode: (i) => i, decode: (i) => i };\n    // NOTE: we don't use float arithmetic (forbidden by FIPS-203 and high chance of bugs).\n    // Comments map to python implementation in RFC (draft-cfrg-schwabe-kyber)\n    // const round = (i: number) => Math.floor(i + 0.5) | 0;\n    const a = 2 ** (d - 1);\n    return {\n        // const compress = (i: number) => round((2 ** d / Q) * i) % 2 ** d;\n        encode: (i) => ((i << d) + Q / 2) / Q,\n        // const decompress = (i: number) => round((Q / 2 ** d) * i);\n        decode: (i) => (i * Q + a) >>> d,\n    };\n};\n// NOTE: we merge encoding and compress because it is faster, also both require same d param\n// Converts between bytes and d-bits compressed representation. Kinda like convertRadix2 from @scure/base\n// decode(encode(t)) == t, but there is loss of information on encode(decode(t))\nconst polyCoder = (d) => bitsCoder(d, compress(d));\nfunction polyAdd(a, b) {\n    for (let i = 0; i < N; i++)\n        a[i] = mod(a[i] + b[i]); // a += b\n}\nfunction polySub(a, b) {\n    for (let i = 0; i < N; i++)\n        a[i] = mod(a[i] - b[i]); // a -= b\n}\n// FIPS-203: Computes the product of two degree-one polynomials with respect to a quadratic modulus\nfunction BaseCaseMultiply(a0, a1, b0, b1, zeta) {\n    const c0 = mod(a1 * b1 * zeta + a0 * b0);\n    const c1 = mod(a0 * b1 + a1 * b0);\n    return { c0, c1 };\n}\n// FIPS-203: Computes the product (in the ring Tq) of two NTT representations. NOTE: works inplace for f\n// NOTE: since multiply defined only for NTT representation, we need to convert to NTT, multiply and convert back\nfunction MultiplyNTTs(f, g) {\n    for (let i = 0; i < N / 2; i++) {\n        let z = nttZetas[64 + (i >> 1)];\n        if (i & 1)\n            z = -z;\n        const { c0, c1 } = BaseCaseMultiply(f[2 * i + 0], f[2 * i + 1], g[2 * i + 0], g[2 * i + 1], z);\n        f[2 * i + 0] = c0;\n        f[2 * i + 1] = c1;\n    }\n    return f;\n}\n// Return poly in NTT representation\nfunction SampleNTT(xof) {\n    const r = new Uint16Array(N);\n    for (let j = 0; j < N;) {\n        const b = xof();\n        if (b.length % 3)\n            throw new Error('SampleNTT: unaligned block');\n        for (let i = 0; j < N && i + 3 <= b.length; i += 3) {\n            const d1 = ((b[i + 0] >> 0) | (b[i + 1] << 8)) & 0xfff;\n            const d2 = ((b[i + 1] >> 4) | (b[i + 2] << 4)) & 0xfff;\n            if (d1 < Q)\n                r[j++] = d1;\n            if (j < N && d2 < Q)\n                r[j++] = d2;\n        }\n    }\n    return r;\n}\n// Sampling from the centered binomial distribution\n// Returns poly with small coefficients (noise/errors)\nfunction sampleCBD(PRF, seed, nonce, eta) {\n    const buf = PRF((eta * N) / 4, seed, nonce);\n    const r = new Uint16Array(N);\n    const b32 = u32(buf);\n    let len = 0;\n    for (let i = 0, p = 0, bb = 0, t0 = 0; i < b32.length; i++) {\n        let b = b32[i];\n        for (let j = 0; j < 32; j++) {\n            bb += b & 1;\n            b >>= 1;\n            len += 1;\n            if (len === eta) {\n                t0 = bb;\n                bb = 0;\n            }\n            else if (len === 2 * eta) {\n                r[p++] = mod(t0 - bb);\n                bb = 0;\n                len = 0;\n            }\n        }\n    }\n    if (len)\n        throw new Error(`sampleCBD: leftover bits: ${len}`);\n    return r;\n}\n// K-PKE\n// As per FIPS-203, it doesn't perform any input validation and can't be used in standalone fashion.\nconst genKPKE = (opts) => {\n    const { K, PRF, XOF, HASH512, ETA1, ETA2, du, dv } = opts;\n    const poly1 = polyCoder(1);\n    const polyV = polyCoder(dv);\n    const polyU = polyCoder(du);\n    const publicCoder = splitCoder(vecCoder(polyCoder(12), K), 32);\n    const secretCoder = vecCoder(polyCoder(12), K);\n    const cipherCoder = splitCoder(vecCoder(polyU, K), polyV);\n    const seedCoder = splitCoder(32, 32);\n    return {\n        secretCoder,\n        secretKeyLen: secretCoder.bytesLen,\n        publicKeyLen: publicCoder.bytesLen,\n        cipherTextLen: cipherCoder.bytesLen,\n        keygen: (seed) => {\n            const seedDst = new Uint8Array(33);\n            seedDst.set(seed);\n            seedDst[32] = K;\n            const seedHash = HASH512(seedDst);\n            const [rho, sigma] = seedCoder.decode(seedHash);\n            const sHat = [];\n            const tHat = [];\n            for (let i = 0; i < K; i++)\n                sHat.push(NTT.encode(sampleCBD(PRF, sigma, i, ETA1)));\n            const x = XOF(rho);\n            for (let i = 0; i < K; i++) {\n                const e = NTT.encode(sampleCBD(PRF, sigma, K + i, ETA1));\n                for (let j = 0; j < K; j++) {\n                    const aji = SampleNTT(x.get(j, i)); // A[j][i], inplace\n                    polyAdd(e, MultiplyNTTs(aji, sHat[j]));\n                }\n                tHat.push(e); // t ← A ◦ s + e\n            }\n            x.clean();\n            const res = {\n                publicKey: publicCoder.encode([tHat, rho]),\n                secretKey: secretCoder.encode(sHat),\n            };\n            cleanBytes(rho, sigma, sHat, tHat, seedDst, seedHash);\n            return res;\n        },\n        encrypt: (publicKey, msg, seed) => {\n            const [tHat, rho] = publicCoder.decode(publicKey);\n            const rHat = [];\n            for (let i = 0; i < K; i++)\n                rHat.push(NTT.encode(sampleCBD(PRF, seed, i, ETA1)));\n            const x = XOF(rho);\n            const tmp2 = new Uint16Array(N);\n            const u = [];\n            for (let i = 0; i < K; i++) {\n                const e1 = sampleCBD(PRF, seed, K + i, ETA2);\n                const tmp = new Uint16Array(N);\n                for (let j = 0; j < K; j++) {\n                    const aij = SampleNTT(x.get(i, j)); // A[i][j], inplace\n                    polyAdd(tmp, MultiplyNTTs(aij, rHat[j])); // t += aij * rHat[j]\n                }\n                polyAdd(e1, NTT.decode(tmp)); // e1 += tmp\n                u.push(e1);\n                polyAdd(tmp2, MultiplyNTTs(tHat[i], rHat[i])); // t2 += tHat[i] * rHat[i]\n                tmp.fill(0);\n            }\n            x.clean();\n            const e2 = sampleCBD(PRF, seed, 2 * K, ETA2);\n            polyAdd(e2, NTT.decode(tmp2)); // e2 += tmp2\n            const v = poly1.decode(msg); // encode plaintext m into polynomial v\n            polyAdd(v, e2); // v += e2\n            cleanBytes(tHat, rHat, tmp2, e2);\n            return cipherCoder.encode([u, v]);\n        },\n        decrypt: (cipherText, privateKey) => {\n            const [u, v] = cipherCoder.decode(cipherText);\n            const sk = secretCoder.decode(privateKey); // s  ← ByteDecode_12(dkPKE)\n            const tmp = new Uint16Array(N);\n            for (let i = 0; i < K; i++)\n                polyAdd(tmp, MultiplyNTTs(sk[i], NTT.encode(u[i]))); // tmp += sk[i] * u[i]\n            polySub(v, NTT.decode(tmp)); // v += tmp\n            cleanBytes(tmp, sk, u);\n            return poly1.encode(v);\n        },\n    };\n};\nfunction createKyber(opts) {\n    const KPKE = genKPKE(opts);\n    const { HASH256, HASH512, KDF } = opts;\n    const { secretCoder: KPKESecretCoder, cipherTextLen } = KPKE;\n    const publicKeyLen = KPKE.publicKeyLen; // 384*K+32\n    const secretCoder = splitCoder(KPKE.secretKeyLen, KPKE.publicKeyLen, 32, 32);\n    const secretKeyLen = secretCoder.bytesLen;\n    const msgLen = 32;\n    return {\n        publicKeyLen,\n        msgLen,\n        keygen: (seed = randomBytes(64)) => {\n            ensureBytes(seed, 64);\n            const { publicKey, secretKey: sk } = KPKE.keygen(seed.subarray(0, 32));\n            const publicKeyHash = HASH256(publicKey);\n            // (dkPKE||ek||H(ek)||z)\n            const secretKey = secretCoder.encode([sk, publicKey, publicKeyHash, seed.subarray(32)]);\n            cleanBytes(sk, publicKeyHash);\n            return { publicKey, secretKey };\n        },\n        encapsulate: (publicKey, msg = randomBytes(32)) => {\n            ensureBytes(publicKey, publicKeyLen);\n            ensureBytes(msg, msgLen);\n            // FIPS-203 includes additional verification check for modulus\n            const eke = publicKey.subarray(0, 384 * opts.K);\n            const ek = KPKESecretCoder.encode(KPKESecretCoder.decode(eke.slice())); // Copy because of inplace encoding\n            // (Modulus check.) Perform the computation ek ← ByteEncode12(ByteDecode12(eke)).\n            // If ek = ̸ eke, the input is invalid. (See Section 4.2.1.)\n            if (!equalBytes(ek, eke)) {\n                cleanBytes(ek);\n                throw new Error('ML-KEM.encapsulate: wrong publicKey modulus');\n            }\n            cleanBytes(ek);\n            const kr = HASH512.create().update(msg).update(HASH256(publicKey)).digest(); // derive randomness\n            const cipherText = KPKE.encrypt(publicKey, msg, kr.subarray(32, 64));\n            kr.subarray(32).fill(0);\n            return { cipherText, sharedSecret: kr.subarray(0, 32) };\n        },\n        decapsulate: (cipherText, secretKey) => {\n            ensureBytes(secretKey, secretKeyLen); // 768*k + 96\n            ensureBytes(cipherText, cipherTextLen); // 32(du*k + dv)\n            const [sk, publicKey, publicKeyHash, z] = secretCoder.decode(secretKey);\n            const msg = KPKE.decrypt(cipherText, sk);\n            const kr = HASH512.create().update(msg).update(publicKeyHash).digest(); // derive randomness, Khat, rHat = G(mHat || h)\n            const Khat = kr.subarray(0, 32);\n            const cipherText2 = KPKE.encrypt(publicKey, msg, kr.subarray(32, 64)); // re-encrypt using the derived randomness\n            const isValid = equalBytes(cipherText, cipherText2); // if ciphertexts do not match, “implicitly reject”\n            const Kbar = KDF.create({ dkLen: 32 }).update(z).update(cipherText).digest();\n            cleanBytes(msg, cipherText2, !isValid ? Khat : Kbar);\n            return isValid ? Khat : Kbar;\n        },\n    };\n}\nfunction shakePRF(dkLen, key, nonce) {\n    return shake256\n        .create({ dkLen })\n        .update(key)\n        .update(new Uint8Array([nonce]))\n        .digest();\n}\nconst opts = {\n    HASH256: sha3_256,\n    HASH512: sha3_512,\n    KDF: shake256,\n    XOF: XOF128,\n    PRF: shakePRF,\n};\n/**\n * FIPS-203 ML-KEM.\n */\nexport const ml_kem512 = /* @__PURE__ */ createKyber({\n    ...opts,\n    ...PARAMS[512],\n});\nexport const ml_kem768 = /* @__PURE__ */ createKyber({\n    ...opts,\n    ...PARAMS[768],\n});\nexport const ml_kem1024 = /* @__PURE__ */ createKyber({\n    ...opts,\n    ...PARAMS[1024],\n});\n//# sourceMappingURL=ml-kem.js.map","/*! noble-post-quantum - MIT License (c) 2024 Paul Miller (paulmillr.com) */\nimport { shake256 } from '@noble/hashes/sha3';\nimport { genCrystals, XOF128, XOF256 } from './_crystals.js';\nimport { cleanBytes, ensureBytes, equalBytes, randomBytes, splitCoder, vecCoder, concatBytes, } from './utils.js';\n/*\nLattice-based digital signature algorithm. See\n[official site](https://www.pq-crystals.org/dilithium/index.shtml),\n[repo](https://github.com/pq-crystals/dilithium).\nDilithium has similar internals to Kyber, but their keys and params are different.\n\n*/\n// Constants\nconst N = 256;\n// 2**23 − 2**13 + 1, 23 bits: multiply will be 46. We have enough precision in JS to avoid bigints\nconst Q = 8380417;\nconst ROOT_OF_UNITY = 1753;\n// f = 256**−1 mod q, pow(256, -1, q) = 8347681 (python3)\nconst F = 8347681;\nconst D = 13;\n// Dilithium is kinda parametrized over GAMMA2, but everything will break with any other value.\nconst GAMMA2_1 = Math.floor((Q - 1) / 88) | 0;\nconst GAMMA2_2 = Math.floor((Q - 1) / 32) | 0;\n// prettier-ignore\nexport const PARAMS = {\n    2: { K: 4, L: 4, D, GAMMA1: 2 ** 17, GAMMA2: GAMMA2_1, TAU: 39, ETA: 2, OMEGA: 80 },\n    3: { K: 6, L: 5, D, GAMMA1: 2 ** 19, GAMMA2: GAMMA2_2, TAU: 49, ETA: 4, OMEGA: 55 },\n    5: { K: 8, L: 7, D, GAMMA1: 2 ** 19, GAMMA2: GAMMA2_2, TAU: 60, ETA: 2, OMEGA: 75 },\n};\nconst newPoly = (n) => new Int32Array(n);\nconst { mod, smod, NTT, bitsCoder } = genCrystals({\n    N,\n    Q,\n    F,\n    ROOT_OF_UNITY,\n    newPoly,\n    isKyber: false,\n    brvBits: 8,\n});\nconst id = (n) => n;\nconst polyCoder = (d, compress = id, verify = id) => bitsCoder(d, {\n    encode: (i) => compress(verify(i)),\n    decode: (i) => verify(compress(i)),\n});\nconst polyAdd = (a, b) => {\n    for (let i = 0; i < a.length; i++)\n        a[i] = mod(a[i] + b[i]);\n    return a;\n};\nconst polySub = (a, b) => {\n    for (let i = 0; i < a.length; i++)\n        a[i] = mod(a[i] - b[i]);\n    return a;\n};\nconst polyShiftl = (p) => {\n    for (let i = 0; i < N; i++)\n        p[i] <<= D;\n    return p;\n};\nconst polyChknorm = (p, B) => {\n    // Not very sure about this, but FIPS204 doesn't provide any function for that :(\n    for (let i = 0; i < N; i++)\n        if (Math.abs(smod(p[i])) >= B)\n            return true;\n    return false;\n};\nconst MultiplyNTTs = (a, b) => {\n    // NOTE: we don't use montgomery reduction in code, since it requires 64 bit ints,\n    // which is not available in JS. mod(a[i] * b[i]) is ok, since Q is 23 bit,\n    // which means a[i] * b[i] is 46 bit, which is safe to use in JS. (number is 53 bits).\n    // Barrett reduction is slower than mod :(\n    const c = newPoly(N);\n    for (let i = 0; i < a.length; i++)\n        c[i] = mod(a[i] * b[i]);\n    return c;\n};\n// Return poly in NTT representation\nfunction RejNTTPoly(xof) {\n    // Samples a polynomial ∈ Tq.\n    const r = newPoly(N);\n    // NOTE: we can represent 3xu24 as 4xu32, but it doesn't improve perf :(\n    for (let j = 0; j < N;) {\n        const b = xof();\n        if (b.length % 3)\n            throw new Error('RejNTTPoly: unaligned block');\n        for (let i = 0; j < N && i <= b.length - 3; i += 3) {\n            const t = (b[i + 0] | (b[i + 1] << 8) | (b[i + 2] << 16)) & 0x7fffff; // 3 bytes\n            if (t < Q)\n                r[j++] = t;\n        }\n    }\n    return r;\n}\nconst EMPTY = new Uint8Array(0);\nfunction getDilithium(opts) {\n    const { K, L, GAMMA1, GAMMA2, TAU, ETA, OMEGA } = opts;\n    const { CRH_BYTES, TR_BYTES, C_TILDE_BYTES, XOF128, XOF256 } = opts;\n    if (![2, 4].includes(ETA))\n        throw new Error('Wrong ETA');\n    if (![1 << 17, 1 << 19].includes(GAMMA1))\n        throw new Error('Wrong GAMMA1');\n    if (![GAMMA2_1, GAMMA2_2].includes(GAMMA2))\n        throw new Error('Wrong GAMMA2');\n    const BETA = TAU * ETA;\n    const decompose = (r) => {\n        // Decomposes r into (r1, r0) such that r ≡ r1(2γ2) + r0 mod q.\n        const rPlus = mod(r);\n        const r0 = smod(rPlus, 2 * GAMMA2) | 0;\n        if (rPlus - r0 === Q - 1)\n            return { r1: 0 | 0, r0: (r0 - 1) | 0 };\n        const r1 = Math.floor((rPlus - r0) / (2 * GAMMA2)) | 0;\n        return { r1, r0 }; // r1 = HighBits, r0 = LowBits\n    };\n    const HighBits = (r) => decompose(r).r1;\n    const LowBits = (r) => decompose(r).r0;\n    const MakeHint = (z, r) => {\n        // Compute hint bit indicating whether adding z to r alters the high bits of r.\n        // From dilithium code\n        const res0 = z <= GAMMA2 || z > Q - GAMMA2 || (z === Q - GAMMA2 && r === 0) ? 0 : 1;\n        // from FIPS204:\n        // // const r1 = HighBits(r);\n        // // const v1 = HighBits(r + z);\n        // // const res1 = +(r1 !== v1);\n        // But they return different results! However, decompose is same.\n        // So, either there is a bug in Dilithium ref implementation or in FIPS204.\n        // For now, lets use dilithium one, so test vectors can be passed.\n        // See\n        // https://github.com/GiacomoPope/dilithium-py?tab=readme-ov-file#optimising-decomposition-and-making-hints\n        return res0;\n    };\n    const UseHint = (h, r) => {\n        // Returns the high bits of r adjusted according to hint h\n        const m = Math.floor((Q - 1) / (2 * GAMMA2));\n        const { r1, r0 } = decompose(r);\n        // 3: if h = 1 and r0 > 0 return (r1 + 1) mod m\n        // 4: if h = 1 and r0 ≤ 0 return (r1 − 1) mod m\n        if (h === 1)\n            return r0 > 0 ? mod(r1 + 1, m) | 0 : mod(r1 - 1, m) | 0;\n        return r1 | 0;\n    };\n    const Power2Round = (r) => {\n        // Decomposes r into (r1, r0) such that r ≡ r1*(2**d) + r0 mod q.\n        const rPlus = mod(r);\n        const r0 = smod(rPlus, 2 ** D) | 0;\n        return { r1: Math.floor((rPlus - r0) / 2 ** D) | 0, r0 };\n    };\n    const hintCoder = {\n        bytesLen: OMEGA + K,\n        encode: (h) => {\n            if (h === false)\n                throw new Error('hint.encode: hint is false'); // should never happen\n            const res = new Uint8Array(OMEGA + K);\n            for (let i = 0, k = 0; i < K; i++) {\n                for (let j = 0; j < N; j++)\n                    if (h[i][j] !== 0)\n                        res[k++] = j;\n                res[OMEGA + i] = k;\n            }\n            return res;\n        },\n        decode: (buf) => {\n            const h = [];\n            let k = 0;\n            for (let i = 0; i < K; i++) {\n                const hi = newPoly(N);\n                if (buf[OMEGA + i] < k || buf[OMEGA + i] > OMEGA)\n                    return false;\n                for (let j = k; j < buf[OMEGA + i]; j++) {\n                    if (j > k && buf[j] <= buf[j - 1])\n                        return false;\n                    hi[buf[j]] = 1;\n                }\n                k = buf[OMEGA + i];\n                h.push(hi);\n            }\n            for (let j = k; j < OMEGA; j++)\n                if (buf[j] !== 0)\n                    return false;\n            return h;\n        },\n    };\n    const ETACoder = polyCoder(ETA === 2 ? 3 : 4, (i) => ETA - i, (i) => {\n        if (!(-ETA <= i && i <= ETA))\n            throw new Error(`malformed key s1/s3 ${i} outside of ETA range [${-ETA}, ${ETA}]`);\n        return i;\n    });\n    const T0Coder = polyCoder(13, (i) => (1 << (D - 1)) - i);\n    const T1Coder = polyCoder(10);\n    // Requires smod. Need to fix!\n    const ZCoder = polyCoder(GAMMA1 === 1 << 17 ? 18 : 20, (i) => smod(GAMMA1 - i));\n    const W1Coder = polyCoder(GAMMA2 === GAMMA2_1 ? 6 : 4);\n    const W1Vec = vecCoder(W1Coder, K);\n    // Main structures\n    const publicCoder = splitCoder(32, vecCoder(T1Coder, K));\n    const secretCoder = splitCoder(32, 32, TR_BYTES, vecCoder(ETACoder, L), vecCoder(ETACoder, K), vecCoder(T0Coder, K));\n    const sigCoder = splitCoder(C_TILDE_BYTES, vecCoder(ZCoder, L), hintCoder);\n    const CoefFromHalfByte = ETA === 2\n        ? (n) => (n < 15 ? 2 - (n % 5) : false)\n        : (n) => (n < 9 ? 4 - n : false);\n    // Return poly in NTT representation\n    function RejBoundedPoly(xof) {\n        // Samples an element a ∈ Rq with coeffcients in [−η, η] computed via rejection sampling from ρ.\n        const r = newPoly(N);\n        for (let j = 0; j < N;) {\n            const b = xof();\n            for (let i = 0; j < N && i < b.length; i += 1) {\n                // half byte. Should be superfast with vector instructions. But very slow with js :(\n                const d1 = CoefFromHalfByte(b[i] & 0x0f);\n                const d2 = CoefFromHalfByte((b[i] >> 4) & 0x0f);\n                if (d1 !== false)\n                    r[j++] = d1;\n                if (j < N && d2 !== false)\n                    r[j++] = d2;\n            }\n        }\n        return r;\n    }\n    const SampleInBall = (seed) => {\n        // Samples a polynomial c ∈ Rq with coeffcients from {−1, 0, 1} and Hamming weight τ\n        const pre = newPoly(N);\n        const s = shake256.create({}).update(seed);\n        const buf = new Uint8Array(shake256.blockLen);\n        s.xofInto(buf);\n        const masks = buf.slice(0, 8);\n        for (let i = N - TAU, pos = 8, maskPos = 0, maskBit = 0; i < N; i++) {\n            let b = i + 1;\n            for (; b > i;) {\n                b = buf[pos++];\n                if (pos < shake256.blockLen)\n                    continue;\n                s.xofInto(buf);\n                pos = 0;\n            }\n            pre[i] = pre[b];\n            pre[b] = 1 - (((masks[maskPos] >> maskBit++) & 1) << 1);\n            if (maskBit >= 8) {\n                maskPos++;\n                maskBit = 0;\n            }\n        }\n        return pre;\n    };\n    const polyPowerRound = (p) => {\n        const res0 = newPoly(N);\n        const res1 = newPoly(N);\n        for (let i = 0; i < p.length; i++) {\n            const { r0, r1 } = Power2Round(p[i]);\n            res0[i] = r0;\n            res1[i] = r1;\n        }\n        return { r0: res0, r1: res1 };\n    };\n    const polyUseHint = (u, h) => {\n        for (let i = 0; i < N; i++)\n            u[i] = UseHint(h[i], u[i]);\n        return u;\n    };\n    const polyMakeHint = (a, b) => {\n        const v = newPoly(N);\n        let cnt = 0;\n        for (let i = 0; i < N; i++) {\n            const h = MakeHint(a[i], b[i]);\n            v[i] = h;\n            cnt += h;\n        }\n        return { v, cnt };\n    };\n    const signRandBytes = 32;\n    const seedCoder = splitCoder(32, 64, 32);\n    // API & argument positions are exactly as in FIPS204.\n    const internal = {\n        signRandBytes,\n        keygen: (seed = randomBytes(32)) => {\n            // H(𝜉||IntegerToBytes(𝑘, 1)||IntegerToBytes(ℓ, 1), 128) 2: ▷ expand seed\n            const seedDst = new Uint8Array(32 + 2);\n            seedDst.set(seed);\n            seedDst[32] = K;\n            seedDst[33] = L;\n            const [rho, rhoPrime, K_] = seedCoder.decode(shake256(seedDst, { dkLen: seedCoder.bytesLen }));\n            const xofPrime = XOF256(rhoPrime);\n            const s1 = [];\n            for (let i = 0; i < L; i++)\n                s1.push(RejBoundedPoly(xofPrime.get(i & 0xff, (i >> 8) & 0xff)));\n            const s2 = [];\n            for (let i = L; i < L + K; i++)\n                s2.push(RejBoundedPoly(xofPrime.get(i & 0xff, (i >> 8) & 0xff)));\n            const s1Hat = s1.map((i) => NTT.encode(i.slice()));\n            const t0 = [];\n            const t1 = [];\n            const xof = XOF128(rho);\n            const t = newPoly(N);\n            for (let i = 0; i < K; i++) {\n                // t ← NTT−1(A*NTT(s1)) + s2\n                t.fill(0); // don't-reallocate\n                for (let j = 0; j < L; j++) {\n                    const aij = RejNTTPoly(xof.get(j, i)); // super slow!\n                    polyAdd(t, MultiplyNTTs(aij, s1Hat[j]));\n                }\n                NTT.decode(t);\n                const { r0, r1 } = polyPowerRound(polyAdd(t, s2[i])); // (t1, t0) ← Power2Round(t, d)\n                t0.push(r0);\n                t1.push(r1);\n            }\n            const publicKey = publicCoder.encode([rho, t1]); // pk ← pkEncode(ρ, t1)\n            const tr = shake256(publicKey, { dkLen: TR_BYTES }); // tr ← H(BytesToBits(pk), 512)\n            const secretKey = secretCoder.encode([rho, K_, tr, s1, s2, t0]); // sk ← skEncode(ρ, K,tr, s1, s2, t0)\n            xof.clean();\n            xofPrime.clean();\n            // STATS\n            // Kyber512:  { calls: 4, xofs: 12 }, Kyber768: { calls: 9, xofs: 27 }, Kyber1024: { calls: 16, xofs: 48 }\n            // DSA44:    { calls: 24, xofs: 24 }, DSA65:    { calls: 41, xofs: 41 }, DSA87:    { calls: 71, xofs: 71 }\n            cleanBytes(rho, rhoPrime, K_, s1, s2, s1Hat, t, t0, t1, tr, seedDst);\n            return { publicKey, secretKey };\n        },\n        // NOTE: random is optional.\n        sign: (secretKey, msg, random) => {\n            // This part can be pre-cached per secretKey, but there is only minor performance improvement,\n            // since we re-use a lot of variables to computation.\n            const [rho, _K, tr, s1, s2, t0] = secretCoder.decode(secretKey); // (ρ, K,tr, s1, s2, t0) ← skDecode(sk)\n            // Cache matrix to avoid re-compute later\n            const A = []; // A ← ExpandA(ρ)\n            const xof = XOF128(rho);\n            for (let i = 0; i < K; i++) {\n                const pv = [];\n                for (let j = 0; j < L; j++)\n                    pv.push(RejNTTPoly(xof.get(j, i)));\n                A.push(pv);\n            }\n            xof.clean();\n            for (let i = 0; i < L; i++)\n                NTT.encode(s1[i]); // sˆ1 ← NTT(s1)\n            for (let i = 0; i < K; i++) {\n                NTT.encode(s2[i]); // sˆ2 ← NTT(s2)\n                NTT.encode(t0[i]); // tˆ0 ← NTT(t0)\n            }\n            // This part is per msg\n            const mu = shake256.create({ dkLen: CRH_BYTES }).update(tr).update(msg).digest(); // 6: µ ← H(tr||M, 512) ▷ Compute message representative µ\n            // Compute private random seed\n            const rnd = random ? random : new Uint8Array(32);\n            ensureBytes(rnd);\n            const rhoprime = shake256\n                .create({ dkLen: CRH_BYTES })\n                .update(_K)\n                .update(rnd)\n                .update(mu)\n                .digest(); // ρ′← H(K||rnd||µ, 512)\n            ensureBytes(rhoprime, CRH_BYTES);\n            const x256 = XOF256(rhoprime, ZCoder.bytesLen);\n            //  Rejection sampling loop\n            main_loop: for (let kappa = 0;;) {\n                const y = [];\n                // y ← ExpandMask(ρ , κ)\n                for (let i = 0; i < L; i++, kappa++)\n                    y.push(ZCoder.decode(x256.get(kappa & 0xff, kappa >> 8)()));\n                const z = y.map((i) => NTT.encode(i.slice()));\n                const w = [];\n                for (let i = 0; i < K; i++) {\n                    // w ← NTT−1(A ◦ NTT(y))\n                    const wi = newPoly(N);\n                    for (let j = 0; j < L; j++)\n                        polyAdd(wi, MultiplyNTTs(A[i][j], z[j]));\n                    NTT.decode(wi);\n                    w.push(wi);\n                }\n                const w1 = w.map((j) => j.map(HighBits)); // w1 ← HighBits(w)\n                // Commitment hash: c˜ ∈{0, 1 2λ } ← H(µ||w1Encode(w1), 2λ)\n                const cTilde = shake256\n                    .create({ dkLen: C_TILDE_BYTES })\n                    .update(mu)\n                    .update(W1Vec.encode(w1))\n                    .digest();\n                // Verifer’s challenge\n                const cHat = NTT.encode(SampleInBall(cTilde)); // c ← SampleInBall(c˜1); cˆ ← NTT(c)\n                // ⟨⟨cs1⟩⟩ ← NTT−1(cˆ◦ sˆ1)\n                const cs1 = s1.map((i) => MultiplyNTTs(i, cHat));\n                for (let i = 0; i < L; i++) {\n                    polyAdd(NTT.decode(cs1[i]), y[i]); // z ← y + ⟨⟨cs1⟩⟩\n                    if (polyChknorm(cs1[i], GAMMA1 - BETA))\n                        continue main_loop; // ||z||∞ ≥ γ1 − β\n                }\n                // cs1 is now z (▷ Signer’s response)\n                let cnt = 0;\n                const h = [];\n                for (let i = 0; i < K; i++) {\n                    const cs2 = NTT.decode(MultiplyNTTs(s2[i], cHat)); // ⟨⟨cs2⟩⟩ ← NTT−1(cˆ◦ sˆ2)\n                    const r0 = polySub(w[i], cs2).map(LowBits); // r0 ← LowBits(w − ⟨⟨cs2⟩⟩)\n                    if (polyChknorm(r0, GAMMA2 - BETA))\n                        continue main_loop; // ||r0||∞ ≥ γ2 − β\n                    const ct0 = NTT.decode(MultiplyNTTs(t0[i], cHat)); // ⟨⟨ct0⟩⟩ ← NTT−1(cˆ◦ tˆ0)\n                    if (polyChknorm(ct0, GAMMA2))\n                        continue main_loop;\n                    polyAdd(r0, ct0);\n                    // ▷ Signer’s hint\n                    const hint = polyMakeHint(r0, w1[i]); // h ← MakeHint(−⟨⟨ct0⟩⟩, w− ⟨⟨cs2⟩⟩ + ⟨⟨ct0⟩⟩)\n                    h.push(hint.v);\n                    cnt += hint.cnt;\n                }\n                if (cnt > OMEGA)\n                    continue; // the number of 1’s in h is greater than ω\n                x256.clean();\n                const res = sigCoder.encode([cTilde, cs1, h]); // σ ← sigEncode(c˜, z mod±q, h)\n                // rho, _K, tr is subarray of secretKey, cannot clean.\n                cleanBytes(cTilde, cs1, h, cHat, w1, w, z, y, rhoprime, mu, s1, s2, t0, ...A);\n                return res;\n            }\n            // @ts-ignore\n            throw new Error('Unreachable code path reached, report this error');\n        },\n        verify: (publicKey, msg, sig) => {\n            // ML-DSA.Verify(pk, M, σ): Verifes a signature σ for a message M.\n            const [rho, t1] = publicCoder.decode(publicKey); // (ρ, t1) ← pkDecode(pk)\n            const tr = shake256(publicKey, { dkLen: TR_BYTES }); // 6: tr ← H(BytesToBits(pk), 512)\n            if (sig.length !== sigCoder.bytesLen)\n                return false; // return false instead of exception\n            const [cTilde, z, h] = sigCoder.decode(sig); // (c˜, z, h) ← sigDecode(σ), ▷ Signer’s commitment hash c ˜, response z and hint\n            if (h === false)\n                return false; // if h = ⊥ then return false\n            for (let i = 0; i < L; i++)\n                if (polyChknorm(z[i], GAMMA1 - BETA))\n                    return false;\n            const mu = shake256.create({ dkLen: CRH_BYTES }).update(tr).update(msg).digest(); // 7: µ ← H(tr||M, 512)\n            // Compute verifer’s challenge from c˜\n            const c = NTT.encode(SampleInBall(cTilde)); // c ← SampleInBall(c˜1)\n            const zNtt = z.map((i) => i.slice()); // zNtt = NTT(z)\n            for (let i = 0; i < L; i++)\n                NTT.encode(zNtt[i]);\n            const wTick1 = [];\n            const xof = XOF128(rho);\n            for (let i = 0; i < K; i++) {\n                const ct12d = MultiplyNTTs(NTT.encode(polyShiftl(t1[i])), c); //c * t1 * (2**d)\n                const Az = newPoly(N); // // A * z\n                for (let j = 0; j < L; j++) {\n                    const aij = RejNTTPoly(xof.get(j, i)); // A[i][j] inplace\n                    polyAdd(Az, MultiplyNTTs(aij, zNtt[j]));\n                }\n                // wApprox = A*z - c*t1 * (2**d)\n                const wApprox = NTT.decode(polySub(Az, ct12d));\n                // Reconstruction of signer’s commitment\n                wTick1.push(polyUseHint(wApprox, h[i])); // w ′ ← UseHint(h, w'approx )\n            }\n            xof.clean();\n            // c˜′← H (µ||w1Encode(w′1), 2λ),  Hash it; this should match c˜\n            const c2 = shake256\n                .create({ dkLen: C_TILDE_BYTES })\n                .update(mu)\n                .update(W1Vec.encode(wTick1))\n                .digest();\n            // Additional checks in FIPS-204:\n            // [[ ||z||∞ < γ1 − β ]] and [[c ˜ = c˜′]] and [[number of 1’s in h is ≤ ω]]\n            for (const t of h) {\n                const sum = t.reduce((acc, i) => acc + i, 0);\n                if (!(sum <= OMEGA))\n                    return false;\n            }\n            for (const t of z)\n                if (polyChknorm(t, GAMMA1 - BETA))\n                    return false;\n            return equalBytes(cTilde, c2);\n        },\n    };\n    const getMessage = (msg, ctx = EMPTY) => {\n        ensureBytes(msg);\n        ensureBytes(ctx);\n        if (ctx.length > 255)\n            throw new Error('context should be less than 255 bytes');\n        return concatBytes(new Uint8Array([0, ctx.length]), ctx, msg);\n    };\n    // TODO: no hash-dsa vectors for now, so we don't implement it yet\n    return {\n        internal,\n        keygen: internal.keygen,\n        signRandBytes: internal.signRandBytes,\n        sign: (secretKey, msg, ctx = EMPTY, random) => {\n            const M = getMessage(msg, ctx);\n            const res = internal.sign(secretKey, M, random);\n            M.fill(0);\n            return res;\n        },\n        verify: (publicKey, msg, sig, ctx = EMPTY) => {\n            return internal.verify(publicKey, getMessage(msg, ctx), sig);\n        },\n    };\n}\n// ML-DSA\nexport const ml_dsa44 = /* @__PURE__ */ getDilithium({\n    ...PARAMS[2],\n    CRH_BYTES: 64,\n    TR_BYTES: 64,\n    C_TILDE_BYTES: 32,\n    XOF128,\n    XOF256,\n});\nexport const ml_dsa65 = /* @__PURE__ */ getDilithium({\n    ...PARAMS[3],\n    CRH_BYTES: 64,\n    TR_BYTES: 64,\n    C_TILDE_BYTES: 48,\n    XOF128,\n    XOF256,\n});\nexport const ml_dsa87 = /* @__PURE__ */ getDilithium({\n    ...PARAMS[5],\n    CRH_BYTES: 64,\n    TR_BYTES: 64,\n    C_TILDE_BYTES: 64,\n    XOF128,\n    XOF256,\n});\n//# sourceMappingURL=ml-dsa.js.map"],"names":["anumber","n","Number","isSafeInteger","Error","abytes","b","lengths","a","Uint8Array","ArrayBuffer","isView","constructor","name","length","includes","aexists","instance","checkFinished","destroyed","finished","U32_MASK64","BigInt","_32n","fromBig","le","h","l","split","lst","Ah","Uint32Array","Al","i","crypto","globalThis","undefined","u32","arr","buffer","byteOffset","Math","floor","byteLength","isLE","byteSwap32","word","toBytes","data","str","TextEncoder","encode","utf8ToBytes","Hash","clone","this","_cloneInto","SHA3_PI","SHA3_ROTL","_SHA3_IOTA","_0n","_1n","_2n","_7n","_256n","_0x71n","round","R","x","y","push","t","j","SHA3_IOTA_H","SHA3_IOTA_L","rotlH","s","rotlBH","rotlSH","rotlL","rotlBL","rotlSL","Keccak","blockLen","suffix","outputLen","enableXOF","rounds","super","pos","posOut","state","state32","keccak","B","idx1","idx0","B0","B1","Th","Tl","curH","curL","shift","PI","fill","keccakP","update","len","take","min","finish","writeInto","out","bufferOut","set","subarray","xofInto","xof","bytes","digestInto","aoutput","destroy","digest","to","gen","hashCons","hashC","msg","tmp","create","wrapConstructor","sha3_256","sha3_512","genShake","opts","wrapXOFConstructorWithOpts","dkLen","shake128","shake256","ensureBytes","randomBytes","bytesLength","getRandomValues","equalBytes","diff","splitCoder","getLength","c","bytesLen","reduce","sum","bufs","res","decode","buf","vecCoder","vecLen","u","r","cleanBytes","list","Array","isArray","getMask","bits","bitReversal","revrsd","toString","padStart","slice","reverse","join","parseInt","genCrystals","newPoly","N","Q","F","ROOT_OF_UNITY","brvBits","isKyber","mod","modulo","result","nttZetas","p","getZettas","LEN1","LEN2","NTT","k","start","zeta","smod","bitsCoder","d","mask","poly","bufLen","createXofShake","shake","seed","_seed","seedLen","calls","xofs","stats","get","clean","XOF128","XOF256","Uint16Array","polyCoder","compress","polyAdd","MultiplyNTTs","f","g","z","c0","c1","a0","a1","b0","b1","SampleNTT","d1","d2","sampleCBD","PRF","nonce","eta","b32","bb","t0","genKPKE","K","XOF","HASH512","ETA1","ETA2","du","dv","poly1","polyV","polyU","publicCoder","secretCoder","cipherCoder","seedCoder","secretKeyLen","publicKeyLen","cipherTextLen","keygen","seedDst","seedHash","rho","sigma","sHat","tHat","e","publicKey","secretKey","encrypt","rHat","tmp2","e1","e2","v","decrypt","cipherText","privateKey","sk","polySub","createKyber","KPKE","HASH256","KDF","KPKESecretCoder","msgLen","publicKeyHash","encapsulate","eke","ek","kr","sharedSecret","decapsulate","Khat","cipherText2","isValid","Kbar","ml_kem768","key","RBGstrength","GAMMA2_1","GAMMA2_2","PARAMS","L","D","GAMMA1","GAMMA2","TAU","ETA","OMEGA","Int32Array","id","verify","polyShiftl","polyChknorm","abs","RejNTTPoly","EMPTY","getDilithium","CRH_BYTES","TR_BYTES","C_TILDE_BYTES","BETA","decompose","rPlus","r0","r1","HighBits","LowBits","UseHint","m","Power2Round","hintCoder","hi","ETACoder","T0Coder","T1Coder","ZCoder","W1Vec","sigCoder","CoefFromHalfByte","RejBoundedPoly","SampleInBall","pre","masks","maskPos","maskBit","polyPowerRound","res0","res1","polyUseHint","polyMakeHint","cnt","internal","signRandBytes","rhoPrime","K_","xofPrime","s1","s2","s1Hat","map","t1","aij","tr","sign","random","_K","A","pv","mu","rnd","rhoprime","x256","main_loop","kappa","w","wi","w1","cTilde","cHat","cs1","cs2","ct0","hint","sig","zNtt","wTick1","ct12d","Az","wApprox","c2","acc","getMessage","ctx","arrays","pad","concatBytes","M","ml_dsa65"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8]}