@bonfida/spl-name-service 3.0.20 → 3.0.21

package/dist/cjs/node_modules/@noble/curves/esm/ed25519.js.map

@@ -1 +1 @@
-{"version":3,"file":"ed25519.js","sources":["../../../../../../node_modules/@noble/curves/esm/ed25519.js"],"sourcesContent":["/**\n * ed25519 Twisted Edwards curve with following addons:\n * - X25519 ECDH\n * - Ristretto cofactor elimination\n * - Elligator hash-to-group / point indistinguishability\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { sha512 } from '@noble/hashes/sha2';\nimport { concatBytes, randomBytes, utf8ToBytes } from '@noble/hashes/utils';\nimport { pippenger } from \"./abstract/curve.js\";\nimport { twistedEdwards } from \"./abstract/edwards.js\";\nimport { createHasher, expand_message_xmd, } from \"./abstract/hash-to-curve.js\";\nimport { Field, FpInvertBatch, FpSqrtEven, isNegativeLE, mod, pow2 } from \"./abstract/modular.js\";\nimport { montgomery } from \"./abstract/montgomery.js\";\nimport { bytesToHex, bytesToNumberLE, ensureBytes, equalBytes, numberToBytesLE, } from \"./abstract/utils.js\";\n// 2n**255n - 19n\nconst ED25519_P = BigInt('57896044618658097711785492504343953926634992332820282019728792003956564819949');\n// √(-1) aka √(a) aka 2^((p-1)/4)\n// Fp.sqrt(Fp.neg(1))\nconst ED25519_SQRT_M1 = /* @__PURE__ */ BigInt('19681161376707505956807079304988542015446066515923890162744021073123829784752');\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3);\n// prettier-ignore\nconst _5n = BigInt(5), _8n = BigInt(8);\nfunction ed25519_pow_2_252_3(x) {\n    // prettier-ignore\n    const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);\n    const P = ED25519_P;\n    const x2 = (x * x) % P;\n    const b2 = (x2 * x) % P; // x^3, 11\n    const b4 = (pow2(b2, _2n, P) * b2) % P; // x^15, 1111\n    const b5 = (pow2(b4, _1n, P) * x) % P; // x^31\n    const b10 = (pow2(b5, _5n, P) * b5) % P;\n    const b20 = (pow2(b10, _10n, P) * b10) % P;\n    const b40 = (pow2(b20, _20n, P) * b20) % P;\n    const b80 = (pow2(b40, _40n, P) * b40) % P;\n    const b160 = (pow2(b80, _80n, P) * b80) % P;\n    const b240 = (pow2(b160, _80n, P) * b80) % P;\n    const b250 = (pow2(b240, _10n, P) * b10) % P;\n    const pow_p_5_8 = (pow2(b250, _2n, P) * x) % P;\n    // ^ To pow to (p+3)/8, multiply it by x.\n    return { pow_p_5_8, b2 };\n}\nfunction adjustScalarBytes(bytes) {\n    // Section 5: For X25519, in order to decode 32 random bytes as an integer scalar,\n    // set the three least significant bits of the first byte\n    bytes[0] &= 248; // 0b1111_1000\n    // and the most significant bit of the last to zero,\n    bytes[31] &= 127; // 0b0111_1111\n    // set the second most significant bit of the last byte to 1\n    bytes[31] |= 64; // 0b0100_0000\n    return bytes;\n}\n// sqrt(u/v)\nfunction uvRatio(u, v) {\n    const P = ED25519_P;\n    const v3 = mod(v * v * v, P); // v³\n    const v7 = mod(v3 * v3 * v, P); // v⁷\n    // (p+3)/8 and (p-5)/8\n    const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;\n    let x = mod(u * v3 * pow, P); // (uv³)(uv⁷)^(p-5)/8\n    const vx2 = mod(v * x * x, P); // vx²\n    const root1 = x; // First root candidate\n    const root2 = mod(x * ED25519_SQRT_M1, P); // Second root candidate\n    const useRoot1 = vx2 === u; // If vx² = u (mod p), x is a square root\n    const useRoot2 = vx2 === mod(-u, P); // If vx² = -u, set x <-- x * 2^((p-1)/4)\n    const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P); // There is no valid root, vx² = -u√(-1)\n    if (useRoot1)\n        x = root1;\n    if (useRoot2 || noRoot)\n        x = root2; // We return root2 anyway, for const-time\n    if (isNegativeLE(x, P))\n        x = mod(-x, P);\n    return { isValid: useRoot1 || useRoot2, value: x };\n}\n/** Weird / bogus points, useful for debugging. */\nexport const ED25519_TORSION_SUBGROUP = [\n    '0100000000000000000000000000000000000000000000000000000000000000',\n    'c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a',\n    '0000000000000000000000000000000000000000000000000000000000000080',\n    '26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc05',\n    'ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f',\n    '26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc85',\n    '0000000000000000000000000000000000000000000000000000000000000000',\n    'c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa',\n];\nconst Fp = /* @__PURE__ */ (() => Field(ED25519_P, undefined, true))();\nconst ed25519Defaults = /* @__PURE__ */ (() => ({\n    // Removing Fp.create() will still work, and is 10% faster on sign\n    a: Fp.create(BigInt(-1)),\n    // d is -121665/121666 a.k.a. Fp.neg(121665 * Fp.inv(121666))\n    d: BigInt('37095705934669439343138083508754565189542113879843219016388785533085940283555'),\n    // Finite field 2n**255n - 19n\n    Fp,\n    // Subgroup order 2n**252n + 27742317777372353535851937790883648493n;\n    n: BigInt('7237005577332262213973186563042994240857116359379907606001950938285454250989'),\n    h: _8n,\n    Gx: BigInt('15112221349535400772501151409588531511454012693041857206046113283949847762202'),\n    Gy: BigInt('46316835694926478169428394003475163141307993866256225615783033603165251855960'),\n    hash: sha512,\n    randomBytes,\n    adjustScalarBytes,\n    // dom2\n    // Ratio of u to v. Allows us to combine inversion and square root. Uses algo from RFC8032 5.1.3.\n    // Constant-time, u/√v\n    uvRatio,\n}))();\n/**\n * ed25519 curve with EdDSA signatures.\n * @example\n * import { ed25519 } from '@noble/curves/ed25519';\n * const priv = ed25519.utils.randomPrivateKey();\n * const pub = ed25519.getPublicKey(priv);\n * const msg = new TextEncoder().encode('hello');\n * const sig = ed25519.sign(msg, priv);\n * ed25519.verify(sig, msg, pub); // Default mode: follows ZIP215\n * ed25519.verify(sig, msg, pub, { zip215: false }); // RFC8032 / FIPS 186-5\n */\nexport const ed25519 = /* @__PURE__ */ (() => twistedEdwards(ed25519Defaults))();\nfunction ed25519_domain(data, ctx, phflag) {\n    if (ctx.length > 255)\n        throw new Error('Context is too big');\n    return concatBytes(utf8ToBytes('SigEd25519 no Ed25519 collisions'), new Uint8Array([phflag ? 1 : 0, ctx.length]), ctx, data);\n}\nexport const ed25519ctx = /* @__PURE__ */ (() => twistedEdwards({\n    ...ed25519Defaults,\n    domain: ed25519_domain,\n}))();\nexport const ed25519ph = /* @__PURE__ */ (() => twistedEdwards(Object.assign({}, ed25519Defaults, {\n    domain: ed25519_domain,\n    prehash: sha512,\n})))();\n/**\n * ECDH using curve25519 aka x25519.\n * @example\n * import { x25519 } from '@noble/curves/ed25519';\n * const priv = 'a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4';\n * const pub = 'e6db6867583030db3594c1a424b15f7c726624ec26b3353b10a903a6d0ab1c4c';\n * x25519.getSharedSecret(priv, pub) === x25519.scalarMult(priv, pub); // aliases\n * x25519.getPublicKey(priv) === x25519.scalarMultBase(priv);\n * x25519.getPublicKey(x25519.utils.randomPrivateKey());\n */\nexport const x25519 = /* @__PURE__ */ (() => montgomery({\n    P: ED25519_P,\n    type: 'x25519',\n    powPminus2: (x) => {\n        const P = ED25519_P;\n        // x^(p-2) aka x^(2^255-21)\n        const { pow_p_5_8, b2 } = ed25519_pow_2_252_3(x);\n        return mod(pow2(pow_p_5_8, _3n, P) * b2, P);\n    },\n    adjustScalarBytes,\n    randomBytes,\n}))();\n/**\n * Converts ed25519 public key to x25519 public key. Uses formula:\n * * `(u, v) = ((1+y)/(1-y), sqrt(-486664)*u/x)`\n * * `(x, y) = (sqrt(-486664)*u/v, (u-1)/(u+1))`\n * @example\n *   const someonesPub = ed25519.getPublicKey(ed25519.utils.randomPrivateKey());\n *   const aPriv = x25519.utils.randomPrivateKey();\n *   x25519.getSharedSecret(aPriv, edwardsToMontgomeryPub(someonesPub))\n */\nexport function edwardsToMontgomeryPub(edwardsPub) {\n    const { y } = ed25519.ExtendedPoint.fromHex(edwardsPub);\n    const _1n = BigInt(1);\n    return Fp.toBytes(Fp.create((_1n + y) * Fp.inv(_1n - y)));\n}\nexport const edwardsToMontgomery = edwardsToMontgomeryPub; // deprecated\n/**\n * Converts ed25519 secret key to x25519 secret key.\n * @example\n *   const someonesPub = x25519.getPublicKey(x25519.utils.randomPrivateKey());\n *   const aPriv = ed25519.utils.randomPrivateKey();\n *   x25519.getSharedSecret(edwardsToMontgomeryPriv(aPriv), someonesPub)\n */\nexport function edwardsToMontgomeryPriv(edwardsPriv) {\n    const hashed = ed25519Defaults.hash(edwardsPriv.subarray(0, 32));\n    return ed25519Defaults.adjustScalarBytes(hashed).subarray(0, 32);\n}\n// Hash To Curve Elligator2 Map (NOTE: different from ristretto255 elligator)\n// NOTE: very important part is usage of FpSqrtEven for ELL2_C1_EDWARDS, since\n// SageMath returns different root first and everything falls apart\nconst ELL2_C1 = /* @__PURE__ */ (() => (Fp.ORDER + _3n) / _8n)(); // 1. c1 = (q + 3) / 8       # Integer arithmetic\nconst ELL2_C2 = /* @__PURE__ */ (() => Fp.pow(_2n, ELL2_C1))(); // 2. c2 = 2^c1\nconst ELL2_C3 = /* @__PURE__ */ (() => Fp.sqrt(Fp.neg(Fp.ONE)))(); // 3. c3 = sqrt(-1)\n// prettier-ignore\nfunction map_to_curve_elligator2_curve25519(u) {\n    const ELL2_C4 = (Fp.ORDER - _5n) / _8n; // 4. c4 = (q - 5) / 8       # Integer arithmetic\n    const ELL2_J = BigInt(486662);\n    let tv1 = Fp.sqr(u); //  1.  tv1 = u^2\n    tv1 = Fp.mul(tv1, _2n); //  2.  tv1 = 2 * tv1\n    let xd = Fp.add(tv1, Fp.ONE); //  3.   xd = tv1 + 1         # Nonzero: -1 is square (mod p), tv1 is not\n    let x1n = Fp.neg(ELL2_J); //  4.  x1n = -J              # x1 = x1n / xd = -J / (1 + 2 * u^2)\n    let tv2 = Fp.sqr(xd); //  5.  tv2 = xd^2\n    let gxd = Fp.mul(tv2, xd); //  6.  gxd = tv2 * xd        # gxd = xd^3\n    let gx1 = Fp.mul(tv1, ELL2_J); //  7.  gx1 = J * tv1         # x1n + J * xd\n    gx1 = Fp.mul(gx1, x1n); //  8.  gx1 = gx1 * x1n       # x1n^2 + J * x1n * xd\n    gx1 = Fp.add(gx1, tv2); //  9.  gx1 = gx1 + tv2       # x1n^2 + J * x1n * xd + xd^2\n    gx1 = Fp.mul(gx1, x1n); //  10. gx1 = gx1 * x1n       # x1n^3 + J * x1n^2 * xd + x1n * xd^2\n    let tv3 = Fp.sqr(gxd); //  11. tv3 = gxd^2\n    tv2 = Fp.sqr(tv3); //  12. tv2 = tv3^2           # gxd^4\n    tv3 = Fp.mul(tv3, gxd); //  13. tv3 = tv3 * gxd       # gxd^3\n    tv3 = Fp.mul(tv3, gx1); //  14. tv3 = tv3 * gx1       # gx1 * gxd^3\n    tv2 = Fp.mul(tv2, tv3); //  15. tv2 = tv2 * tv3       # gx1 * gxd^7\n    let y11 = Fp.pow(tv2, ELL2_C4); //  16. y11 = tv2^c4        # (gx1 * gxd^7)^((p - 5) / 8)\n    y11 = Fp.mul(y11, tv3); //  17. y11 = y11 * tv3       # gx1*gxd^3*(gx1*gxd^7)^((p-5)/8)\n    let y12 = Fp.mul(y11, ELL2_C3); //  18. y12 = y11 * c3\n    tv2 = Fp.sqr(y11); //  19. tv2 = y11^2\n    tv2 = Fp.mul(tv2, gxd); //  20. tv2 = tv2 * gxd\n    let e1 = Fp.eql(tv2, gx1); //  21.  e1 = tv2 == gx1\n    let y1 = Fp.cmov(y12, y11, e1); //  22.  y1 = CMOV(y12, y11, e1)  # If g(x1) is square, this is its sqrt\n    let x2n = Fp.mul(x1n, tv1); //  23. x2n = x1n * tv1       # x2 = x2n / xd = 2 * u^2 * x1n / xd\n    let y21 = Fp.mul(y11, u); //  24. y21 = y11 * u\n    y21 = Fp.mul(y21, ELL2_C2); //  25. y21 = y21 * c2\n    let y22 = Fp.mul(y21, ELL2_C3); //  26. y22 = y21 * c3\n    let gx2 = Fp.mul(gx1, tv1); //  27. gx2 = gx1 * tv1       # g(x2) = gx2 / gxd = 2 * u^2 * g(x1)\n    tv2 = Fp.sqr(y21); //  28. tv2 = y21^2\n    tv2 = Fp.mul(tv2, gxd); //  29. tv2 = tv2 * gxd\n    let e2 = Fp.eql(tv2, gx2); //  30.  e2 = tv2 == gx2\n    let y2 = Fp.cmov(y22, y21, e2); //  31.  y2 = CMOV(y22, y21, e2)  # If g(x2) is square, this is its sqrt\n    tv2 = Fp.sqr(y1); //  32. tv2 = y1^2\n    tv2 = Fp.mul(tv2, gxd); //  33. tv2 = tv2 * gxd\n    let e3 = Fp.eql(tv2, gx1); //  34.  e3 = tv2 == gx1\n    let xn = Fp.cmov(x2n, x1n, e3); //  35.  xn = CMOV(x2n, x1n, e3)  # If e3, x = x1, else x = x2\n    let y = Fp.cmov(y2, y1, e3); //  36.   y = CMOV(y2, y1, e3)    # If e3, y = y1, else y = y2\n    let e4 = Fp.isOdd(y); //  37.  e4 = sgn0(y) == 1        # Fix sign of y\n    y = Fp.cmov(y, Fp.neg(y), e3 !== e4); //  38.   y = CMOV(y, -y, e3 XOR e4)\n    return { xMn: xn, xMd: xd, yMn: y, yMd: _1n }; //  39. return (xn, xd, y, 1)\n}\nconst ELL2_C1_EDWARDS = /* @__PURE__ */ (() => FpSqrtEven(Fp, Fp.neg(BigInt(486664))))(); // sgn0(c1) MUST equal 0\nfunction map_to_curve_elligator2_edwards25519(u) {\n    const { xMn, xMd, yMn, yMd } = map_to_curve_elligator2_curve25519(u); //  1.  (xMn, xMd, yMn, yMd) =\n    // map_to_curve_elligator2_curve25519(u)\n    let xn = Fp.mul(xMn, yMd); //  2.  xn = xMn * yMd\n    xn = Fp.mul(xn, ELL2_C1_EDWARDS); //  3.  xn = xn * c1\n    let xd = Fp.mul(xMd, yMn); //  4.  xd = xMd * yMn    # xn / xd = c1 * xM / yM\n    let yn = Fp.sub(xMn, xMd); //  5.  yn = xMn - xMd\n    let yd = Fp.add(xMn, xMd); //  6.  yd = xMn + xMd    # (n / d - 1) / (n / d + 1) = (n - d) / (n + d)\n    let tv1 = Fp.mul(xd, yd); //  7. tv1 = xd * yd\n    let e = Fp.eql(tv1, Fp.ZERO); //  8.   e = tv1 == 0\n    xn = Fp.cmov(xn, Fp.ZERO, e); //  9.  xn = CMOV(xn, 0, e)\n    xd = Fp.cmov(xd, Fp.ONE, e); //  10. xd = CMOV(xd, 1, e)\n    yn = Fp.cmov(yn, Fp.ONE, e); //  11. yn = CMOV(yn, 1, e)\n    yd = Fp.cmov(yd, Fp.ONE, e); //  12. yd = CMOV(yd, 1, e)\n    const [xd_inv, yd_inv] = FpInvertBatch(Fp, [xd, yd], true); // batch division\n    return { x: Fp.mul(xn, xd_inv), y: Fp.mul(yn, yd_inv) }; //  13. return (xn, xd, yn, yd)\n}\nexport const ed25519_hasher = /* @__PURE__ */ (() => createHasher(ed25519.ExtendedPoint, (scalars) => map_to_curve_elligator2_edwards25519(scalars[0]), {\n    DST: 'edwards25519_XMD:SHA-512_ELL2_RO_',\n    encodeDST: 'edwards25519_XMD:SHA-512_ELL2_NU_',\n    p: Fp.ORDER,\n    m: 1,\n    k: 128,\n    expand: 'xmd',\n    hash: sha512,\n}))();\nexport const hashToCurve = /* @__PURE__ */ (() => ed25519_hasher.hashToCurve)();\nexport const encodeToCurve = /* @__PURE__ */ (() => ed25519_hasher.encodeToCurve)();\nfunction aristp(other) {\n    if (!(other instanceof RistPoint))\n        throw new Error('RistrettoPoint expected');\n}\n// √(-1) aka √(a) aka 2^((p-1)/4)\nconst SQRT_M1 = ED25519_SQRT_M1;\n// √(ad - 1)\nconst SQRT_AD_MINUS_ONE = /* @__PURE__ */ BigInt('25063068953384623474111414158702152701244531502492656460079210482610430750235');\n// 1 / √(a-d)\nconst INVSQRT_A_MINUS_D = /* @__PURE__ */ BigInt('54469307008909316920995813868745141605393597292927456921205312896311721017578');\n// 1-d²\nconst ONE_MINUS_D_SQ = /* @__PURE__ */ BigInt('1159843021668779879193775521855586647937357759715417654439879720876111806838');\n// (d-1)²\nconst D_MINUS_ONE_SQ = /* @__PURE__ */ BigInt('40440834346308536858101042469323190826248399146238708352240133220865137265952');\n// Calculates 1/√(number)\nconst invertSqrt = (number) => uvRatio(_1n, number);\nconst MAX_255B = /* @__PURE__ */ BigInt('0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');\nconst bytes255ToNumberLE = (bytes) => ed25519.CURVE.Fp.create(bytesToNumberLE(bytes) & MAX_255B);\n/**\n * Computes Elligator map for Ristretto255.\n * Described in [RFC9380](https://www.rfc-editor.org/rfc/rfc9380#appendix-B) and on\n * the [website](https://ristretto.group/formulas/elligator.html).\n */\nfunction calcElligatorRistrettoMap(r0) {\n    const { d } = ed25519.CURVE;\n    const P = ed25519.CURVE.Fp.ORDER;\n    const mod = ed25519.CURVE.Fp.create;\n    const r = mod(SQRT_M1 * r0 * r0); // 1\n    const Ns = mod((r + _1n) * ONE_MINUS_D_SQ); // 2\n    let c = BigInt(-1); // 3\n    const D = mod((c - d * r) * mod(r + d)); // 4\n    let { isValid: Ns_D_is_sq, value: s } = uvRatio(Ns, D); // 5\n    let s_ = mod(s * r0); // 6\n    if (!isNegativeLE(s_, P))\n        s_ = mod(-s_);\n    if (!Ns_D_is_sq)\n        s = s_; // 7\n    if (!Ns_D_is_sq)\n        c = r; // 8\n    const Nt = mod(c * (r - _1n) * D_MINUS_ONE_SQ - D); // 9\n    const s2 = s * s;\n    const W0 = mod((s + s) * D); // 10\n    const W1 = mod(Nt * SQRT_AD_MINUS_ONE); // 11\n    const W2 = mod(_1n - s2); // 12\n    const W3 = mod(_1n + s2); // 13\n    return new ed25519.ExtendedPoint(mod(W0 * W3), mod(W2 * W1), mod(W1 * W3), mod(W0 * W2));\n}\n/**\n * Each ed25519/ExtendedPoint has 8 different equivalent points. This can be\n * a source of bugs for protocols like ring signatures. Ristretto was created to solve this.\n * Ristretto point operates in X:Y:Z:T extended coordinates like ExtendedPoint,\n * but it should work in its own namespace: do not combine those two.\n * See [RFC9496](https://www.rfc-editor.org/rfc/rfc9496).\n */\nclass RistPoint {\n    // Private property to discourage combining ExtendedPoint + RistrettoPoint\n    // Always use Ristretto encoding/decoding instead.\n    constructor(ep) {\n        this.ep = ep;\n    }\n    static fromAffine(ap) {\n        return new RistPoint(ed25519.ExtendedPoint.fromAffine(ap));\n    }\n    /**\n     * Takes uniform output of 64-byte hash function like sha512 and converts it to `RistrettoPoint`.\n     * The hash-to-group operation applies Elligator twice and adds the results.\n     * **Note:** this is one-way map, there is no conversion from point to hash.\n     * Described in [RFC9380](https://www.rfc-editor.org/rfc/rfc9380#appendix-B) and on\n     * the [website](https://ristretto.group/formulas/elligator.html).\n     * @param hex 64-byte output of a hash function\n     */\n    static hashToCurve(hex) {\n        hex = ensureBytes('ristrettoHash', hex, 64);\n        const r1 = bytes255ToNumberLE(hex.slice(0, 32));\n        const R1 = calcElligatorRistrettoMap(r1);\n        const r2 = bytes255ToNumberLE(hex.slice(32, 64));\n        const R2 = calcElligatorRistrettoMap(r2);\n        return new RistPoint(R1.add(R2));\n    }\n    /**\n     * Converts ristretto-encoded string to ristretto point.\n     * Described in [RFC9496](https://www.rfc-editor.org/rfc/rfc9496#name-decode).\n     * @param hex Ristretto-encoded 32 bytes. Not every 32-byte string is valid ristretto encoding\n     */\n    static fromHex(hex) {\n        hex = ensureBytes('ristrettoHex', hex, 32);\n        const { a, d } = ed25519.CURVE;\n        const P = ed25519.CURVE.Fp.ORDER;\n        const mod = ed25519.CURVE.Fp.create;\n        const emsg = 'RistrettoPoint.fromHex: the hex is not valid encoding of RistrettoPoint';\n        const s = bytes255ToNumberLE(hex);\n        // 1. Check that s_bytes is the canonical encoding of a field element, or else abort.\n        // 3. Check that s is non-negative, or else abort\n        if (!equalBytes(numberToBytesLE(s, 32), hex) || isNegativeLE(s, P))\n            throw new Error(emsg);\n        const s2 = mod(s * s);\n        const u1 = mod(_1n + a * s2); // 4 (a is -1)\n        const u2 = mod(_1n - a * s2); // 5\n        const u1_2 = mod(u1 * u1);\n        const u2_2 = mod(u2 * u2);\n        const v = mod(a * d * u1_2 - u2_2); // 6\n        const { isValid, value: I } = invertSqrt(mod(v * u2_2)); // 7\n        const Dx = mod(I * u2); // 8\n        const Dy = mod(I * Dx * v); // 9\n        let x = mod((s + s) * Dx); // 10\n        if (isNegativeLE(x, P))\n            x = mod(-x); // 10\n        const y = mod(u1 * Dy); // 11\n        const t = mod(x * y); // 12\n        if (!isValid || isNegativeLE(t, P) || y === _0n)\n            throw new Error(emsg);\n        return new RistPoint(new ed25519.ExtendedPoint(x, y, _1n, t));\n    }\n    static msm(points, scalars) {\n        const Fn = Field(ed25519.CURVE.n, ed25519.CURVE.nBitLength);\n        return pippenger(RistPoint, Fn, points, scalars);\n    }\n    /**\n     * Encodes ristretto point to Uint8Array.\n     * Described in [RFC9496](https://www.rfc-editor.org/rfc/rfc9496#name-encode).\n     */\n    toRawBytes() {\n        let { ex: x, ey: y, ez: z, et: t } = this.ep;\n        const P = ed25519.CURVE.Fp.ORDER;\n        const mod = ed25519.CURVE.Fp.create;\n        const u1 = mod(mod(z + y) * mod(z - y)); // 1\n        const u2 = mod(x * y); // 2\n        // Square root always exists\n        const u2sq = mod(u2 * u2);\n        const { value: invsqrt } = invertSqrt(mod(u1 * u2sq)); // 3\n        const D1 = mod(invsqrt * u1); // 4\n        const D2 = mod(invsqrt * u2); // 5\n        const zInv = mod(D1 * D2 * t); // 6\n        let D; // 7\n        if (isNegativeLE(t * zInv, P)) {\n            let _x = mod(y * SQRT_M1);\n            let _y = mod(x * SQRT_M1);\n            x = _x;\n            y = _y;\n            D = mod(D1 * INVSQRT_A_MINUS_D);\n        }\n        else {\n            D = D2; // 8\n        }\n        if (isNegativeLE(x * zInv, P))\n            y = mod(-y); // 9\n        let s = mod((z - y) * D); // 10 (check footer's note, no sqrt(-a))\n        if (isNegativeLE(s, P))\n            s = mod(-s);\n        return numberToBytesLE(s, 32); // 11\n    }\n    toHex() {\n        return bytesToHex(this.toRawBytes());\n    }\n    toString() {\n        return this.toHex();\n    }\n    /**\n     * Compares two Ristretto points.\n     * Described in [RFC9496](https://www.rfc-editor.org/rfc/rfc9496#name-equals).\n     */\n    equals(other) {\n        aristp(other);\n        const { ex: X1, ey: Y1 } = this.ep;\n        const { ex: X2, ey: Y2 } = other.ep;\n        const mod = ed25519.CURVE.Fp.create;\n        // (x1 * y2 == y1 * x2) | (y1 * y2 == x1 * x2)\n        const one = mod(X1 * Y2) === mod(Y1 * X2);\n        const two = mod(Y1 * Y2) === mod(X1 * X2);\n        return one || two;\n    }\n    add(other) {\n        aristp(other);\n        return new RistPoint(this.ep.add(other.ep));\n    }\n    subtract(other) {\n        aristp(other);\n        return new RistPoint(this.ep.subtract(other.ep));\n    }\n    multiply(scalar) {\n        return new RistPoint(this.ep.multiply(scalar));\n    }\n    multiplyUnsafe(scalar) {\n        return new RistPoint(this.ep.multiplyUnsafe(scalar));\n    }\n    double() {\n        return new RistPoint(this.ep.double());\n    }\n    negate() {\n        return new RistPoint(this.ep.negate());\n    }\n}\n/**\n * Wrapper over Edwards Point for ristretto255 from\n * [RFC9496](https://www.rfc-editor.org/rfc/rfc9496).\n */\nexport const RistrettoPoint = /* @__PURE__ */ (() => {\n    if (!RistPoint.BASE)\n        RistPoint.BASE = new RistPoint(ed25519.ExtendedPoint.BASE);\n    if (!RistPoint.ZERO)\n        RistPoint.ZERO = new RistPoint(ed25519.ExtendedPoint.ZERO);\n    return RistPoint;\n})();\n/**\n * hash-to-curve for ristretto255.\n * Described in [RFC9380](https://www.rfc-editor.org/rfc/rfc9380#appendix-B).\n */\nexport const hashToRistretto255 = (msg, options) => {\n    const d = options.DST;\n    const DST = typeof d === 'string' ? utf8ToBytes(d) : d;\n    const uniform_bytes = expand_message_xmd(msg, DST, 64, sha512);\n    const P = RistPoint.hashToCurve(uniform_bytes);\n    return P;\n};\n/** @deprecated */\nexport const hash_to_ristretto255 = hashToRistretto255; // legacy\n//# sourceMappingURL=ed25519.js.map"],"names":["ED25519_P","BigInt","ED25519_SQRT_M1","_1n","_2n","_5n","_8n","adjustScalarBytes","bytes","uvRatio","u","v","P","v3","mod","pow","x","_10n","_20n","_40n","_80n","b2","b4","pow2","b5","b10","b20","b40","b80","b160","b240","b250","pow_p_5_8","ed25519_pow_2_252_3","vx2","root1","root2","useRoot1","useRoot2","noRoot","isNegativeLE","isValid","value","Fp","Field","undefined","ed25519Defaults","a","create","d","n","h","Gx","Gy","hash","sha512","randomBytes","ed25519","twistedEdwards"],"mappings":";;AA+BA,MAAMA,EAAYC,OAChB,iFAIIC,EAAkCD,OACtC,iFAIUA,OAAO,GAAIE,MAAAA,EAAMF,OAAO,GAAIG,EAAMH,OAAO,GAAUA,OAAO,GAEtE,MAAMI,EAAMJ,OAAO,GAAIK,EAAML,OAAO,GAsBpC,SAASM,EAAkBC,GAQzB,OALAA,EAAM,IAAM,IAEZA,EAAM,KAAO,IAEbA,EAAM,KAAO,GACNA,CACT,CAGA,SAASC,EAAQC,EAAWC,GAC1B,MAAMC,EAAIZ,EACJa,EAAKC,EAAAA,IAAIH,EAAIA,EAAIA,EAAGC,GAGpBG,EArCR,SAA6BC,GAE3B,MAAMC,EAAOhB,OAAO,IAAKiB,EAAOjB,OAAO,IAAKkB,EAAOlB,OAAO,IAAKmB,EAAOnB,OAAO,IACvEW,EAAIZ,EAEJqB,EADML,EAAIA,EAAKJ,EACJI,EAAKJ,EAChBU,EAAMC,EAAAA,KAAKF,EAAIjB,EAAKQ,GAAKS,EAAMT,EAC/BY,EAAMD,EAAAA,KAAKD,EAAInB,EAAKS,GAAKI,EAAKJ,EAC9Ba,EAAOF,EAAAA,KAAKC,EAAInB,EAAKO,GAAKY,EAAMZ,EAChCc,EAAOH,EAAAA,KAAKE,EAAKR,EAAML,GAAKa,EAAOb,EACnCe,EAAOJ,EAAAA,KAAKG,EAAKR,EAAMN,GAAKc,EAAOd,EACnCgB,EAAOL,EAAAA,KAAKI,EAAKR,EAAMP,GAAKe,EAAOf,EACnCiB,EAAQN,EAAAA,KAAKK,EAAKR,EAAMR,GAAKgB,EAAOhB,EACpCkB,EAAQP,EAAAA,KAAKM,EAAMT,EAAMR,GAAKgB,EAAOhB,EACrCmB,EAAQR,EAAAA,KAAKO,EAAMb,EAAML,GAAKa,EAAOb,EAG3C,MAAO,CAAEoB,UAFUT,EAAAA,KAAKQ,EAAM3B,EAAKQ,GAAKI,EAAKJ,EAEzBS,KACtB,CAmBcY,CAAoBvB,EAFrBI,EAAAA,IAAID,EAAKA,EAAKF,EAAGC,IAEYoB,UACxC,IAAIhB,EAAIF,EAAAA,IAAIJ,EAAIG,EAAKE,EAAKH,GAC1B,MAAMsB,EAAMpB,EAAAA,IAAIH,EAAIK,EAAIA,EAAGJ,GACrBuB,EAAQnB,EACRoB,EAAQtB,EAAGA,IAACE,EAAId,EAAiBU,GACjCyB,EAAWH,IAAQxB,EACnB4B,EAAWJ,IAAQpB,EAAAA,KAAKJ,EAAGE,GAC3B2B,EAASL,IAAQpB,EAAGA,KAAEJ,EAAIR,EAAiBU,GAIjD,OAHIyB,IAAUrB,EAAImB,IACdG,GAAYC,KAAQvB,EAAIoB,GACxBI,EAAYA,aAACxB,EAAGJ,KAAII,EAAIF,OAAKE,EAAGJ,IAC7B,CAAE6B,QAASJ,GAAYC,EAAUI,MAAO1B,EACjD,CAcA,MAAM2B,EAAqB,KAAOC,EAAKA,MAAC5C,OAAW6C,GAAW,GAAnC,GAErBC,EAAkC,MACrC,CAECC,EAAGJ,EAAGK,OAAO/C,QAAS,IAEtBgD,EAAGhD,OAAO,iFAEV0C,KAEAO,EAAGjD,OAAO,gFACVkD,EAAG7C,EACH8C,GAAInD,OAAO,iFACXoD,GAAIpD,OAAO,iFACXqD,KAAMC,EAAMA,mBACZC,EAAWA,YACXjD,oBAIAE,YAnBoC,GAiC3BgD,EAAmC,KAAOC,EAAcA,eAACZ,GAAtB","x_google_ignoreList":[0]}
+{"version":3,"file":"ed25519.js","sources":["../../../../../../node_modules/@noble/curves/esm/ed25519.js"],"sourcesContent":["/**\n * ed25519 Twisted Edwards curve with following addons:\n * - X25519 ECDH\n * - Ristretto cofactor elimination\n * - Elligator hash-to-group / point indistinguishability\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { sha512 } from '@noble/hashes/sha2.js';\nimport { abytes, concatBytes, utf8ToBytes } from '@noble/hashes/utils.js';\nimport { pippenger } from \"./abstract/curve.js\";\nimport { PrimeEdwardsPoint, twistedEdwards, } from \"./abstract/edwards.js\";\nimport { _DST_scalar, createHasher, expand_message_xmd, } from \"./abstract/hash-to-curve.js\";\nimport { Field, FpInvertBatch, FpSqrtEven, isNegativeLE, mod, pow2, } from \"./abstract/modular.js\";\nimport { montgomery } from \"./abstract/montgomery.js\";\nimport { bytesToNumberLE, ensureBytes, equalBytes } from \"./utils.js\";\n// prettier-ignore\nconst _0n = /* @__PURE__ */ BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3);\n// prettier-ignore\nconst _5n = BigInt(5), _8n = BigInt(8);\n// P = 2n**255n-19n\nconst ed25519_CURVE_p = BigInt('0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed');\n// N = 2n**252n + 27742317777372353535851937790883648493n\n// a = Fp.create(BigInt(-1))\n// d = -121665/121666 a.k.a. Fp.neg(121665 * Fp.inv(121666))\nconst ed25519_CURVE = /* @__PURE__ */ (() => ({\n    p: ed25519_CURVE_p,\n    n: BigInt('0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed'),\n    h: _8n,\n    a: BigInt('0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec'),\n    d: BigInt('0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3'),\n    Gx: BigInt('0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a'),\n    Gy: BigInt('0x6666666666666666666666666666666666666666666666666666666666666658'),\n}))();\nfunction ed25519_pow_2_252_3(x) {\n    // prettier-ignore\n    const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);\n    const P = ed25519_CURVE_p;\n    const x2 = (x * x) % P;\n    const b2 = (x2 * x) % P; // x^3, 11\n    const b4 = (pow2(b2, _2n, P) * b2) % P; // x^15, 1111\n    const b5 = (pow2(b4, _1n, P) * x) % P; // x^31\n    const b10 = (pow2(b5, _5n, P) * b5) % P;\n    const b20 = (pow2(b10, _10n, P) * b10) % P;\n    const b40 = (pow2(b20, _20n, P) * b20) % P;\n    const b80 = (pow2(b40, _40n, P) * b40) % P;\n    const b160 = (pow2(b80, _80n, P) * b80) % P;\n    const b240 = (pow2(b160, _80n, P) * b80) % P;\n    const b250 = (pow2(b240, _10n, P) * b10) % P;\n    const pow_p_5_8 = (pow2(b250, _2n, P) * x) % P;\n    // ^ To pow to (p+3)/8, multiply it by x.\n    return { pow_p_5_8, b2 };\n}\nfunction adjustScalarBytes(bytes) {\n    // Section 5: For X25519, in order to decode 32 random bytes as an integer scalar,\n    // set the three least significant bits of the first byte\n    bytes[0] &= 248; // 0b1111_1000\n    // and the most significant bit of the last to zero,\n    bytes[31] &= 127; // 0b0111_1111\n    // set the second most significant bit of the last byte to 1\n    bytes[31] |= 64; // 0b0100_0000\n    return bytes;\n}\n// √(-1) aka √(a) aka 2^((p-1)/4)\n// Fp.sqrt(Fp.neg(1))\nconst ED25519_SQRT_M1 = /* @__PURE__ */ BigInt('19681161376707505956807079304988542015446066515923890162744021073123829784752');\n// sqrt(u/v)\nfunction uvRatio(u, v) {\n    const P = ed25519_CURVE_p;\n    const v3 = mod(v * v * v, P); // v³\n    const v7 = mod(v3 * v3 * v, P); // v⁷\n    // (p+3)/8 and (p-5)/8\n    const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;\n    let x = mod(u * v3 * pow, P); // (uv³)(uv⁷)^(p-5)/8\n    const vx2 = mod(v * x * x, P); // vx²\n    const root1 = x; // First root candidate\n    const root2 = mod(x * ED25519_SQRT_M1, P); // Second root candidate\n    const useRoot1 = vx2 === u; // If vx² = u (mod p), x is a square root\n    const useRoot2 = vx2 === mod(-u, P); // If vx² = -u, set x <-- x * 2^((p-1)/4)\n    const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P); // There is no valid root, vx² = -u√(-1)\n    if (useRoot1)\n        x = root1;\n    if (useRoot2 || noRoot)\n        x = root2; // We return root2 anyway, for const-time\n    if (isNegativeLE(x, P))\n        x = mod(-x, P);\n    return { isValid: useRoot1 || useRoot2, value: x };\n}\nconst Fp = /* @__PURE__ */ (() => Field(ed25519_CURVE.p, { isLE: true }))();\nconst Fn = /* @__PURE__ */ (() => Field(ed25519_CURVE.n, { isLE: true }))();\nconst ed25519Defaults = /* @__PURE__ */ (() => ({\n    ...ed25519_CURVE,\n    Fp,\n    hash: sha512,\n    adjustScalarBytes,\n    // dom2\n    // Ratio of u to v. Allows us to combine inversion and square root. Uses algo from RFC8032 5.1.3.\n    // Constant-time, u/√v\n    uvRatio,\n}))();\n/**\n * ed25519 curve with EdDSA signatures.\n * @example\n * import { ed25519 } from '@noble/curves/ed25519';\n * const { secretKey, publicKey } = ed25519.keygen();\n * const msg = new TextEncoder().encode('hello');\n * const sig = ed25519.sign(msg, priv);\n * ed25519.verify(sig, msg, pub); // Default mode: follows ZIP215\n * ed25519.verify(sig, msg, pub, { zip215: false }); // RFC8032 / FIPS 186-5\n */\nexport const ed25519 = /* @__PURE__ */ (() => twistedEdwards(ed25519Defaults))();\nfunction ed25519_domain(data, ctx, phflag) {\n    if (ctx.length > 255)\n        throw new Error('Context is too big');\n    return concatBytes(utf8ToBytes('SigEd25519 no Ed25519 collisions'), new Uint8Array([phflag ? 1 : 0, ctx.length]), ctx, data);\n}\n/** Context of ed25519. Uses context for domain separation. */\nexport const ed25519ctx = /* @__PURE__ */ (() => twistedEdwards({\n    ...ed25519Defaults,\n    domain: ed25519_domain,\n}))();\n/** Prehashed version of ed25519. Accepts already-hashed messages in sign() and verify(). */\nexport const ed25519ph = /* @__PURE__ */ (() => twistedEdwards(Object.assign({}, ed25519Defaults, {\n    domain: ed25519_domain,\n    prehash: sha512,\n})))();\n/**\n * ECDH using curve25519 aka x25519.\n * @example\n * import { x25519 } from '@noble/curves/ed25519';\n * const priv = 'a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4';\n * const pub = 'e6db6867583030db3594c1a424b15f7c726624ec26b3353b10a903a6d0ab1c4c';\n * x25519.getSharedSecret(priv, pub) === x25519.scalarMult(priv, pub); // aliases\n * x25519.getPublicKey(priv) === x25519.scalarMultBase(priv);\n * x25519.getPublicKey(x25519.utils.randomSecretKey());\n */\nexport const x25519 = /* @__PURE__ */ (() => {\n    const P = Fp.ORDER;\n    return montgomery({\n        P,\n        type: 'x25519',\n        powPminus2: (x) => {\n            // x^(p-2) aka x^(2^255-21)\n            const { pow_p_5_8, b2 } = ed25519_pow_2_252_3(x);\n            return mod(pow2(pow_p_5_8, _3n, P) * b2, P);\n        },\n        adjustScalarBytes,\n    });\n})();\n// Hash To Curve Elligator2 Map (NOTE: different from ristretto255 elligator)\n// NOTE: very important part is usage of FpSqrtEven for ELL2_C1_EDWARDS, since\n// SageMath returns different root first and everything falls apart\nconst ELL2_C1 = /* @__PURE__ */ (() => (ed25519_CURVE_p + _3n) / _8n)(); // 1. c1 = (q + 3) / 8       # Integer arithmetic\nconst ELL2_C2 = /* @__PURE__ */ (() => Fp.pow(_2n, ELL2_C1))(); // 2. c2 = 2^c1\nconst ELL2_C3 = /* @__PURE__ */ (() => Fp.sqrt(Fp.neg(Fp.ONE)))(); // 3. c3 = sqrt(-1)\n// prettier-ignore\nfunction map_to_curve_elligator2_curve25519(u) {\n    const ELL2_C4 = (ed25519_CURVE_p - _5n) / _8n; // 4. c4 = (q - 5) / 8       # Integer arithmetic\n    const ELL2_J = BigInt(486662);\n    let tv1 = Fp.sqr(u); //  1.  tv1 = u^2\n    tv1 = Fp.mul(tv1, _2n); //  2.  tv1 = 2 * tv1\n    let xd = Fp.add(tv1, Fp.ONE); //  3.   xd = tv1 + 1         # Nonzero: -1 is square (mod p), tv1 is not\n    let x1n = Fp.neg(ELL2_J); //  4.  x1n = -J              # x1 = x1n / xd = -J / (1 + 2 * u^2)\n    let tv2 = Fp.sqr(xd); //  5.  tv2 = xd^2\n    let gxd = Fp.mul(tv2, xd); //  6.  gxd = tv2 * xd        # gxd = xd^3\n    let gx1 = Fp.mul(tv1, ELL2_J); //  7.  gx1 = J * tv1         # x1n + J * xd\n    gx1 = Fp.mul(gx1, x1n); //  8.  gx1 = gx1 * x1n       # x1n^2 + J * x1n * xd\n    gx1 = Fp.add(gx1, tv2); //  9.  gx1 = gx1 + tv2       # x1n^2 + J * x1n * xd + xd^2\n    gx1 = Fp.mul(gx1, x1n); //  10. gx1 = gx1 * x1n       # x1n^3 + J * x1n^2 * xd + x1n * xd^2\n    let tv3 = Fp.sqr(gxd); //  11. tv3 = gxd^2\n    tv2 = Fp.sqr(tv3); //  12. tv2 = tv3^2           # gxd^4\n    tv3 = Fp.mul(tv3, gxd); //  13. tv3 = tv3 * gxd       # gxd^3\n    tv3 = Fp.mul(tv3, gx1); //  14. tv3 = tv3 * gx1       # gx1 * gxd^3\n    tv2 = Fp.mul(tv2, tv3); //  15. tv2 = tv2 * tv3       # gx1 * gxd^7\n    let y11 = Fp.pow(tv2, ELL2_C4); //  16. y11 = tv2^c4        # (gx1 * gxd^7)^((p - 5) / 8)\n    y11 = Fp.mul(y11, tv3); //  17. y11 = y11 * tv3       # gx1*gxd^3*(gx1*gxd^7)^((p-5)/8)\n    let y12 = Fp.mul(y11, ELL2_C3); //  18. y12 = y11 * c3\n    tv2 = Fp.sqr(y11); //  19. tv2 = y11^2\n    tv2 = Fp.mul(tv2, gxd); //  20. tv2 = tv2 * gxd\n    let e1 = Fp.eql(tv2, gx1); //  21.  e1 = tv2 == gx1\n    let y1 = Fp.cmov(y12, y11, e1); //  22.  y1 = CMOV(y12, y11, e1)  # If g(x1) is square, this is its sqrt\n    let x2n = Fp.mul(x1n, tv1); //  23. x2n = x1n * tv1       # x2 = x2n / xd = 2 * u^2 * x1n / xd\n    let y21 = Fp.mul(y11, u); //  24. y21 = y11 * u\n    y21 = Fp.mul(y21, ELL2_C2); //  25. y21 = y21 * c2\n    let y22 = Fp.mul(y21, ELL2_C3); //  26. y22 = y21 * c3\n    let gx2 = Fp.mul(gx1, tv1); //  27. gx2 = gx1 * tv1       # g(x2) = gx2 / gxd = 2 * u^2 * g(x1)\n    tv2 = Fp.sqr(y21); //  28. tv2 = y21^2\n    tv2 = Fp.mul(tv2, gxd); //  29. tv2 = tv2 * gxd\n    let e2 = Fp.eql(tv2, gx2); //  30.  e2 = tv2 == gx2\n    let y2 = Fp.cmov(y22, y21, e2); //  31.  y2 = CMOV(y22, y21, e2)  # If g(x2) is square, this is its sqrt\n    tv2 = Fp.sqr(y1); //  32. tv2 = y1^2\n    tv2 = Fp.mul(tv2, gxd); //  33. tv2 = tv2 * gxd\n    let e3 = Fp.eql(tv2, gx1); //  34.  e3 = tv2 == gx1\n    let xn = Fp.cmov(x2n, x1n, e3); //  35.  xn = CMOV(x2n, x1n, e3)  # If e3, x = x1, else x = x2\n    let y = Fp.cmov(y2, y1, e3); //  36.   y = CMOV(y2, y1, e3)    # If e3, y = y1, else y = y2\n    let e4 = Fp.isOdd(y); //  37.  e4 = sgn0(y) == 1        # Fix sign of y\n    y = Fp.cmov(y, Fp.neg(y), e3 !== e4); //  38.   y = CMOV(y, -y, e3 XOR e4)\n    return { xMn: xn, xMd: xd, yMn: y, yMd: _1n }; //  39. return (xn, xd, y, 1)\n}\nconst ELL2_C1_EDWARDS = /* @__PURE__ */ (() => FpSqrtEven(Fp, Fp.neg(BigInt(486664))))(); // sgn0(c1) MUST equal 0\nfunction map_to_curve_elligator2_edwards25519(u) {\n    const { xMn, xMd, yMn, yMd } = map_to_curve_elligator2_curve25519(u); //  1.  (xMn, xMd, yMn, yMd) =\n    // map_to_curve_elligator2_curve25519(u)\n    let xn = Fp.mul(xMn, yMd); //  2.  xn = xMn * yMd\n    xn = Fp.mul(xn, ELL2_C1_EDWARDS); //  3.  xn = xn * c1\n    let xd = Fp.mul(xMd, yMn); //  4.  xd = xMd * yMn    # xn / xd = c1 * xM / yM\n    let yn = Fp.sub(xMn, xMd); //  5.  yn = xMn - xMd\n    let yd = Fp.add(xMn, xMd); //  6.  yd = xMn + xMd    # (n / d - 1) / (n / d + 1) = (n - d) / (n + d)\n    let tv1 = Fp.mul(xd, yd); //  7. tv1 = xd * yd\n    let e = Fp.eql(tv1, Fp.ZERO); //  8.   e = tv1 == 0\n    xn = Fp.cmov(xn, Fp.ZERO, e); //  9.  xn = CMOV(xn, 0, e)\n    xd = Fp.cmov(xd, Fp.ONE, e); //  10. xd = CMOV(xd, 1, e)\n    yn = Fp.cmov(yn, Fp.ONE, e); //  11. yn = CMOV(yn, 1, e)\n    yd = Fp.cmov(yd, Fp.ONE, e); //  12. yd = CMOV(yd, 1, e)\n    const [xd_inv, yd_inv] = FpInvertBatch(Fp, [xd, yd], true); // batch division\n    return { x: Fp.mul(xn, xd_inv), y: Fp.mul(yn, yd_inv) }; //  13. return (xn, xd, yn, yd)\n}\n/** Hashing to ed25519 points / field. RFC 9380 methods. */\nexport const ed25519_hasher = /* @__PURE__ */ (() => createHasher(ed25519.Point, (scalars) => map_to_curve_elligator2_edwards25519(scalars[0]), {\n    DST: 'edwards25519_XMD:SHA-512_ELL2_RO_',\n    encodeDST: 'edwards25519_XMD:SHA-512_ELL2_NU_',\n    p: ed25519_CURVE_p,\n    m: 1,\n    k: 128,\n    expand: 'xmd',\n    hash: sha512,\n}))();\n// √(-1) aka √(a) aka 2^((p-1)/4)\nconst SQRT_M1 = ED25519_SQRT_M1;\n// √(ad - 1)\nconst SQRT_AD_MINUS_ONE = /* @__PURE__ */ BigInt('25063068953384623474111414158702152701244531502492656460079210482610430750235');\n// 1 / √(a-d)\nconst INVSQRT_A_MINUS_D = /* @__PURE__ */ BigInt('54469307008909316920995813868745141605393597292927456921205312896311721017578');\n// 1-d²\nconst ONE_MINUS_D_SQ = /* @__PURE__ */ BigInt('1159843021668779879193775521855586647937357759715417654439879720876111806838');\n// (d-1)²\nconst D_MINUS_ONE_SQ = /* @__PURE__ */ BigInt('40440834346308536858101042469323190826248399146238708352240133220865137265952');\n// Calculates 1/√(number)\nconst invertSqrt = (number) => uvRatio(_1n, number);\nconst MAX_255B = /* @__PURE__ */ BigInt('0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');\nconst bytes255ToNumberLE = (bytes) => ed25519.Point.Fp.create(bytesToNumberLE(bytes) & MAX_255B);\n/**\n * Computes Elligator map for Ristretto255.\n * Described in [RFC9380](https://www.rfc-editor.org/rfc/rfc9380#appendix-B) and on\n * the [website](https://ristretto.group/formulas/elligator.html).\n */\nfunction calcElligatorRistrettoMap(r0) {\n    const { d } = ed25519_CURVE;\n    const P = ed25519_CURVE_p;\n    const mod = (n) => Fp.create(n);\n    const r = mod(SQRT_M1 * r0 * r0); // 1\n    const Ns = mod((r + _1n) * ONE_MINUS_D_SQ); // 2\n    let c = BigInt(-1); // 3\n    const D = mod((c - d * r) * mod(r + d)); // 4\n    let { isValid: Ns_D_is_sq, value: s } = uvRatio(Ns, D); // 5\n    let s_ = mod(s * r0); // 6\n    if (!isNegativeLE(s_, P))\n        s_ = mod(-s_);\n    if (!Ns_D_is_sq)\n        s = s_; // 7\n    if (!Ns_D_is_sq)\n        c = r; // 8\n    const Nt = mod(c * (r - _1n) * D_MINUS_ONE_SQ - D); // 9\n    const s2 = s * s;\n    const W0 = mod((s + s) * D); // 10\n    const W1 = mod(Nt * SQRT_AD_MINUS_ONE); // 11\n    const W2 = mod(_1n - s2); // 12\n    const W3 = mod(_1n + s2); // 13\n    return new ed25519.Point(mod(W0 * W3), mod(W2 * W1), mod(W1 * W3), mod(W0 * W2));\n}\nfunction ristretto255_map(bytes) {\n    abytes(bytes, 64);\n    const r1 = bytes255ToNumberLE(bytes.subarray(0, 32));\n    const R1 = calcElligatorRistrettoMap(r1);\n    const r2 = bytes255ToNumberLE(bytes.subarray(32, 64));\n    const R2 = calcElligatorRistrettoMap(r2);\n    return new _RistrettoPoint(R1.add(R2));\n}\n/**\n * Wrapper over Edwards Point for ristretto255.\n *\n * Each ed25519/ExtendedPoint has 8 different equivalent points. This can be\n * a source of bugs for protocols like ring signatures. Ristretto was created to solve this.\n * Ristretto point operates in X:Y:Z:T extended coordinates like ExtendedPoint,\n * but it should work in its own namespace: do not combine those two.\n * See [RFC9496](https://www.rfc-editor.org/rfc/rfc9496).\n */\nclass _RistrettoPoint extends PrimeEdwardsPoint {\n    constructor(ep) {\n        super(ep);\n    }\n    static fromAffine(ap) {\n        return new _RistrettoPoint(ed25519.Point.fromAffine(ap));\n    }\n    assertSame(other) {\n        if (!(other instanceof _RistrettoPoint))\n            throw new Error('RistrettoPoint expected');\n    }\n    init(ep) {\n        return new _RistrettoPoint(ep);\n    }\n    /** @deprecated use `import { ristretto255_hasher } from '@noble/curves/ed25519.js';` */\n    static hashToCurve(hex) {\n        return ristretto255_map(ensureBytes('ristrettoHash', hex, 64));\n    }\n    static fromBytes(bytes) {\n        abytes(bytes, 32);\n        const { a, d } = ed25519_CURVE;\n        const P = ed25519_CURVE_p;\n        const mod = (n) => Fp.create(n);\n        const s = bytes255ToNumberLE(bytes);\n        // 1. Check that s_bytes is the canonical encoding of a field element, or else abort.\n        // 3. Check that s is non-negative, or else abort\n        if (!equalBytes(Fp.toBytes(s), bytes) || isNegativeLE(s, P))\n            throw new Error('invalid ristretto255 encoding 1');\n        const s2 = mod(s * s);\n        const u1 = mod(_1n + a * s2); // 4 (a is -1)\n        const u2 = mod(_1n - a * s2); // 5\n        const u1_2 = mod(u1 * u1);\n        const u2_2 = mod(u2 * u2);\n        const v = mod(a * d * u1_2 - u2_2); // 6\n        const { isValid, value: I } = invertSqrt(mod(v * u2_2)); // 7\n        const Dx = mod(I * u2); // 8\n        const Dy = mod(I * Dx * v); // 9\n        let x = mod((s + s) * Dx); // 10\n        if (isNegativeLE(x, P))\n            x = mod(-x); // 10\n        const y = mod(u1 * Dy); // 11\n        const t = mod(x * y); // 12\n        if (!isValid || isNegativeLE(t, P) || y === _0n)\n            throw new Error('invalid ristretto255 encoding 2');\n        return new _RistrettoPoint(new ed25519.Point(x, y, _1n, t));\n    }\n    /**\n     * Converts ristretto-encoded string to ristretto point.\n     * Described in [RFC9496](https://www.rfc-editor.org/rfc/rfc9496#name-decode).\n     * @param hex Ristretto-encoded 32 bytes. Not every 32-byte string is valid ristretto encoding\n     */\n    static fromHex(hex) {\n        return _RistrettoPoint.fromBytes(ensureBytes('ristrettoHex', hex, 32));\n    }\n    static msm(points, scalars) {\n        return pippenger(_RistrettoPoint, ed25519.Point.Fn, points, scalars);\n    }\n    /**\n     * Encodes ristretto point to Uint8Array.\n     * Described in [RFC9496](https://www.rfc-editor.org/rfc/rfc9496#name-encode).\n     */\n    toBytes() {\n        let { X, Y, Z, T } = this.ep;\n        const P = ed25519_CURVE_p;\n        const mod = (n) => Fp.create(n);\n        const u1 = mod(mod(Z + Y) * mod(Z - Y)); // 1\n        const u2 = mod(X * Y); // 2\n        // Square root always exists\n        const u2sq = mod(u2 * u2);\n        const { value: invsqrt } = invertSqrt(mod(u1 * u2sq)); // 3\n        const D1 = mod(invsqrt * u1); // 4\n        const D2 = mod(invsqrt * u2); // 5\n        const zInv = mod(D1 * D2 * T); // 6\n        let D; // 7\n        if (isNegativeLE(T * zInv, P)) {\n            let _x = mod(Y * SQRT_M1);\n            let _y = mod(X * SQRT_M1);\n            X = _x;\n            Y = _y;\n            D = mod(D1 * INVSQRT_A_MINUS_D);\n        }\n        else {\n            D = D2; // 8\n        }\n        if (isNegativeLE(X * zInv, P))\n            Y = mod(-Y); // 9\n        let s = mod((Z - Y) * D); // 10 (check footer's note, no sqrt(-a))\n        if (isNegativeLE(s, P))\n            s = mod(-s);\n        return Fp.toBytes(s); // 11\n    }\n    /**\n     * Compares two Ristretto points.\n     * Described in [RFC9496](https://www.rfc-editor.org/rfc/rfc9496#name-equals).\n     */\n    equals(other) {\n        this.assertSame(other);\n        const { X: X1, Y: Y1 } = this.ep;\n        const { X: X2, Y: Y2 } = other.ep;\n        const mod = (n) => Fp.create(n);\n        // (x1 * y2 == y1 * x2) | (y1 * y2 == x1 * x2)\n        const one = mod(X1 * Y2) === mod(Y1 * X2);\n        const two = mod(Y1 * Y2) === mod(X1 * X2);\n        return one || two;\n    }\n    is0() {\n        return this.equals(_RistrettoPoint.ZERO);\n    }\n}\n// Do NOT change syntax: the following gymnastics is done,\n// because typescript strips comments, which makes bundlers disable tree-shaking.\n// prettier-ignore\n_RistrettoPoint.BASE = \n/* @__PURE__ */ (() => new _RistrettoPoint(ed25519.Point.BASE))();\n// prettier-ignore\n_RistrettoPoint.ZERO = \n/* @__PURE__ */ (() => new _RistrettoPoint(ed25519.Point.ZERO))();\n// prettier-ignore\n_RistrettoPoint.Fp = \n/* @__PURE__ */ (() => Fp)();\n// prettier-ignore\n_RistrettoPoint.Fn = \n/* @__PURE__ */ (() => Fn)();\nexport const ristretto255 = { Point: _RistrettoPoint };\n/** Hashing to ristretto255 points / field. RFC 9380 methods. */\nexport const ristretto255_hasher = {\n    hashToCurve(msg, options) {\n        const DST = options?.DST || 'ristretto255_XMD:SHA-512_R255MAP_RO_';\n        const xmd = expand_message_xmd(msg, DST, 64, sha512);\n        return ristretto255_map(xmd);\n    },\n    hashToScalar(msg, options = { DST: _DST_scalar }) {\n        const xmd = expand_message_xmd(msg, options.DST, 64, sha512);\n        return Fn.create(bytesToNumberLE(xmd));\n    },\n};\n// export const ristretto255_oprf: OPRF = createORPF({\n//   name: 'ristretto255-SHA512',\n//   Point: RistrettoPoint,\n//   hash: sha512,\n//   hashToGroup: ristretto255_hasher.hashToCurve,\n//   hashToScalar: ristretto255_hasher.hashToScalar,\n// });\n/**\n * Weird / bogus points, useful for debugging.\n * All 8 ed25519 points of 8-torsion subgroup can be generated from the point\n * T = `26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc05`.\n * ⟨T⟩ = { O, T, 2T, 3T, 4T, 5T, 6T, 7T }\n */\nexport const ED25519_TORSION_SUBGROUP = [\n    '0100000000000000000000000000000000000000000000000000000000000000',\n    'c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a',\n    '0000000000000000000000000000000000000000000000000000000000000080',\n    '26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc05',\n    'ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f',\n    '26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc85',\n    '0000000000000000000000000000000000000000000000000000000000000000',\n    'c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa',\n];\n/** @deprecated use `ed25519.utils.toMontgomery` */\nexport function edwardsToMontgomeryPub(edwardsPub) {\n    return ed25519.utils.toMontgomery(ensureBytes('pub', edwardsPub));\n}\n/** @deprecated use `ed25519.utils.toMontgomery` */\nexport const edwardsToMontgomery = edwardsToMontgomeryPub;\n/** @deprecated use `ed25519.utils.toMontgomerySecret` */\nexport function edwardsToMontgomeryPriv(edwardsPriv) {\n    return ed25519.utils.toMontgomerySecret(ensureBytes('pub', edwardsPriv));\n}\n/** @deprecated use `ristretto255.Point` */\nexport const RistrettoPoint = _RistrettoPoint;\n/** @deprecated use `import { ed25519_hasher } from '@noble/curves/ed25519.js';` */\nexport const hashToCurve = /* @__PURE__ */ (() => ed25519_hasher.hashToCurve)();\n/** @deprecated use `import { ed25519_hasher } from '@noble/curves/ed25519.js';` */\nexport const encodeToCurve = /* @__PURE__ */ (() => ed25519_hasher.encodeToCurve)();\n/** @deprecated use `import { ristretto255_hasher } from '@noble/curves/ed25519.js';` */\nexport const hashToRistretto255 = /* @__PURE__ */ (() => ristretto255_hasher.hashToCurve)();\n/** @deprecated use `import { ristretto255_hasher } from '@noble/curves/ed25519.js';` */\nexport const hash_to_ristretto255 = /* @__PURE__ */ (() => ristretto255_hasher.hashToCurve)();\n//# sourceMappingURL=ed25519.js.map"],"names":["_1n","BigInt","_2n","_5n","_8n","ed25519_CURVE_p","ed25519_CURVE","p","n","h","a","d","Gx","Gy","adjustScalarBytes","bytes","ED25519_SQRT_M1","uvRatio","u","v","P","v3","mod","pow","x","_10n","_20n","_40n","_80n","b2","b4","pow2","b5","b10","b20","b40","b80","b160","b240","b250","pow_p_5_8","ed25519_pow_2_252_3","vx2","root1","root2","useRoot1","useRoot2","noRoot","isNegativeLE","isValid","value","Fp","Field","isLE","ed25519Defaults","hash","sha512","ed25519","twistedEdwards"],"mappings":";;AAwCA,MAAuCA,EAAMC,OAAO,GAAIC,EAAMD,OAAO,GAAUA,OAAO,GAEtF,MAAME,EAAMF,OAAO,GAAIG,EAAMH,OAAO,GAG9BI,EAAkBJ,OACtB,sEAMIK,EAA6C,MAAC,CAClDC,EAAGF,EACHG,EAAGP,OAAO,sEACVQ,EAAGL,EACHM,EAAGT,OAAO,sEACVU,EAAGV,OAAO,sEACVW,GAAIX,OAAO,sEACXY,GAAIZ,OAAO,wEAPsC,GA8BnD,SAASa,EAAkBC,GAQzB,OALAA,EAAM,IAAM,IAEZA,EAAM,KAAO,IAEbA,EAAM,KAAO,GACNA,CACT,CAIA,MAAMC,EAAkCf,OACtC,iFAGF,SAASgB,EAAQC,EAAWC,GAC1B,MAAMC,EAAIf,EACJgB,EAAKC,EAAAA,IAAIH,EAAIA,EAAIA,EAAGC,GAGpBG,EA1CR,SAA6BC,GAE3B,MAAMC,EAAOxB,OAAO,IAAKyB,EAAOzB,OAAO,IAAK0B,EAAO1B,OAAO,IAAK2B,EAAO3B,OAAO,IACvEmB,EAAIf,EAEJwB,EADML,EAAIA,EAAKJ,EACJI,EAAKJ,EAChBU,EAAMC,EAAAA,KAAKF,EAAI3B,EAAKkB,GAAKS,EAAMT,EAC/BY,EAAMD,EAAAA,KAAKD,EAAI9B,EAAKoB,GAAKI,EAAKJ,EAC9Ba,EAAOF,EAAAA,KAAKC,EAAI7B,EAAKiB,GAAKY,EAAMZ,EAChCc,EAAOH,EAAAA,KAAKE,EAAKR,EAAML,GAAKa,EAAOb,EACnCe,EAAOJ,EAAAA,KAAKG,EAAKR,EAAMN,GAAKc,EAAOd,EACnCgB,EAAOL,EAAAA,KAAKI,EAAKR,EAAMP,GAAKe,EAAOf,EACnCiB,EAAQN,EAAAA,KAAKK,EAAKR,EAAMR,GAAKgB,EAAOhB,EACpCkB,EAAQP,EAAAA,KAAKM,EAAMT,EAAMR,GAAKgB,EAAOhB,EACrCmB,EAAQR,EAAAA,KAAKO,EAAMb,EAAML,GAAKa,EAAOb,EAG3C,MAAO,CAAEoB,UAFUT,EAAAA,KAAKQ,EAAMrC,EAAKkB,GAAKI,EAAKJ,EAEzBS,KACtB,CAwBcY,CAAoBvB,EAFrBI,EAAAA,IAAID,EAAKA,EAAKF,EAAGC,IAEYoB,UACxC,IAAIhB,EAAIF,EAAAA,IAAIJ,EAAIG,EAAKE,EAAKH,GAC1B,MAAMsB,EAAMpB,EAAAA,IAAIH,EAAIK,EAAIA,EAAGJ,GACrBuB,EAAQnB,EACRoB,EAAQtB,EAAAA,IAAIE,EAAIR,EAAiBI,GACjCyB,EAAWH,IAAQxB,EACnB4B,EAAWJ,IAAQpB,EAAAA,KAAKJ,EAAGE,GAC3B2B,EAASL,IAAQpB,EAAAA,KAAKJ,EAAIF,EAAiBI,GAIjD,OAHIyB,IAAUrB,EAAImB,IACdG,GAAYC,KAAQvB,EAAIoB,GACxBI,EAAAA,aAAaxB,EAAGJ,KAAII,EAAIF,OAAKE,EAAGJ,IAC7B,CAAE6B,QAASJ,GAAYC,EAAUI,MAAO1B,EACjD,CAEA,MAAM2B,EAAqB,KAAOC,QAAM9C,EAAcC,EAAG,CAAE8C,MAAM,IAAtC,GAGrBC,EAAkC,MAAC,IACpChD,EACH6C,KACAI,KAAMC,EAAAA,OACN1C,oBAIAG,YARsC,GAqB3BwC,EAAmC,KAAOC,EAAAA,eAAeJ,GAAtB","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@noble/curves/esm/utils.js

@@ -0,0 +1,3 @@
+"use strict";var t=require("../../hashes/esm/utils.js");
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */const e=BigInt(0),r=BigInt(1);function o(t){if("string"!=typeof t)throw new Error("hex string expected, got "+typeof t);return""===t?e:BigInt("0x"+t)}function n(e,r){return t.hexToBytes(e.toString(16).padStart(2*r,"0"))}const s=t=>"bigint"==typeof t&&e<=t;function i(t,e,r){return s(t)&&s(e)&&s(r)&&e<=t&&t<r}exports.abytes=t.abytes,exports.anumber=t.anumber,exports.bytesToHex=t.bytesToHex,exports.concatBytes=t.concatBytes,exports.hexToBytes=t.hexToBytes,exports.isBytes=t.isBytes,exports.randomBytes=t.randomBytes,exports.utf8ToBytes=t.utf8ToBytes,exports._abool2=function(t,e=""){if("boolean"!=typeof t){throw new Error((e&&`"${e}"`)+"expected boolean, got type="+typeof t)}return t},exports._abytes2=function(e,r,o=""){const n=t.isBytes(e),s=e?.length,i=void 0!==r;if(!n||i&&s!==r){throw new Error((o&&`"${o}" `)+"expected Uint8Array"+(i?` of length ${r}`:"")+", got "+(n?`length=${s}`:"type="+typeof e))}return e},exports._validateObject=function(t,e,r={}){if(!t||"object"!=typeof t)throw new Error("expected valid options object");function o(e,r,o){const n=t[e];if(o&&void 0===n)return;const s=typeof n;if(s!==r||null===n)throw new Error(`param "${e}" is invalid: expected ${r}, got ${s}`)}Object.entries(e).forEach(([t,e])=>o(t,e,!1)),Object.entries(r).forEach(([t,e])=>o(t,e,!0))},exports.aInRange=function(t,e,r,o){if(!i(e,r,o))throw new Error("expected valid "+t+": "+r+" <= n < "+o+", got "+e)},exports.bitLen=function(t){let o;for(o=0;t>e;t>>=r,o+=1);return o},exports.bitMask=t=>(r<<BigInt(t))-r,exports.bytesToNumberBE=function(e){return o(t.bytesToHex(e))},exports.bytesToNumberLE=function(e){return t.abytes(e),o(t.bytesToHex(Uint8Array.from(e).reverse()))},exports.copyBytes=function(t){return Uint8Array.from(t)},exports.ensureBytes=function(e,r,o){let n;if("string"==typeof r)try{n=t.hexToBytes(r)}catch(t){throw new Error(e+" must be hex string or Uint8Array, cause: "+t)}else{if(!t.isBytes(r))throw new Error(e+" must be hex string or Uint8Array");n=Uint8Array.from(r)}const s=n.length;if("number"==typeof o&&s!==o)throw new Error(e+" of length "+o+" expected, got "+s);return n},exports.hexToNumber=o,exports.inRange=i,exports.memoized=function(t){const e=new WeakMap;return(r,...o)=>{const n=e.get(r);if(void 0!==n)return n;const s=t(r,...o);return e.set(r,s),s}},exports.numberToBytesBE=n,exports.numberToBytesLE=function(t,e){return n(t,e).reverse()};
+//# sourceMappingURL=utils.js.map

package/dist/cjs/node_modules/@noble/curves/esm/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../../../../node_modules/@noble/curves/esm/utils.js"],"sourcesContent":["/**\n * Hex, bytes and number utilities.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { abytes as abytes_, bytesToHex as bytesToHex_, concatBytes as concatBytes_, hexToBytes as hexToBytes_, isBytes as isBytes_, } from '@noble/hashes/utils.js';\nexport { abytes, anumber, bytesToHex, bytesToUtf8, concatBytes, hexToBytes, isBytes, randomBytes, utf8ToBytes, } from '@noble/hashes/utils.js';\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nexport function abool(title, value) {\n    if (typeof value !== 'boolean')\n        throw new Error(title + ' boolean expected, got ' + value);\n}\n// tmp name until v2\nexport function _abool2(value, title = '') {\n    if (typeof value !== 'boolean') {\n        const prefix = title && `\"${title}\"`;\n        throw new Error(prefix + 'expected boolean, got type=' + typeof value);\n    }\n    return value;\n}\n// tmp name until v2\n/** Asserts something is Uint8Array. */\nexport function _abytes2(value, length, title = '') {\n    const bytes = isBytes_(value);\n    const len = value?.length;\n    const needsLen = length !== undefined;\n    if (!bytes || (needsLen && len !== length)) {\n        const prefix = title && `\"${title}\" `;\n        const ofLen = needsLen ? ` of length ${length}` : '';\n        const got = bytes ? `length=${len}` : `type=${typeof value}`;\n        throw new Error(prefix + 'expected Uint8Array' + ofLen + ', got ' + got);\n    }\n    return value;\n}\n// Used in weierstrass, der\nexport function numberToHexUnpadded(num) {\n    const hex = num.toString(16);\n    return hex.length & 1 ? '0' + hex : hex;\n}\nexport function hexToNumber(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    return hex === '' ? _0n : BigInt('0x' + hex); // Big Endian\n}\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes) {\n    return hexToNumber(bytesToHex_(bytes));\n}\nexport function bytesToNumberLE(bytes) {\n    abytes_(bytes);\n    return hexToNumber(bytesToHex_(Uint8Array.from(bytes).reverse()));\n}\nexport function numberToBytesBE(n, len) {\n    return hexToBytes_(n.toString(16).padStart(len * 2, '0'));\n}\nexport function numberToBytesLE(n, len) {\n    return numberToBytesBE(n, len).reverse();\n}\n// Unpadded, rarely used\nexport function numberToVarBytesBE(n) {\n    return hexToBytes_(numberToHexUnpadded(n));\n}\n/**\n * Takes hex string or Uint8Array, converts to Uint8Array.\n * Validates output length.\n * Will throw error for other types.\n * @param title descriptive title for an error e.g. 'secret key'\n * @param hex hex string or Uint8Array\n * @param expectedLength optional, will compare to result array's length\n * @returns\n */\nexport function ensureBytes(title, hex, expectedLength) {\n    let res;\n    if (typeof hex === 'string') {\n        try {\n            res = hexToBytes_(hex);\n        }\n        catch (e) {\n            throw new Error(title + ' must be hex string or Uint8Array, cause: ' + e);\n        }\n    }\n    else if (isBytes_(hex)) {\n        // Uint8Array.from() instead of hash.slice() because node.js Buffer\n        // is instance of Uint8Array, and its slice() creates **mutable** copy\n        res = Uint8Array.from(hex);\n    }\n    else {\n        throw new Error(title + ' must be hex string or Uint8Array');\n    }\n    const len = res.length;\n    if (typeof expectedLength === 'number' && len !== expectedLength)\n        throw new Error(title + ' of length ' + expectedLength + ' expected, got ' + len);\n    return res;\n}\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}\n/**\n * Copies Uint8Array. We can't use u8a.slice(), because u8a can be Buffer,\n * and Buffer#slice creates mutable copy. Never use Buffers!\n */\nexport function copyBytes(bytes) {\n    return Uint8Array.from(bytes);\n}\n/**\n * Decodes 7-bit ASCII string to Uint8Array, throws on non-ascii symbols\n * Should be safe to use for things expected to be ASCII.\n * Returns exact same result as utf8ToBytes for ASCII or throws.\n */\nexport function asciiToBytes(ascii) {\n    return Uint8Array.from(ascii, (c, i) => {\n        const charCode = c.charCodeAt(0);\n        if (c.length !== 1 || charCode > 127) {\n            throw new Error(`string contains non-ASCII character \"${ascii[i]}\" with code ${charCode} at position ${i}`);\n        }\n        return charCode;\n    });\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\n// export const utf8ToBytes: typeof utf8ToBytes_ = utf8ToBytes_;\n/**\n * Converts bytes to string using UTF8 encoding.\n * @example bytesToUtf8(Uint8Array.from([97, 98, 99])) // 'abc'\n */\n// export const bytesToUtf8: typeof bytesToUtf8_ = bytesToUtf8_;\n// Is positive bigint\nconst isPosBig = (n) => typeof n === 'bigint' && _0n <= n;\nexport function inRange(n, min, max) {\n    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;\n}\n/**\n * Asserts min <= n < max. NOTE: It's < max and not <= max.\n * @example\n * aInRange('x', x, 1n, 256n); // would assume x is in (1n..255n)\n */\nexport function aInRange(title, n, min, max) {\n    // Why min <= n < max and not a (min < n < max) OR b (min <= n <= max)?\n    // consider P=256n, min=0n, max=P\n    // - a for min=0 would require -1:          `inRange('x', x, -1n, P)`\n    // - b would commonly require subtraction:  `inRange('x', x, 0n, P - 1n)`\n    // - our way is the cleanest:               `inRange('x', x, 0n, P)\n    if (!inRange(n, min, max))\n        throw new Error('expected valid ' + title + ': ' + min + ' <= n < ' + max + ', got ' + n);\n}\n// Bit operations\n/**\n * Calculates amount of bits in a bigint.\n * Same as `n.toString(2).length`\n * TODO: merge with nLength in modular\n */\nexport function bitLen(n) {\n    let len;\n    for (len = 0; n > _0n; n >>= _1n, len += 1)\n        ;\n    return len;\n}\n/**\n * Gets single bit at position.\n * NOTE: first bit position is 0 (same as arrays)\n * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`\n */\nexport function bitGet(n, pos) {\n    return (n >> BigInt(pos)) & _1n;\n}\n/**\n * Sets single bit at position.\n */\nexport function bitSet(n, pos, value) {\n    return n | ((value ? _1n : _0n) << BigInt(pos));\n}\n/**\n * Calculate mask for N bits. Not using ** operator with bigints because of old engines.\n * Same as BigInt(`0b${Array(i).fill('1').join('')}`)\n */\nexport const bitMask = (n) => (_1n << BigInt(n)) - _1n;\n/**\n * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n * @returns function that will call DRBG until 2nd arg returns something meaningful\n * @example\n *   const drbg = createHmacDRBG<Key>(32, 32, hmac);\n *   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined\n */\nexport function createHmacDrbg(hashLen, qByteLen, hmacFn) {\n    if (typeof hashLen !== 'number' || hashLen < 2)\n        throw new Error('hashLen must be a number');\n    if (typeof qByteLen !== 'number' || qByteLen < 2)\n        throw new Error('qByteLen must be a number');\n    if (typeof hmacFn !== 'function')\n        throw new Error('hmacFn must be a function');\n    // Step B, Step C: set hashLen to 8*ceil(hlen/8)\n    const u8n = (len) => new Uint8Array(len); // creates Uint8Array\n    const u8of = (byte) => Uint8Array.of(byte); // another shortcut\n    let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n    let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same\n    let i = 0; // Iterations counter, will throw when over 1000\n    const reset = () => {\n        v.fill(1);\n        k.fill(0);\n        i = 0;\n    };\n    const h = (...b) => hmacFn(k, v, ...b); // hmac(k)(v, ...values)\n    const reseed = (seed = u8n(0)) => {\n        // HMAC-DRBG reseed() function. Steps D-G\n        k = h(u8of(0x00), seed); // k = hmac(k || v || 0x00 || seed)\n        v = h(); // v = hmac(k || v)\n        if (seed.length === 0)\n            return;\n        k = h(u8of(0x01), seed); // k = hmac(k || v || 0x01 || seed)\n        v = h(); // v = hmac(k || v)\n    };\n    const gen = () => {\n        // HMAC-DRBG generate() function\n        if (i++ >= 1000)\n            throw new Error('drbg: tried 1000 values');\n        let len = 0;\n        const out = [];\n        while (len < qByteLen) {\n            v = h();\n            const sl = v.slice();\n            out.push(sl);\n            len += v.length;\n        }\n        return concatBytes_(...out);\n    };\n    const genUntil = (seed, pred) => {\n        reset();\n        reseed(seed); // Steps D-G\n        let res = undefined; // Step H: grind until k is in [1..n-1]\n        while (!(res = pred(gen())))\n            reseed();\n        reset();\n        return res;\n    };\n    return genUntil;\n}\n// Validating curves and fields\nconst validatorFns = {\n    bigint: (val) => typeof val === 'bigint',\n    function: (val) => typeof val === 'function',\n    boolean: (val) => typeof val === 'boolean',\n    string: (val) => typeof val === 'string',\n    stringOrUint8Array: (val) => typeof val === 'string' || isBytes_(val),\n    isSafeInteger: (val) => Number.isSafeInteger(val),\n    array: (val) => Array.isArray(val),\n    field: (val, object) => object.Fp.isValid(val),\n    hash: (val) => typeof val === 'function' && Number.isSafeInteger(val.outputLen),\n};\n// type Record<K extends string | number | symbol, T> = { [P in K]: T; }\nexport function validateObject(object, validators, optValidators = {}) {\n    const checkField = (fieldName, type, isOptional) => {\n        const checkVal = validatorFns[type];\n        if (typeof checkVal !== 'function')\n            throw new Error('invalid validator function');\n        const val = object[fieldName];\n        if (isOptional && val === undefined)\n            return;\n        if (!checkVal(val, object)) {\n            throw new Error('param ' + String(fieldName) + ' is invalid. Expected ' + type + ', got ' + val);\n        }\n    };\n    for (const [fieldName, type] of Object.entries(validators))\n        checkField(fieldName, type, false);\n    for (const [fieldName, type] of Object.entries(optValidators))\n        checkField(fieldName, type, true);\n    return object;\n}\n// validate type tests\n// const o: { a: number; b: number; c: number } = { a: 1, b: 5, c: 6 };\n// const z0 = validateObject(o, { a: 'isSafeInteger' }, { c: 'bigint' }); // Ok!\n// // Should fail type-check\n// const z1 = validateObject(o, { a: 'tmp' }, { c: 'zz' });\n// const z2 = validateObject(o, { a: 'isSafeInteger' }, { c: 'zz' });\n// const z3 = validateObject(o, { test: 'boolean', z: 'bug' });\n// const z4 = validateObject(o, { a: 'boolean', z: 'bug' });\nexport function isHash(val) {\n    return typeof val === 'function' && Number.isSafeInteger(val.outputLen);\n}\nexport function _validateObject(object, fields, optFields = {}) {\n    if (!object || typeof object !== 'object')\n        throw new Error('expected valid options object');\n    function checkField(fieldName, expectedType, isOpt) {\n        const val = object[fieldName];\n        if (isOpt && val === undefined)\n            return;\n        const current = typeof val;\n        if (current !== expectedType || val === null)\n            throw new Error(`param \"${fieldName}\" is invalid: expected ${expectedType}, got ${current}`);\n    }\n    Object.entries(fields).forEach(([k, v]) => checkField(k, v, false));\n    Object.entries(optFields).forEach(([k, v]) => checkField(k, v, true));\n}\n/**\n * throws not implemented error\n */\nexport const notImplemented = () => {\n    throw new Error('not implemented');\n};\n/**\n * Memoizes (caches) computation result.\n * Uses WeakMap: the value is going auto-cleaned by GC after last reference is removed.\n */\nexport function memoized(fn) {\n    const map = new WeakMap();\n    return (arg, ...args) => {\n        const val = map.get(arg);\n        if (val !== undefined)\n            return val;\n        const computed = fn(arg, ...args);\n        map.set(arg, computed);\n        return computed;\n    };\n}\n//# sourceMappingURL=utils.js.map"],"names":["_0n","BigInt","_1n","hexToNumber","hex","Error","numberToBytesBE","n","len","hexToBytes_","toString","padStart","isPosBig","inRange","min","max","value","title","length","bytes","isBytes_","needsLen","undefined","bytesToHex_","abytes_","Uint8Array","from","reverse","expectedLength","res","e"],"mappings":";sEAuBA,MAAMA,EAAsBC,OAAO,GAC7BC,EAAsBD,OAAK,GA6C3B,SAAUE,EAAYC,GAC1B,GAAQ,iBAAAA,EAAA,MAAA,IAAAC,MAAA,mCAAAD,GACR,MAAA,KAAAA,EAAAJ,EAAAC,OAAA,KAAAG,EACF,CAWM,SAAUE,EAAgBC,EAAoBC,GAClD,OAAOC,EAAAA,WAAYF,EAAEG,SAAS,IAAIC,SAAe,EAANH,EAAS,KACtD,CAkFA,MAAMI,EAAYL,GAA2B,iBAANA,GAASP,GAAAO,EAE9C,SAAAM,EAAAN,EAAAO,EAAAC,GACA,OAAOH,EAASL,IAAMK,EAAOE,IAAAF,EAAAG,IAAAD,GAAAP,GAAAA,EAAAQ,CAC/B,mQAnIM,SAAkBC,EAASC,EAAA,IAC/B,GAAqB,kBAAVD,EAAkB,CAE3B,MAAM,IAAIX,OADKY,GAAS,IAAIA,MACH,qCAAiCD,EAC9D,CACE,OAAOA,CACT,mBAIM,SAAYA,EAAAE,EAAAD,EAAA,IAChB,MAAME,EAAQC,EAAAA,QAASJ,GACzBR,EAAAQ,GAAAE,OACQG,OAAsBC,IAAXJ,EACjB,IAAKC,GAAUE,GAAYb,IAAQU,EAAS,CAI9C,MAAA,IAAAb,OAHAY,GAAA,IAAAA,OAGA,uBAFkBI,EAAW,cAAWH,IAAA,IAExC,UADgBC,EAAQ,UAAUX,IAAQ,eAAEQ,GAE1C,CACA,OAAOA,CACT,qYAqHA,SAAAC,EAAAV,EAAAO,EAAAC,GAME,IAAAF,EAAAN,EAAAO,EAAAC,GACE,MAAM,IAAIV,MAAM,kBAAoBY,EAAQ,KAAMH,EAAA,WAAAC,EAAA,SAAAR,EACtD,iBASM,SAAiBA,GACrB,IAAIC,EACJ,IAAKA,EAAM,EAAGD,EAAIP,EAAKO,IAAML,EAAKM,GAAO,GACzC,OAAOA,CACT,kBAsBuBD,IAAAL,GAAAD,OAAAM,IAAAL,0BAlJjB,SAAMiB,GACV,OAAOhB,EAAYoB,aAAYJ,GACjC,0BACM,SAAYA,GAEhB,OADAK,EAAAA,OAAQL,GACFhB,EAAAoB,EAAAA,WAAAE,WAAAC,KAAAP,GAAAQ,WACR,oBAsDM,SAAoBR,GACxB,OAAOM,WAAWC,KAAKP,EACzB,sBAlCA,SAAAF,EAAAb,EAAAwB,GACE,IAAAC,EACA,GAAmB,iBAARzB,EACT,IACFyB,EAAApB,EAAAA,WAAAL,EACE,CAAE,MAAO0B,GACP,MAAM,IAAIzB,MAAMY,EAAQ,6CAAGa,EACjC,KACE,KAAAV,UAAAhB,GAKE,MAAM,IAAIC,MAAMY,EAAQ,qCAFxBY,EAAMJ,WAAWC,KAAKtB,EAGxB,CACA,MAAMI,EAAMqB,EAAIX,OAChB,GAA8B,iBAAnBU,GAA+BpB,IAAEoB,EAC1C,MAAM,IAAIvB,MAAMY,EAAQ,cAAgBW,EAAiB,kBAAoBpB,GAC/E,OAAMqB,CACR,8OApCI,SAAAtB,EAAAC,GACF,OAAOF,EAAAC,EAAAC,GAAAmB,SACT","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@noble/hashes/esm/_md.js

@@ -1,2 +1,2 @@
-"use strict";var t=require("./utils.js");function s(t,s,e,i){if("function"==typeof t.setBigUint64)return t.setBigUint64(s,e,i);const n=BigInt(32),r=BigInt(4294967295),o=Number(e>>n&r),h=Number(e&r),u=i?4:0,f=i?0:4;t.setUint32(s+u,o,i),t.setUint32(s+f,h,i)}class e extends t.Hash{constructor(s,e,i,n){super(),this.finished=!1,this.length=0,this.pos=0,this.destroyed=!1,this.blockLen=s,this.outputLen=e,this.padOffset=i,this.isLE=n,this.buffer=new Uint8Array(s),this.view=t.createView(this.buffer)}update(s){t.aexists(this),s=t.toBytes(s),t.abytes(s);const{view:e,buffer:i,blockLen:n}=this,r=s.length;for(let o=0;o<r;){const h=Math.min(n-this.pos,r-o);if(h!==n)i.set(s.subarray(o,o+h),this.pos),this.pos+=h,o+=h,this.pos===n&&(this.process(e,0),this.pos=0);else{const e=t.createView(s);for(;n<=r-o;o+=n)this.process(e,o)}}return this.length+=s.length,this.roundClean(),this}digestInto(e){t.aexists(this),t.aoutput(e,this),this.finished=!0;const{buffer:i,view:n,blockLen:r,isLE:o}=this;let{pos:h}=this;i[h++]=128,t.clean(this.buffer.subarray(h)),this.padOffset>r-h&&(this.process(n,0),h=0);for(let t=h;t<r;t++)i[t]=0;s(n,r-8,BigInt(8*this.length),o),this.process(n,0);const u=t.createView(e),f=this.outputLen;if(f%4)throw new Error("_sha2: outputLen should be aligned to 32bit");const c=f/4,a=this.get();if(c>a.length)throw new Error("_sha2: outputLen bigger than state");for(let t=0;t<c;t++)u.setUint32(4*t,a[t],o)}digest(){const{buffer:t,outputLen:s}=this;this.digestInto(t);const e=t.slice(0,s);return this.destroy(),e}_cloneInto(t){t||(t=new this.constructor),t.set(...this.get());const{blockLen:s,buffer:e,length:i,finished:n,destroyed:r,pos:o}=this;return t.destroyed=r,t.finished=n,t.length=i,t.pos=o,i%s&&t.buffer.set(e),t}clone(){return this._cloneInto()}}const i=Uint32Array.from([1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225]),n=Uint32Array.from([1779033703,4089235720,3144134277,2227873595,1013904242,4271175723,2773480762,1595750129,1359893119,2917565137,2600822924,725511199,528734635,4215389547,1541459225,327033209]);exports.Chi=function(t,s,e){return t&s^~t&e},exports.HashMD=e,exports.Maj=function(t,s,e){return t&s^t&e^s&e},exports.SHA256_IV=i,exports.SHA512_IV=n,exports.setBigUint64=s;
+"use strict";var t=require("./utils.js");function s(t,s,e,i){if("function"==typeof t.setBigUint64)return t.setBigUint64(s,e,i);const n=BigInt(32),r=BigInt(4294967295),o=Number(e>>n&r),h=Number(e&r),u=i?4:0,f=i?0:4;t.setUint32(s+u,o,i),t.setUint32(s+f,h,i)}class e extends t.Hash{constructor(s,e,i,n){super(),this.finished=!1,this.length=0,this.pos=0,this.destroyed=!1,this.blockLen=s,this.outputLen=e,this.padOffset=i,this.isLE=n,this.buffer=new Uint8Array(s),this.view=t.createView(this.buffer)}update(s){t.aexists(this),s=t.toBytes(s),t.abytes(s);const{view:e,buffer:i,blockLen:n}=this,r=s.length;for(let o=0;o<r;){const h=Math.min(n-this.pos,r-o);if(h===n){const e=t.createView(s);for(;n<=r-o;o+=n)this.process(e,o);continue}i.set(s.subarray(o,o+h),this.pos),this.pos+=h,o+=h,this.pos===n&&(this.process(e,0),this.pos=0)}return this.length+=s.length,this.roundClean(),this}digestInto(e){t.aexists(this),t.aoutput(e,this),this.finished=!0;const{buffer:i,view:n,blockLen:r,isLE:o}=this;let{pos:h}=this;i[h++]=128,t.clean(this.buffer.subarray(h)),this.padOffset>r-h&&(this.process(n,0),h=0);for(let t=h;t<r;t++)i[t]=0;s(n,r-8,BigInt(8*this.length),o),this.process(n,0);const u=t.createView(e),f=this.outputLen;if(f%4)throw new Error("_sha2: outputLen should be aligned to 32bit");const c=f/4,a=this.get();if(c>a.length)throw new Error("_sha2: outputLen bigger than state");for(let t=0;t<c;t++)u.setUint32(4*t,a[t],o)}digest(){const{buffer:t,outputLen:s}=this;this.digestInto(t);const e=t.slice(0,s);return this.destroy(),e}_cloneInto(t){t||(t=new this.constructor),t.set(...this.get());const{blockLen:s,buffer:e,length:i,finished:n,destroyed:r,pos:o}=this;return t.destroyed=r,t.finished=n,t.length=i,t.pos=o,i%s&&t.buffer.set(e),t}clone(){return this._cloneInto()}}const i=Uint32Array.from([1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225]),n=Uint32Array.from([1779033703,4089235720,3144134277,2227873595,1013904242,4271175723,2773480762,1595750129,1359893119,2917565137,2600822924,725511199,528734635,4215389547,1541459225,327033209]);exports.Chi=function(t,s,e){return t&s^~t&e},exports.HashMD=e,exports.Maj=function(t,s,e){return t&s^t&e^s&e},exports.SHA256_IV=i,exports.SHA512_IV=n,exports.setBigUint64=s;
 //# sourceMappingURL=_md.js.map

package/dist/cjs/node_modules/@noble/hashes/esm/_md.js.map

@@ -1 +1 @@
-{"version":3,"file":"_md.js","sources":["../../../../../../node_modules/@noble/hashes/esm/_md.js"],"sourcesContent":["/**\n * Internal Merkle-Damgard hash utils.\n * @module\n */\nimport { Hash, abytes, aexists, aoutput, clean, createView, toBytes } from \"./utils.js\";\n/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */\nexport function setBigUint64(view, byteOffset, value, isLE) {\n    if (typeof view.setBigUint64 === 'function')\n        return view.setBigUint64(byteOffset, value, isLE);\n    const _32n = BigInt(32);\n    const _u32_max = BigInt(0xffffffff);\n    const wh = Number((value >> _32n) & _u32_max);\n    const wl = Number(value & _u32_max);\n    const h = isLE ? 4 : 0;\n    const l = isLE ? 0 : 4;\n    view.setUint32(byteOffset + h, wh, isLE);\n    view.setUint32(byteOffset + l, wl, isLE);\n}\n/** Choice: a ? b : c */\nexport function Chi(a, b, c) {\n    return (a & b) ^ (~a & c);\n}\n/** Majority function, true if any two inputs is true. */\nexport function Maj(a, b, c) {\n    return (a & b) ^ (a & c) ^ (b & c);\n}\n/**\n * Merkle-Damgard hash construction base class.\n * Could be used to create MD5, RIPEMD, SHA1, SHA2.\n */\nexport class HashMD extends Hash {\n    constructor(blockLen, outputLen, padOffset, isLE) {\n        super();\n        this.finished = false;\n        this.length = 0;\n        this.pos = 0;\n        this.destroyed = false;\n        this.blockLen = blockLen;\n        this.outputLen = outputLen;\n        this.padOffset = padOffset;\n        this.isLE = isLE;\n        this.buffer = new Uint8Array(blockLen);\n        this.view = createView(this.buffer);\n    }\n    update(data) {\n        aexists(this);\n        data = toBytes(data);\n        abytes(data);\n        const { view, buffer, blockLen } = this;\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            // Fast path: we have at least one block in input, cast it to view and process\n            if (take === blockLen) {\n                const dataView = createView(data);\n                for (; blockLen <= len - pos; pos += blockLen)\n                    this.process(dataView, pos);\n                continue;\n            }\n            buffer.set(data.subarray(pos, pos + take), this.pos);\n            this.pos += take;\n            pos += take;\n            if (this.pos === blockLen) {\n                this.process(view, 0);\n                this.pos = 0;\n            }\n        }\n        this.length += data.length;\n        this.roundClean();\n        return this;\n    }\n    digestInto(out) {\n        aexists(this);\n        aoutput(out, this);\n        this.finished = true;\n        // Padding\n        // We can avoid allocation of buffer for padding completely if it\n        // was previously not allocated here. But it won't change performance.\n        const { buffer, view, blockLen, isLE } = this;\n        let { pos } = this;\n        // append the bit '1' to the message\n        buffer[pos++] = 0b10000000;\n        clean(this.buffer.subarray(pos));\n        // we have less than padOffset left in buffer, so we cannot put length in\n        // current block, need process it and pad again\n        if (this.padOffset > blockLen - pos) {\n            this.process(view, 0);\n            pos = 0;\n        }\n        // Pad until full block byte with zeros\n        for (let i = pos; i < blockLen; i++)\n            buffer[i] = 0;\n        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\n        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.\n        // So we just write lowest 64 bits of that value.\n        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);\n        this.process(view, 0);\n        const oview = createView(out);\n        const len = this.outputLen;\n        // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT\n        if (len % 4)\n            throw new Error('_sha2: outputLen should be aligned to 32bit');\n        const outLen = len / 4;\n        const state = this.get();\n        if (outLen > state.length)\n            throw new Error('_sha2: outputLen bigger than state');\n        for (let i = 0; i < outLen; i++)\n            oview.setUint32(4 * i, state[i], isLE);\n    }\n    digest() {\n        const { buffer, outputLen } = this;\n        this.digestInto(buffer);\n        const res = buffer.slice(0, outputLen);\n        this.destroy();\n        return res;\n    }\n    _cloneInto(to) {\n        to || (to = new this.constructor());\n        to.set(...this.get());\n        const { blockLen, buffer, length, finished, destroyed, pos } = this;\n        to.destroyed = destroyed;\n        to.finished = finished;\n        to.length = length;\n        to.pos = pos;\n        if (length % blockLen)\n            to.buffer.set(buffer);\n        return to;\n    }\n    clone() {\n        return this._cloneInto();\n    }\n}\n/**\n * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.\n * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.\n */\n/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */\nexport const SHA256_IV = /* @__PURE__ */ Uint32Array.from([\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,\n]);\n/** Initial SHA224 state. Bits 32..64 of frac part of sqrt of primes 23..53 */\nexport const SHA224_IV = /* @__PURE__ */ Uint32Array.from([\n    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,\n]);\n/** Initial SHA384 state. Bits 0..64 of frac part of sqrt of primes 23..53 */\nexport const SHA384_IV = /* @__PURE__ */ Uint32Array.from([\n    0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939,\n    0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4,\n]);\n/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */\nexport const SHA512_IV = /* @__PURE__ */ Uint32Array.from([\n    0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,\n    0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,\n]);\n//# sourceMappingURL=_md.js.map"],"names":["setBigUint64","view","byteOffset","value","isLE","_32n","BigInt","_u32_max","wh","Number","wl","h","l","setUint32","HashMD","Hash","constructor","blockLen","outputLen","padOffset","super","this","finished","length","pos","destroyed","buffer","Uint8Array","createView","update","data","aexists","toBytes","abytes","len","take","Math","min","set","subarray","process","dataView","roundClean","digestInto","out","aoutput","clean","i","oview","Error","outLen","state","get","digest","res","slice","destroy","_cloneInto","to","clone","SHA256_IV","Uint32Array","from","SHA512_IV","a","b","c"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"_md.js","sources":["../../../../../../node_modules/@noble/hashes/esm/_md.js"],"sourcesContent":["/**\n * Internal Merkle-Damgard hash utils.\n * @module\n */\nimport { Hash, abytes, aexists, aoutput, clean, createView, toBytes } from \"./utils.js\";\n/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */\nexport function setBigUint64(view, byteOffset, value, isLE) {\n    if (typeof view.setBigUint64 === 'function')\n        return view.setBigUint64(byteOffset, value, isLE);\n    const _32n = BigInt(32);\n    const _u32_max = BigInt(0xffffffff);\n    const wh = Number((value >> _32n) & _u32_max);\n    const wl = Number(value & _u32_max);\n    const h = isLE ? 4 : 0;\n    const l = isLE ? 0 : 4;\n    view.setUint32(byteOffset + h, wh, isLE);\n    view.setUint32(byteOffset + l, wl, isLE);\n}\n/** Choice: a ? b : c */\nexport function Chi(a, b, c) {\n    return (a & b) ^ (~a & c);\n}\n/** Majority function, true if any two inputs is true. */\nexport function Maj(a, b, c) {\n    return (a & b) ^ (a & c) ^ (b & c);\n}\n/**\n * Merkle-Damgard hash construction base class.\n * Could be used to create MD5, RIPEMD, SHA1, SHA2.\n */\nexport class HashMD extends Hash {\n    constructor(blockLen, outputLen, padOffset, isLE) {\n        super();\n        this.finished = false;\n        this.length = 0;\n        this.pos = 0;\n        this.destroyed = false;\n        this.blockLen = blockLen;\n        this.outputLen = outputLen;\n        this.padOffset = padOffset;\n        this.isLE = isLE;\n        this.buffer = new Uint8Array(blockLen);\n        this.view = createView(this.buffer);\n    }\n    update(data) {\n        aexists(this);\n        data = toBytes(data);\n        abytes(data);\n        const { view, buffer, blockLen } = this;\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            // Fast path: we have at least one block in input, cast it to view and process\n            if (take === blockLen) {\n                const dataView = createView(data);\n                for (; blockLen <= len - pos; pos += blockLen)\n                    this.process(dataView, pos);\n                continue;\n            }\n            buffer.set(data.subarray(pos, pos + take), this.pos);\n            this.pos += take;\n            pos += take;\n            if (this.pos === blockLen) {\n                this.process(view, 0);\n                this.pos = 0;\n            }\n        }\n        this.length += data.length;\n        this.roundClean();\n        return this;\n    }\n    digestInto(out) {\n        aexists(this);\n        aoutput(out, this);\n        this.finished = true;\n        // Padding\n        // We can avoid allocation of buffer for padding completely if it\n        // was previously not allocated here. But it won't change performance.\n        const { buffer, view, blockLen, isLE } = this;\n        let { pos } = this;\n        // append the bit '1' to the message\n        buffer[pos++] = 0b10000000;\n        clean(this.buffer.subarray(pos));\n        // we have less than padOffset left in buffer, so we cannot put length in\n        // current block, need process it and pad again\n        if (this.padOffset > blockLen - pos) {\n            this.process(view, 0);\n            pos = 0;\n        }\n        // Pad until full block byte with zeros\n        for (let i = pos; i < blockLen; i++)\n            buffer[i] = 0;\n        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\n        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.\n        // So we just write lowest 64 bits of that value.\n        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);\n        this.process(view, 0);\n        const oview = createView(out);\n        const len = this.outputLen;\n        // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT\n        if (len % 4)\n            throw new Error('_sha2: outputLen should be aligned to 32bit');\n        const outLen = len / 4;\n        const state = this.get();\n        if (outLen > state.length)\n            throw new Error('_sha2: outputLen bigger than state');\n        for (let i = 0; i < outLen; i++)\n            oview.setUint32(4 * i, state[i], isLE);\n    }\n    digest() {\n        const { buffer, outputLen } = this;\n        this.digestInto(buffer);\n        const res = buffer.slice(0, outputLen);\n        this.destroy();\n        return res;\n    }\n    _cloneInto(to) {\n        to || (to = new this.constructor());\n        to.set(...this.get());\n        const { blockLen, buffer, length, finished, destroyed, pos } = this;\n        to.destroyed = destroyed;\n        to.finished = finished;\n        to.length = length;\n        to.pos = pos;\n        if (length % blockLen)\n            to.buffer.set(buffer);\n        return to;\n    }\n    clone() {\n        return this._cloneInto();\n    }\n}\n/**\n * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.\n * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.\n */\n/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */\nexport const SHA256_IV = /* @__PURE__ */ Uint32Array.from([\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,\n]);\n/** Initial SHA224 state. Bits 32..64 of frac part of sqrt of primes 23..53 */\nexport const SHA224_IV = /* @__PURE__ */ Uint32Array.from([\n    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,\n]);\n/** Initial SHA384 state. Bits 0..64 of frac part of sqrt of primes 23..53 */\nexport const SHA384_IV = /* @__PURE__ */ Uint32Array.from([\n    0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939,\n    0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4,\n]);\n/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */\nexport const SHA512_IV = /* @__PURE__ */ Uint32Array.from([\n    0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,\n    0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,\n]);\n//# sourceMappingURL=_md.js.map"],"names":["setBigUint64","view","byteOffset","value","isLE","_32n","BigInt","_u32_max","wh","Number","wl","h","l","setUint32","HashMD","Hash","constructor","blockLen","outputLen","padOffset","super","this","finished","length","pos","destroyed","buffer","Uint8Array","createView","update","data","aexists","toBytes","abytes","len","take","Math","min","dataView","process","set","subarray","roundClean","digestInto","out","aoutput","clean","i","oview","Error","outLen","state","get","digest","res","slice","destroy","_cloneInto","to","clone","SHA256_IV","Uint32Array","from","SHA512_IV","a","b","c"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@noble/hashes/esm/sha2.js

@@ -1,2 +1,2 @@
-"use strict";var t=require("./_md.js"),e=require("./_u64.js"),h=require("./utils.js");const s=Uint32Array.from([1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298]),a=new Uint32Array(64);class c extends t.HashMD{constructor(e=32){super(64,e,8,!1),this.A=0|t.SHA256_IV[0],this.B=0|t.SHA256_IV[1],this.C=0|t.SHA256_IV[2],this.D=0|t.SHA256_IV[3],this.E=0|t.SHA256_IV[4],this.F=0|t.SHA256_IV[5],this.G=0|t.SHA256_IV[6],this.H=0|t.SHA256_IV[7]}get(){const{A:t,B:e,C:h,D:s,E:a,F:c,G:r,H:d}=this;return[t,e,h,s,a,c,r,d]}set(t,e,h,s,a,c,r,d){this.A=0|t,this.B=0|e,this.C=0|h,this.D=0|s,this.E=0|a,this.F=0|c,this.G=0|r,this.H=0|d}process(e,c){for(let t=0;t<16;t++,c+=4)a[t]=e.getUint32(c,!1);for(let t=16;t<64;t++){const e=a[t-15],s=a[t-2],c=h.rotr(e,7)^h.rotr(e,18)^e>>>3,r=h.rotr(s,17)^h.rotr(s,19)^s>>>10;a[t]=r+a[t-7]+c+a[t-16]|0}let{A:r,B:d,C:b,D:i,E:x,F:f,G:l,H:o}=this;for(let e=0;e<64;e++){const c=o+(h.rotr(x,6)^h.rotr(x,11)^h.rotr(x,25))+t.Chi(x,f,l)+s[e]+a[e]|0,H=(h.rotr(r,2)^h.rotr(r,13)^h.rotr(r,22))+t.Maj(r,d,b)|0;o=l,l=f,f=x,x=i+c|0,i=b,b=d,d=r,r=c+H|0}r=r+this.A|0,d=d+this.B|0,b=b+this.C|0,i=i+this.D|0,x=x+this.E|0,f=f+this.F|0,l=l+this.G|0,o=o+this.H|0,this.set(r,d,b,i,x,f,l,o)}roundClean(){h.clean(a)}destroy(){this.set(0,0,0,0,0,0,0,0),h.clean(this.buffer)}}const r=(()=>e.split(["0x428a2f98d728ae22","0x7137449123ef65cd","0xb5c0fbcfec4d3b2f","0xe9b5dba58189dbbc","0x3956c25bf348b538","0x59f111f1b605d019","0x923f82a4af194f9b","0xab1c5ed5da6d8118","0xd807aa98a3030242","0x12835b0145706fbe","0x243185be4ee4b28c","0x550c7dc3d5ffb4e2","0x72be5d74f27b896f","0x80deb1fe3b1696b1","0x9bdc06a725c71235","0xc19bf174cf692694","0xe49b69c19ef14ad2","0xefbe4786384f25e3","0x0fc19dc68b8cd5b5","0x240ca1cc77ac9c65","0x2de92c6f592b0275","0x4a7484aa6ea6e483","0x5cb0a9dcbd41fbd4","0x76f988da831153b5","0x983e5152ee66dfab","0xa831c66d2db43210","0xb00327c898fb213f","0xbf597fc7beef0ee4","0xc6e00bf33da88fc2","0xd5a79147930aa725","0x06ca6351e003826f","0x142929670a0e6e70","0x27b70a8546d22ffc","0x2e1b21385c26c926","0x4d2c6dfc5ac42aed","0x53380d139d95b3df","0x650a73548baf63de","0x766a0abb3c77b2a8","0x81c2c92e47edaee6","0x92722c851482353b","0xa2bfe8a14cf10364","0xa81a664bbc423001","0xc24b8b70d0f89791","0xc76c51a30654be30","0xd192e819d6ef5218","0xd69906245565a910","0xf40e35855771202a","0x106aa07032bbd1b8","0x19a4c116b8d2d0c8","0x1e376c085141ab53","0x2748774cdf8eeb99","0x34b0bcb5e19b48a8","0x391c0cb3c5c95a63","0x4ed8aa4ae3418acb","0x5b9cca4f7763e373","0x682e6ff3d6b2b8a3","0x748f82ee5defb2fc","0x78a5636f43172f60","0x84c87814a1f0ab72","0x8cc702081a6439ec","0x90befffa23631e28","0xa4506cebde82bde9","0xbef9a3f7b2c67915","0xc67178f2e372532b","0xca273eceea26619c","0xd186b8c721c0c207","0xeada7dd6cde0eb1e","0xf57d4f7fee6ed178","0x06f067aa72176fba","0x0a637dc5a2c898a6","0x113f9804bef90dae","0x1b710b35131c471b","0x28db77f523047d84","0x32caab7b40c72493","0x3c9ebe0a15c9bebc","0x431d67c49c100d4c","0x4cc5d4becb3e42b6","0x597f299cfc657e2a","0x5fcb6fab3ad6faec","0x6c44198c4a475817"].map((t=>BigInt(t)))))(),d=(()=>r[0])(),b=(()=>r[1])(),i=new Uint32Array(80),x=new Uint32Array(80);class f extends t.HashMD{constructor(e=64){super(128,e,16,!1),this.Ah=0|t.SHA512_IV[0],this.Al=0|t.SHA512_IV[1],this.Bh=0|t.SHA512_IV[2],this.Bl=0|t.SHA512_IV[3],this.Ch=0|t.SHA512_IV[4],this.Cl=0|t.SHA512_IV[5],this.Dh=0|t.SHA512_IV[6],this.Dl=0|t.SHA512_IV[7],this.Eh=0|t.SHA512_IV[8],this.El=0|t.SHA512_IV[9],this.Fh=0|t.SHA512_IV[10],this.Fl=0|t.SHA512_IV[11],this.Gh=0|t.SHA512_IV[12],this.Gl=0|t.SHA512_IV[13],this.Hh=0|t.SHA512_IV[14],this.Hl=0|t.SHA512_IV[15]}get(){const{Ah:t,Al:e,Bh:h,Bl:s,Ch:a,Cl:c,Dh:r,Dl:d,Eh:b,El:i,Fh:x,Fl:f,Gh:l,Gl:o,Hh:H,Hl:A}=this;return[t,e,h,s,a,c,r,d,b,i,x,f,l,o,H,A]}set(t,e,h,s,a,c,r,d,b,i,x,f,l,o,H,A){this.Ah=0|t,this.Al=0|e,this.Bh=0|h,this.Bl=0|s,this.Ch=0|a,this.Cl=0|c,this.Dh=0|r,this.Dl=0|d,this.Eh=0|b,this.El=0|i,this.Fh=0|x,this.Fl=0|f,this.Gh=0|l,this.Gl=0|o,this.Hh=0|H,this.Hl=0|A}process(t,h){for(let e=0;e<16;e++,h+=4)i[e]=t.getUint32(h),x[e]=t.getUint32(h+=4);for(let t=16;t<80;t++){const h=0|i[t-15],s=0|x[t-15],a=e.rotrSH(h,s,1)^e.rotrSH(h,s,8)^e.shrSH(h,s,7),c=e.rotrSL(h,s,1)^e.rotrSL(h,s,8)^e.shrSL(h,s,7),r=0|i[t-2],d=0|x[t-2],b=e.rotrSH(r,d,19)^e.rotrBH(r,d,61)^e.shrSH(r,d,6),f=e.rotrSL(r,d,19)^e.rotrBL(r,d,61)^e.shrSL(r,d,6),l=e.add4L(c,f,x[t-7],x[t-16]),o=e.add4H(l,a,b,i[t-7],i[t-16]);i[t]=0|o,x[t]=0|l}let{Ah:s,Al:a,Bh:c,Bl:r,Ch:f,Cl:l,Dh:o,Dl:H,Eh:A,El:S,Fh:n,Fl:_,Gh:I,Gl:B,Hh:V,Hl:C}=this;for(let t=0;t<80;t++){const h=e.rotrSH(A,S,14)^e.rotrSH(A,S,18)^e.rotrBH(A,S,41),D=e.rotrSL(A,S,14)^e.rotrSL(A,S,18)^e.rotrBL(A,S,41),u=A&n^~A&I,E=S&_^~S&B,F=e.add5L(C,D,E,b[t],x[t]),G=e.add5H(F,V,h,u,d[t],i[t]),L=0|F,p=e.rotrSH(s,a,28)^e.rotrBH(s,a,34)^e.rotrBH(s,a,39),U=e.rotrSL(s,a,28)^e.rotrBL(s,a,34)^e.rotrBL(s,a,39),g=s&c^s&f^c&f,y=a&r^a&l^r&l;V=0|I,C=0|B,I=0|n,B=0|_,n=0|A,_=0|S,({h:A,l:S}=e.add(0|o,0|H,0|G,0|L)),o=0|f,H=0|l,f=0|c,l=0|r,c=0|s,r=0|a;const w=e.add3L(L,U,y);s=e.add3H(w,G,p,g),a=0|w}({h:s,l:a}=e.add(0|this.Ah,0|this.Al,0|s,0|a)),({h:c,l:r}=e.add(0|this.Bh,0|this.Bl,0|c,0|r)),({h:f,l:l}=e.add(0|this.Ch,0|this.Cl,0|f,0|l)),({h:o,l:H}=e.add(0|this.Dh,0|this.Dl,0|o,0|H)),({h:A,l:S}=e.add(0|this.Eh,0|this.El,0|A,0|S)),({h:n,l:_}=e.add(0|this.Fh,0|this.Fl,0|n,0|_)),({h:I,l:B}=e.add(0|this.Gh,0|this.Gl,0|I,0|B)),({h:V,l:C}=e.add(0|this.Hh,0|this.Hl,0|V,0|C)),this.set(s,a,c,r,f,l,o,H,A,S,n,_,I,B,V,C)}roundClean(){h.clean(i,x)}destroy(){h.clean(this.buffer),this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)}}const l=h.createHasher((()=>new c)),o=h.createHasher((()=>new f));exports.SHA256=c,exports.SHA512=f,exports.sha256=l,exports.sha512=o;
+"use strict";var t=require("./_md.js"),e=require("./_u64.js"),h=require("./utils.js");const s=Uint32Array.from([1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298]),a=new Uint32Array(64);class c extends t.HashMD{constructor(e=32){super(64,e,8,!1),this.A=0|t.SHA256_IV[0],this.B=0|t.SHA256_IV[1],this.C=0|t.SHA256_IV[2],this.D=0|t.SHA256_IV[3],this.E=0|t.SHA256_IV[4],this.F=0|t.SHA256_IV[5],this.G=0|t.SHA256_IV[6],this.H=0|t.SHA256_IV[7]}get(){const{A:t,B:e,C:h,D:s,E:a,F:c,G:r,H:d}=this;return[t,e,h,s,a,c,r,d]}set(t,e,h,s,a,c,r,d){this.A=0|t,this.B=0|e,this.C=0|h,this.D=0|s,this.E=0|a,this.F=0|c,this.G=0|r,this.H=0|d}process(e,c){for(let t=0;t<16;t++,c+=4)a[t]=e.getUint32(c,!1);for(let t=16;t<64;t++){const e=a[t-15],s=a[t-2],c=h.rotr(e,7)^h.rotr(e,18)^e>>>3,r=h.rotr(s,17)^h.rotr(s,19)^s>>>10;a[t]=r+a[t-7]+c+a[t-16]|0}let{A:r,B:d,C:b,D:i,E:x,F:f,G:l,H:o}=this;for(let e=0;e<64;e++){const c=o+(h.rotr(x,6)^h.rotr(x,11)^h.rotr(x,25))+t.Chi(x,f,l)+s[e]+a[e]|0,H=(h.rotr(r,2)^h.rotr(r,13)^h.rotr(r,22))+t.Maj(r,d,b)|0;o=l,l=f,f=x,x=i+c|0,i=b,b=d,d=r,r=c+H|0}r=r+this.A|0,d=d+this.B|0,b=b+this.C|0,i=i+this.D|0,x=x+this.E|0,f=f+this.F|0,l=l+this.G|0,o=o+this.H|0,this.set(r,d,b,i,x,f,l,o)}roundClean(){h.clean(a)}destroy(){this.set(0,0,0,0,0,0,0,0),h.clean(this.buffer)}}const r=(()=>e.split(["0x428a2f98d728ae22","0x7137449123ef65cd","0xb5c0fbcfec4d3b2f","0xe9b5dba58189dbbc","0x3956c25bf348b538","0x59f111f1b605d019","0x923f82a4af194f9b","0xab1c5ed5da6d8118","0xd807aa98a3030242","0x12835b0145706fbe","0x243185be4ee4b28c","0x550c7dc3d5ffb4e2","0x72be5d74f27b896f","0x80deb1fe3b1696b1","0x9bdc06a725c71235","0xc19bf174cf692694","0xe49b69c19ef14ad2","0xefbe4786384f25e3","0x0fc19dc68b8cd5b5","0x240ca1cc77ac9c65","0x2de92c6f592b0275","0x4a7484aa6ea6e483","0x5cb0a9dcbd41fbd4","0x76f988da831153b5","0x983e5152ee66dfab","0xa831c66d2db43210","0xb00327c898fb213f","0xbf597fc7beef0ee4","0xc6e00bf33da88fc2","0xd5a79147930aa725","0x06ca6351e003826f","0x142929670a0e6e70","0x27b70a8546d22ffc","0x2e1b21385c26c926","0x4d2c6dfc5ac42aed","0x53380d139d95b3df","0x650a73548baf63de","0x766a0abb3c77b2a8","0x81c2c92e47edaee6","0x92722c851482353b","0xa2bfe8a14cf10364","0xa81a664bbc423001","0xc24b8b70d0f89791","0xc76c51a30654be30","0xd192e819d6ef5218","0xd69906245565a910","0xf40e35855771202a","0x106aa07032bbd1b8","0x19a4c116b8d2d0c8","0x1e376c085141ab53","0x2748774cdf8eeb99","0x34b0bcb5e19b48a8","0x391c0cb3c5c95a63","0x4ed8aa4ae3418acb","0x5b9cca4f7763e373","0x682e6ff3d6b2b8a3","0x748f82ee5defb2fc","0x78a5636f43172f60","0x84c87814a1f0ab72","0x8cc702081a6439ec","0x90befffa23631e28","0xa4506cebde82bde9","0xbef9a3f7b2c67915","0xc67178f2e372532b","0xca273eceea26619c","0xd186b8c721c0c207","0xeada7dd6cde0eb1e","0xf57d4f7fee6ed178","0x06f067aa72176fba","0x0a637dc5a2c898a6","0x113f9804bef90dae","0x1b710b35131c471b","0x28db77f523047d84","0x32caab7b40c72493","0x3c9ebe0a15c9bebc","0x431d67c49c100d4c","0x4cc5d4becb3e42b6","0x597f299cfc657e2a","0x5fcb6fab3ad6faec","0x6c44198c4a475817"].map(t=>BigInt(t))))(),d=(()=>r[0])(),b=(()=>r[1])(),i=new Uint32Array(80),x=new Uint32Array(80);class f extends t.HashMD{constructor(e=64){super(128,e,16,!1),this.Ah=0|t.SHA512_IV[0],this.Al=0|t.SHA512_IV[1],this.Bh=0|t.SHA512_IV[2],this.Bl=0|t.SHA512_IV[3],this.Ch=0|t.SHA512_IV[4],this.Cl=0|t.SHA512_IV[5],this.Dh=0|t.SHA512_IV[6],this.Dl=0|t.SHA512_IV[7],this.Eh=0|t.SHA512_IV[8],this.El=0|t.SHA512_IV[9],this.Fh=0|t.SHA512_IV[10],this.Fl=0|t.SHA512_IV[11],this.Gh=0|t.SHA512_IV[12],this.Gl=0|t.SHA512_IV[13],this.Hh=0|t.SHA512_IV[14],this.Hl=0|t.SHA512_IV[15]}get(){const{Ah:t,Al:e,Bh:h,Bl:s,Ch:a,Cl:c,Dh:r,Dl:d,Eh:b,El:i,Fh:x,Fl:f,Gh:l,Gl:o,Hh:H,Hl:A}=this;return[t,e,h,s,a,c,r,d,b,i,x,f,l,o,H,A]}set(t,e,h,s,a,c,r,d,b,i,x,f,l,o,H,A){this.Ah=0|t,this.Al=0|e,this.Bh=0|h,this.Bl=0|s,this.Ch=0|a,this.Cl=0|c,this.Dh=0|r,this.Dl=0|d,this.Eh=0|b,this.El=0|i,this.Fh=0|x,this.Fl=0|f,this.Gh=0|l,this.Gl=0|o,this.Hh=0|H,this.Hl=0|A}process(t,h){for(let e=0;e<16;e++,h+=4)i[e]=t.getUint32(h),x[e]=t.getUint32(h+=4);for(let t=16;t<80;t++){const h=0|i[t-15],s=0|x[t-15],a=e.rotrSH(h,s,1)^e.rotrSH(h,s,8)^e.shrSH(h,s,7),c=e.rotrSL(h,s,1)^e.rotrSL(h,s,8)^e.shrSL(h,s,7),r=0|i[t-2],d=0|x[t-2],b=e.rotrSH(r,d,19)^e.rotrBH(r,d,61)^e.shrSH(r,d,6),f=e.rotrSL(r,d,19)^e.rotrBL(r,d,61)^e.shrSL(r,d,6),l=e.add4L(c,f,x[t-7],x[t-16]),o=e.add4H(l,a,b,i[t-7],i[t-16]);i[t]=0|o,x[t]=0|l}let{Ah:s,Al:a,Bh:c,Bl:r,Ch:f,Cl:l,Dh:o,Dl:H,Eh:A,El:S,Fh:n,Fl:_,Gh:I,Gl:B,Hh:V,Hl:C}=this;for(let t=0;t<80;t++){const h=e.rotrSH(A,S,14)^e.rotrSH(A,S,18)^e.rotrBH(A,S,41),D=e.rotrSL(A,S,14)^e.rotrSL(A,S,18)^e.rotrBL(A,S,41),u=A&n^~A&I,E=S&_^~S&B,F=e.add5L(C,D,E,b[t],x[t]),G=e.add5H(F,V,h,u,d[t],i[t]),L=0|F,p=e.rotrSH(s,a,28)^e.rotrBH(s,a,34)^e.rotrBH(s,a,39),U=e.rotrSL(s,a,28)^e.rotrBL(s,a,34)^e.rotrBL(s,a,39),g=s&c^s&f^c&f,y=a&r^a&l^r&l;V=0|I,C=0|B,I=0|n,B=0|_,n=0|A,_=0|S,({h:A,l:S}=e.add(0|o,0|H,0|G,0|L)),o=0|f,H=0|l,f=0|c,l=0|r,c=0|s,r=0|a;const w=e.add3L(L,U,y);s=e.add3H(w,G,p,g),a=0|w}({h:s,l:a}=e.add(0|this.Ah,0|this.Al,0|s,0|a)),({h:c,l:r}=e.add(0|this.Bh,0|this.Bl,0|c,0|r)),({h:f,l:l}=e.add(0|this.Ch,0|this.Cl,0|f,0|l)),({h:o,l:H}=e.add(0|this.Dh,0|this.Dl,0|o,0|H)),({h:A,l:S}=e.add(0|this.Eh,0|this.El,0|A,0|S)),({h:n,l:_}=e.add(0|this.Fh,0|this.Fl,0|n,0|_)),({h:I,l:B}=e.add(0|this.Gh,0|this.Gl,0|I,0|B)),({h:V,l:C}=e.add(0|this.Hh,0|this.Hl,0|V,0|C)),this.set(s,a,c,r,f,l,o,H,A,S,n,_,I,B,V,C)}roundClean(){h.clean(i,x)}destroy(){h.clean(this.buffer),this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)}}const l=h.createHasher(()=>new c),o=h.createHasher(()=>new f);exports.SHA256=c,exports.SHA512=f,exports.sha256=l,exports.sha512=o;
 //# sourceMappingURL=sha2.js.map

package/dist/cjs/node_modules/@noble/hashes/esm/sha2.js.map

@@ -1 +1 @@
-{"version":3,"file":"sha2.js","sources":["../../../../../../node_modules/@noble/hashes/esm/sha2.js"],"sourcesContent":["/**\n * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.\n * SHA256 is the fastest hash implementable in JS, even faster than Blake3.\n * Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and\n * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).\n * @module\n */\nimport { Chi, HashMD, Maj, SHA224_IV, SHA256_IV, SHA384_IV, SHA512_IV } from \"./_md.js\";\nimport * as u64 from \"./_u64.js\";\nimport { clean, createHasher, rotr } from \"./utils.js\";\n/**\n * Round constants:\n * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)\n */\n// prettier-ignore\nconst SHA256_K = /* @__PURE__ */ Uint32Array.from([\n    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\n/** Reusable temporary buffer. \"W\" comes straight from spec. */\nconst SHA256_W = /* @__PURE__ */ new Uint32Array(64);\nexport class SHA256 extends HashMD {\n    constructor(outputLen = 32) {\n        super(64, outputLen, 8, false);\n        // We cannot use array here since array allows indexing by variable\n        // which means optimizer/compiler cannot use registers.\n        this.A = SHA256_IV[0] | 0;\n        this.B = SHA256_IV[1] | 0;\n        this.C = SHA256_IV[2] | 0;\n        this.D = SHA256_IV[3] | 0;\n        this.E = SHA256_IV[4] | 0;\n        this.F = SHA256_IV[5] | 0;\n        this.G = SHA256_IV[6] | 0;\n        this.H = SHA256_IV[7] | 0;\n    }\n    get() {\n        const { A, B, C, D, E, F, G, H } = this;\n        return [A, B, C, D, E, F, G, H];\n    }\n    // prettier-ignore\n    set(A, B, C, D, E, F, G, H) {\n        this.A = A | 0;\n        this.B = B | 0;\n        this.C = C | 0;\n        this.D = D | 0;\n        this.E = E | 0;\n        this.F = F | 0;\n        this.G = G | 0;\n        this.H = H | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4)\n            SHA256_W[i] = view.getUint32(offset, false);\n        for (let i = 16; i < 64; i++) {\n            const W15 = SHA256_W[i - 15];\n            const W2 = SHA256_W[i - 2];\n            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);\n            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);\n            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;\n        }\n        // Compression function main loop, 64 rounds\n        let { A, B, C, D, E, F, G, H } = this;\n        for (let i = 0; i < 64; i++) {\n            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);\n            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);\n            const T2 = (sigma0 + Maj(A, B, C)) | 0;\n            H = G;\n            G = F;\n            F = E;\n            E = (D + T1) | 0;\n            D = C;\n            C = B;\n            B = A;\n            A = (T1 + T2) | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        A = (A + this.A) | 0;\n        B = (B + this.B) | 0;\n        C = (C + this.C) | 0;\n        D = (D + this.D) | 0;\n        E = (E + this.E) | 0;\n        F = (F + this.F) | 0;\n        G = (G + this.G) | 0;\n        H = (H + this.H) | 0;\n        this.set(A, B, C, D, E, F, G, H);\n    }\n    roundClean() {\n        clean(SHA256_W);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n        clean(this.buffer);\n    }\n}\nexport class SHA224 extends SHA256 {\n    constructor() {\n        super(28);\n        this.A = SHA224_IV[0] | 0;\n        this.B = SHA224_IV[1] | 0;\n        this.C = SHA224_IV[2] | 0;\n        this.D = SHA224_IV[3] | 0;\n        this.E = SHA224_IV[4] | 0;\n        this.F = SHA224_IV[5] | 0;\n        this.G = SHA224_IV[6] | 0;\n        this.H = SHA224_IV[7] | 0;\n    }\n}\n// SHA2-512 is slower than sha256 in js because u64 operations are slow.\n// Round contants\n// First 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409\n// prettier-ignore\nconst K512 = /* @__PURE__ */ (() => u64.split([\n    '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',\n    '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',\n    '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',\n    '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',\n    '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',\n    '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',\n    '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',\n    '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',\n    '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',\n    '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',\n    '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',\n    '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',\n    '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',\n    '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',\n    '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',\n    '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',\n    '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',\n    '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',\n    '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',\n    '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'\n].map(n => BigInt(n))))();\nconst SHA512_Kh = /* @__PURE__ */ (() => K512[0])();\nconst SHA512_Kl = /* @__PURE__ */ (() => K512[1])();\n// Reusable temporary buffers\nconst SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);\nconst SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);\nexport class SHA512 extends HashMD {\n    constructor(outputLen = 64) {\n        super(128, outputLen, 16, false);\n        // We cannot use array here since array allows indexing by variable\n        // which means optimizer/compiler cannot use registers.\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = SHA512_IV[0] | 0;\n        this.Al = SHA512_IV[1] | 0;\n        this.Bh = SHA512_IV[2] | 0;\n        this.Bl = SHA512_IV[3] | 0;\n        this.Ch = SHA512_IV[4] | 0;\n        this.Cl = SHA512_IV[5] | 0;\n        this.Dh = SHA512_IV[6] | 0;\n        this.Dl = SHA512_IV[7] | 0;\n        this.Eh = SHA512_IV[8] | 0;\n        this.El = SHA512_IV[9] | 0;\n        this.Fh = SHA512_IV[10] | 0;\n        this.Fl = SHA512_IV[11] | 0;\n        this.Gh = SHA512_IV[12] | 0;\n        this.Gl = SHA512_IV[13] | 0;\n        this.Hh = SHA512_IV[14] | 0;\n        this.Hl = SHA512_IV[15] | 0;\n    }\n    // prettier-ignore\n    get() {\n        const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];\n    }\n    // prettier-ignore\n    set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {\n        this.Ah = Ah | 0;\n        this.Al = Al | 0;\n        this.Bh = Bh | 0;\n        this.Bl = Bl | 0;\n        this.Ch = Ch | 0;\n        this.Cl = Cl | 0;\n        this.Dh = Dh | 0;\n        this.Dl = Dl | 0;\n        this.Eh = Eh | 0;\n        this.El = El | 0;\n        this.Fh = Fh | 0;\n        this.Fl = Fl | 0;\n        this.Gh = Gh | 0;\n        this.Gl = Gl | 0;\n        this.Hh = Hh | 0;\n        this.Hl = Hl | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4) {\n            SHA512_W_H[i] = view.getUint32(offset);\n            SHA512_W_L[i] = view.getUint32((offset += 4));\n        }\n        for (let i = 16; i < 80; i++) {\n            // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)\n            const W15h = SHA512_W_H[i - 15] | 0;\n            const W15l = SHA512_W_L[i - 15] | 0;\n            const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);\n            const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);\n            // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)\n            const W2h = SHA512_W_H[i - 2] | 0;\n            const W2l = SHA512_W_L[i - 2] | 0;\n            const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);\n            const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);\n            // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];\n            const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\n            const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);\n            SHA512_W_H[i] = SUMh | 0;\n            SHA512_W_L[i] = SUMl | 0;\n        }\n        let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        // Compression function main loop, 80 rounds\n        for (let i = 0; i < 80; i++) {\n            // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)\n            const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);\n            const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);\n            //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const CHIh = (Eh & Fh) ^ (~Eh & Gh);\n            const CHIl = (El & Fl) ^ (~El & Gl);\n            // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]\n            // prettier-ignore\n            const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\n            const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);\n            const T1l = T1ll | 0;\n            // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)\n            const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);\n            const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);\n            const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);\n            const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);\n            Hh = Gh | 0;\n            Hl = Gl | 0;\n            Gh = Fh | 0;\n            Gl = Fl | 0;\n            Fh = Eh | 0;\n            Fl = El | 0;\n            ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));\n            Dh = Ch | 0;\n            Dl = Cl | 0;\n            Ch = Bh | 0;\n            Cl = Bl | 0;\n            Bh = Ah | 0;\n            Bl = Al | 0;\n            const All = u64.add3L(T1l, sigma0l, MAJl);\n            Ah = u64.add3H(All, T1h, sigma0h, MAJh);\n            Al = All | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));\n        ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));\n        ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));\n        ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));\n        ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));\n        ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));\n        ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));\n        ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));\n        this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);\n    }\n    roundClean() {\n        clean(SHA512_W_H, SHA512_W_L);\n    }\n    destroy() {\n        clean(this.buffer);\n        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n    }\n}\nexport class SHA384 extends SHA512 {\n    constructor() {\n        super(48);\n        this.Ah = SHA384_IV[0] | 0;\n        this.Al = SHA384_IV[1] | 0;\n        this.Bh = SHA384_IV[2] | 0;\n        this.Bl = SHA384_IV[3] | 0;\n        this.Ch = SHA384_IV[4] | 0;\n        this.Cl = SHA384_IV[5] | 0;\n        this.Dh = SHA384_IV[6] | 0;\n        this.Dl = SHA384_IV[7] | 0;\n        this.Eh = SHA384_IV[8] | 0;\n        this.El = SHA384_IV[9] | 0;\n        this.Fh = SHA384_IV[10] | 0;\n        this.Fl = SHA384_IV[11] | 0;\n        this.Gh = SHA384_IV[12] | 0;\n        this.Gl = SHA384_IV[13] | 0;\n        this.Hh = SHA384_IV[14] | 0;\n        this.Hl = SHA384_IV[15] | 0;\n    }\n}\n/**\n * Truncated SHA512/256 and SHA512/224.\n * SHA512_IV is XORed with 0xa5a5a5a5a5a5a5a5, then used as \"intermediary\" IV of SHA512/t.\n * Then t hashes string to produce result IV.\n * See `test/misc/sha2-gen-iv.js`.\n */\n/** SHA512/224 IV */\nconst T224_IV = /* @__PURE__ */ Uint32Array.from([\n    0x8c3d37c8, 0x19544da2, 0x73e19966, 0x89dcd4d6, 0x1dfab7ae, 0x32ff9c82, 0x679dd514, 0x582f9fcf,\n    0x0f6d2b69, 0x7bd44da8, 0x77e36f73, 0x04c48942, 0x3f9d85a8, 0x6a1d36c8, 0x1112e6ad, 0x91d692a1,\n]);\n/** SHA512/256 IV */\nconst T256_IV = /* @__PURE__ */ Uint32Array.from([\n    0x22312194, 0xfc2bf72c, 0x9f555fa3, 0xc84c64c2, 0x2393b86b, 0x6f53b151, 0x96387719, 0x5940eabd,\n    0x96283ee2, 0xa88effe3, 0xbe5e1e25, 0x53863992, 0x2b0199fc, 0x2c85b8aa, 0x0eb72ddc, 0x81c52ca2,\n]);\nexport class SHA512_224 extends SHA512 {\n    constructor() {\n        super(28);\n        this.Ah = T224_IV[0] | 0;\n        this.Al = T224_IV[1] | 0;\n        this.Bh = T224_IV[2] | 0;\n        this.Bl = T224_IV[3] | 0;\n        this.Ch = T224_IV[4] | 0;\n        this.Cl = T224_IV[5] | 0;\n        this.Dh = T224_IV[6] | 0;\n        this.Dl = T224_IV[7] | 0;\n        this.Eh = T224_IV[8] | 0;\n        this.El = T224_IV[9] | 0;\n        this.Fh = T224_IV[10] | 0;\n        this.Fl = T224_IV[11] | 0;\n        this.Gh = T224_IV[12] | 0;\n        this.Gl = T224_IV[13] | 0;\n        this.Hh = T224_IV[14] | 0;\n        this.Hl = T224_IV[15] | 0;\n    }\n}\nexport class SHA512_256 extends SHA512 {\n    constructor() {\n        super(32);\n        this.Ah = T256_IV[0] | 0;\n        this.Al = T256_IV[1] | 0;\n        this.Bh = T256_IV[2] | 0;\n        this.Bl = T256_IV[3] | 0;\n        this.Ch = T256_IV[4] | 0;\n        this.Cl = T256_IV[5] | 0;\n        this.Dh = T256_IV[6] | 0;\n        this.Dl = T256_IV[7] | 0;\n        this.Eh = T256_IV[8] | 0;\n        this.El = T256_IV[9] | 0;\n        this.Fh = T256_IV[10] | 0;\n        this.Fl = T256_IV[11] | 0;\n        this.Gh = T256_IV[12] | 0;\n        this.Gl = T256_IV[13] | 0;\n        this.Hh = T256_IV[14] | 0;\n        this.Hl = T256_IV[15] | 0;\n    }\n}\n/**\n * SHA2-256 hash function from RFC 4634.\n *\n * It is the fastest JS hash, even faster than Blake3.\n * To break sha256 using birthday attack, attackers need to try 2^128 hashes.\n * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.\n */\nexport const sha256 = /* @__PURE__ */ createHasher(() => new SHA256());\n/** SHA2-224 hash function from RFC 4634 */\nexport const sha224 = /* @__PURE__ */ createHasher(() => new SHA224());\n/** SHA2-512 hash function from RFC 4634. */\nexport const sha512 = /* @__PURE__ */ createHasher(() => new SHA512());\n/** SHA2-384 hash function from RFC 4634. */\nexport const sha384 = /* @__PURE__ */ createHasher(() => new SHA384());\n/**\n * SHA2-512/256 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_256 = /* @__PURE__ */ createHasher(() => new SHA512_256());\n/**\n * SHA2-512/224 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_224 = /* @__PURE__ */ createHasher(() => new SHA512_224());\n//# sourceMappingURL=sha2.js.map"],"names":["SHA256_K","Uint32Array","from","SHA256_W","SHA256","HashMD","constructor","outputLen","super","this","A","SHA256_IV","B","C","D","E","F","G","H","get","set","process","view","offset","i","getUint32","W15","W2","s0","rotr","s1","T1","Chi","T2","Maj","roundClean","clean","destroy","buffer","K512","u64","split","map","n","BigInt","SHA512_Kh","SHA512_Kl","SHA512_W_H","SHA512_W_L","SHA512","Ah","SHA512_IV","Al","Bh","Bl","Ch","Cl","Dh","Dl","Eh","El","Fh","Fl","Gh","Gl","Hh","Hl","W15h","W15l","s0h","rotrSH","s0l","rotrSL","W2h","W2l","s1h","rotrBH","s1l","rotrBL","SUMl","SUMh","add4H","sigma1h","sigma1l","CHIh","CHIl","T1ll","T1h","T1l","sigma0h","sigma0l","MAJh","MAJl","h","l","add","All","add3L","sha256","createHasher","sha512"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"sha2.js","sources":["../../../../../../node_modules/@noble/hashes/esm/sha2.js"],"sourcesContent":["/**\n * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.\n * SHA256 is the fastest hash implementable in JS, even faster than Blake3.\n * Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and\n * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).\n * @module\n */\nimport { Chi, HashMD, Maj, SHA224_IV, SHA256_IV, SHA384_IV, SHA512_IV } from \"./_md.js\";\nimport * as u64 from \"./_u64.js\";\nimport { clean, createHasher, rotr } from \"./utils.js\";\n/**\n * Round constants:\n * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)\n */\n// prettier-ignore\nconst SHA256_K = /* @__PURE__ */ Uint32Array.from([\n    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\n/** Reusable temporary buffer. \"W\" comes straight from spec. */\nconst SHA256_W = /* @__PURE__ */ new Uint32Array(64);\nexport class SHA256 extends HashMD {\n    constructor(outputLen = 32) {\n        super(64, outputLen, 8, false);\n        // We cannot use array here since array allows indexing by variable\n        // which means optimizer/compiler cannot use registers.\n        this.A = SHA256_IV[0] | 0;\n        this.B = SHA256_IV[1] | 0;\n        this.C = SHA256_IV[2] | 0;\n        this.D = SHA256_IV[3] | 0;\n        this.E = SHA256_IV[4] | 0;\n        this.F = SHA256_IV[5] | 0;\n        this.G = SHA256_IV[6] | 0;\n        this.H = SHA256_IV[7] | 0;\n    }\n    get() {\n        const { A, B, C, D, E, F, G, H } = this;\n        return [A, B, C, D, E, F, G, H];\n    }\n    // prettier-ignore\n    set(A, B, C, D, E, F, G, H) {\n        this.A = A | 0;\n        this.B = B | 0;\n        this.C = C | 0;\n        this.D = D | 0;\n        this.E = E | 0;\n        this.F = F | 0;\n        this.G = G | 0;\n        this.H = H | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4)\n            SHA256_W[i] = view.getUint32(offset, false);\n        for (let i = 16; i < 64; i++) {\n            const W15 = SHA256_W[i - 15];\n            const W2 = SHA256_W[i - 2];\n            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);\n            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);\n            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;\n        }\n        // Compression function main loop, 64 rounds\n        let { A, B, C, D, E, F, G, H } = this;\n        for (let i = 0; i < 64; i++) {\n            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);\n            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);\n            const T2 = (sigma0 + Maj(A, B, C)) | 0;\n            H = G;\n            G = F;\n            F = E;\n            E = (D + T1) | 0;\n            D = C;\n            C = B;\n            B = A;\n            A = (T1 + T2) | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        A = (A + this.A) | 0;\n        B = (B + this.B) | 0;\n        C = (C + this.C) | 0;\n        D = (D + this.D) | 0;\n        E = (E + this.E) | 0;\n        F = (F + this.F) | 0;\n        G = (G + this.G) | 0;\n        H = (H + this.H) | 0;\n        this.set(A, B, C, D, E, F, G, H);\n    }\n    roundClean() {\n        clean(SHA256_W);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n        clean(this.buffer);\n    }\n}\nexport class SHA224 extends SHA256 {\n    constructor() {\n        super(28);\n        this.A = SHA224_IV[0] | 0;\n        this.B = SHA224_IV[1] | 0;\n        this.C = SHA224_IV[2] | 0;\n        this.D = SHA224_IV[3] | 0;\n        this.E = SHA224_IV[4] | 0;\n        this.F = SHA224_IV[5] | 0;\n        this.G = SHA224_IV[6] | 0;\n        this.H = SHA224_IV[7] | 0;\n    }\n}\n// SHA2-512 is slower than sha256 in js because u64 operations are slow.\n// Round contants\n// First 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409\n// prettier-ignore\nconst K512 = /* @__PURE__ */ (() => u64.split([\n    '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',\n    '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',\n    '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',\n    '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',\n    '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',\n    '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',\n    '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',\n    '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',\n    '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',\n    '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',\n    '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',\n    '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',\n    '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',\n    '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',\n    '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',\n    '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',\n    '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',\n    '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',\n    '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',\n    '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'\n].map(n => BigInt(n))))();\nconst SHA512_Kh = /* @__PURE__ */ (() => K512[0])();\nconst SHA512_Kl = /* @__PURE__ */ (() => K512[1])();\n// Reusable temporary buffers\nconst SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);\nconst SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);\nexport class SHA512 extends HashMD {\n    constructor(outputLen = 64) {\n        super(128, outputLen, 16, false);\n        // We cannot use array here since array allows indexing by variable\n        // which means optimizer/compiler cannot use registers.\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = SHA512_IV[0] | 0;\n        this.Al = SHA512_IV[1] | 0;\n        this.Bh = SHA512_IV[2] | 0;\n        this.Bl = SHA512_IV[3] | 0;\n        this.Ch = SHA512_IV[4] | 0;\n        this.Cl = SHA512_IV[5] | 0;\n        this.Dh = SHA512_IV[6] | 0;\n        this.Dl = SHA512_IV[7] | 0;\n        this.Eh = SHA512_IV[8] | 0;\n        this.El = SHA512_IV[9] | 0;\n        this.Fh = SHA512_IV[10] | 0;\n        this.Fl = SHA512_IV[11] | 0;\n        this.Gh = SHA512_IV[12] | 0;\n        this.Gl = SHA512_IV[13] | 0;\n        this.Hh = SHA512_IV[14] | 0;\n        this.Hl = SHA512_IV[15] | 0;\n    }\n    // prettier-ignore\n    get() {\n        const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];\n    }\n    // prettier-ignore\n    set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {\n        this.Ah = Ah | 0;\n        this.Al = Al | 0;\n        this.Bh = Bh | 0;\n        this.Bl = Bl | 0;\n        this.Ch = Ch | 0;\n        this.Cl = Cl | 0;\n        this.Dh = Dh | 0;\n        this.Dl = Dl | 0;\n        this.Eh = Eh | 0;\n        this.El = El | 0;\n        this.Fh = Fh | 0;\n        this.Fl = Fl | 0;\n        this.Gh = Gh | 0;\n        this.Gl = Gl | 0;\n        this.Hh = Hh | 0;\n        this.Hl = Hl | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4) {\n            SHA512_W_H[i] = view.getUint32(offset);\n            SHA512_W_L[i] = view.getUint32((offset += 4));\n        }\n        for (let i = 16; i < 80; i++) {\n            // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)\n            const W15h = SHA512_W_H[i - 15] | 0;\n            const W15l = SHA512_W_L[i - 15] | 0;\n            const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);\n            const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);\n            // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)\n            const W2h = SHA512_W_H[i - 2] | 0;\n            const W2l = SHA512_W_L[i - 2] | 0;\n            const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);\n            const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);\n            // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];\n            const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\n            const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);\n            SHA512_W_H[i] = SUMh | 0;\n            SHA512_W_L[i] = SUMl | 0;\n        }\n        let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        // Compression function main loop, 80 rounds\n        for (let i = 0; i < 80; i++) {\n            // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)\n            const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);\n            const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);\n            //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const CHIh = (Eh & Fh) ^ (~Eh & Gh);\n            const CHIl = (El & Fl) ^ (~El & Gl);\n            // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]\n            // prettier-ignore\n            const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\n            const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);\n            const T1l = T1ll | 0;\n            // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)\n            const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);\n            const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);\n            const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);\n            const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);\n            Hh = Gh | 0;\n            Hl = Gl | 0;\n            Gh = Fh | 0;\n            Gl = Fl | 0;\n            Fh = Eh | 0;\n            Fl = El | 0;\n            ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));\n            Dh = Ch | 0;\n            Dl = Cl | 0;\n            Ch = Bh | 0;\n            Cl = Bl | 0;\n            Bh = Ah | 0;\n            Bl = Al | 0;\n            const All = u64.add3L(T1l, sigma0l, MAJl);\n            Ah = u64.add3H(All, T1h, sigma0h, MAJh);\n            Al = All | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));\n        ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));\n        ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));\n        ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));\n        ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));\n        ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));\n        ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));\n        ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));\n        this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);\n    }\n    roundClean() {\n        clean(SHA512_W_H, SHA512_W_L);\n    }\n    destroy() {\n        clean(this.buffer);\n        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n    }\n}\nexport class SHA384 extends SHA512 {\n    constructor() {\n        super(48);\n        this.Ah = SHA384_IV[0] | 0;\n        this.Al = SHA384_IV[1] | 0;\n        this.Bh = SHA384_IV[2] | 0;\n        this.Bl = SHA384_IV[3] | 0;\n        this.Ch = SHA384_IV[4] | 0;\n        this.Cl = SHA384_IV[5] | 0;\n        this.Dh = SHA384_IV[6] | 0;\n        this.Dl = SHA384_IV[7] | 0;\n        this.Eh = SHA384_IV[8] | 0;\n        this.El = SHA384_IV[9] | 0;\n        this.Fh = SHA384_IV[10] | 0;\n        this.Fl = SHA384_IV[11] | 0;\n        this.Gh = SHA384_IV[12] | 0;\n        this.Gl = SHA384_IV[13] | 0;\n        this.Hh = SHA384_IV[14] | 0;\n        this.Hl = SHA384_IV[15] | 0;\n    }\n}\n/**\n * Truncated SHA512/256 and SHA512/224.\n * SHA512_IV is XORed with 0xa5a5a5a5a5a5a5a5, then used as \"intermediary\" IV of SHA512/t.\n * Then t hashes string to produce result IV.\n * See `test/misc/sha2-gen-iv.js`.\n */\n/** SHA512/224 IV */\nconst T224_IV = /* @__PURE__ */ Uint32Array.from([\n    0x8c3d37c8, 0x19544da2, 0x73e19966, 0x89dcd4d6, 0x1dfab7ae, 0x32ff9c82, 0x679dd514, 0x582f9fcf,\n    0x0f6d2b69, 0x7bd44da8, 0x77e36f73, 0x04c48942, 0x3f9d85a8, 0x6a1d36c8, 0x1112e6ad, 0x91d692a1,\n]);\n/** SHA512/256 IV */\nconst T256_IV = /* @__PURE__ */ Uint32Array.from([\n    0x22312194, 0xfc2bf72c, 0x9f555fa3, 0xc84c64c2, 0x2393b86b, 0x6f53b151, 0x96387719, 0x5940eabd,\n    0x96283ee2, 0xa88effe3, 0xbe5e1e25, 0x53863992, 0x2b0199fc, 0x2c85b8aa, 0x0eb72ddc, 0x81c52ca2,\n]);\nexport class SHA512_224 extends SHA512 {\n    constructor() {\n        super(28);\n        this.Ah = T224_IV[0] | 0;\n        this.Al = T224_IV[1] | 0;\n        this.Bh = T224_IV[2] | 0;\n        this.Bl = T224_IV[3] | 0;\n        this.Ch = T224_IV[4] | 0;\n        this.Cl = T224_IV[5] | 0;\n        this.Dh = T224_IV[6] | 0;\n        this.Dl = T224_IV[7] | 0;\n        this.Eh = T224_IV[8] | 0;\n        this.El = T224_IV[9] | 0;\n        this.Fh = T224_IV[10] | 0;\n        this.Fl = T224_IV[11] | 0;\n        this.Gh = T224_IV[12] | 0;\n        this.Gl = T224_IV[13] | 0;\n        this.Hh = T224_IV[14] | 0;\n        this.Hl = T224_IV[15] | 0;\n    }\n}\nexport class SHA512_256 extends SHA512 {\n    constructor() {\n        super(32);\n        this.Ah = T256_IV[0] | 0;\n        this.Al = T256_IV[1] | 0;\n        this.Bh = T256_IV[2] | 0;\n        this.Bl = T256_IV[3] | 0;\n        this.Ch = T256_IV[4] | 0;\n        this.Cl = T256_IV[5] | 0;\n        this.Dh = T256_IV[6] | 0;\n        this.Dl = T256_IV[7] | 0;\n        this.Eh = T256_IV[8] | 0;\n        this.El = T256_IV[9] | 0;\n        this.Fh = T256_IV[10] | 0;\n        this.Fl = T256_IV[11] | 0;\n        this.Gh = T256_IV[12] | 0;\n        this.Gl = T256_IV[13] | 0;\n        this.Hh = T256_IV[14] | 0;\n        this.Hl = T256_IV[15] | 0;\n    }\n}\n/**\n * SHA2-256 hash function from RFC 4634.\n *\n * It is the fastest JS hash, even faster than Blake3.\n * To break sha256 using birthday attack, attackers need to try 2^128 hashes.\n * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.\n */\nexport const sha256 = /* @__PURE__ */ createHasher(() => new SHA256());\n/** SHA2-224 hash function from RFC 4634 */\nexport const sha224 = /* @__PURE__ */ createHasher(() => new SHA224());\n/** SHA2-512 hash function from RFC 4634. */\nexport const sha512 = /* @__PURE__ */ createHasher(() => new SHA512());\n/** SHA2-384 hash function from RFC 4634. */\nexport const sha384 = /* @__PURE__ */ createHasher(() => new SHA384());\n/**\n * SHA2-512/256 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_256 = /* @__PURE__ */ createHasher(() => new SHA512_256());\n/**\n * SHA2-512/224 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_224 = /* @__PURE__ */ createHasher(() => new SHA512_224());\n//# sourceMappingURL=sha2.js.map"],"names":["SHA256_K","Uint32Array","from","SHA256_W","SHA256","HashMD","constructor","outputLen","super","this","A","SHA256_IV","B","C","D","E","F","G","H","get","set","process","view","offset","i","getUint32","W15","W2","s0","rotr","s1","T1","Chi","T2","Maj","roundClean","clean","destroy","buffer","K512","u64","map","n","BigInt","SHA512_Kh","SHA512_Kl","SHA512_W_H","SHA512_W_L","SHA512","Ah","SHA512_IV","Al","Bh","Bl","Ch","Cl","Dh","Dl","Eh","El","Fh","Fl","Gh","Gl","Hh","Hl","W15h","W15l","s0h","s0l","W2h","W2l","s1h","s1l","SUMl","SUMh","sigma1h","sigma1l","CHIh","CHIl","T1ll","T1h","T1l","sigma0h","sigma0l","MAJh","MAJl","h","l","All","sha256","createHasher","sha512"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@noble/hashes/esm/utils.js

@@ -1,3 +1,3 @@
-"use strict";var e=require("./crypto.js");
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */function t(e){return e instanceof Uint8Array||ArrayBuffer.isView(e)&&"Uint8Array"===e.constructor.name}function r(e,...r){if(!t(e))throw new Error("Uint8Array expected");if(r.length>0&&!r.includes(e.length))throw new Error("Uint8Array expected of length "+r+", got length="+e.length)}function n(e){if("string"!=typeof e)throw new Error("string expected");return new Uint8Array((new TextEncoder).encode(e))}function o(e){return"string"==typeof e&&(e=n(e)),r(e),e}exports.Hash=class{},exports.abytes=r,exports.aexists=function(e,t=!0){if(e.destroyed)throw new Error("Hash instance has been destroyed");if(t&&e.finished)throw new Error("Hash#digest() has already been called")},exports.anumber=function(e){if(!Number.isSafeInteger(e)||e<0)throw new Error("positive integer expected, got "+e)},exports.aoutput=function(e,t){r(e);const n=t.outputLen;if(e.length<n)throw new Error("digestInto() expects output buffer of length at least "+n)},exports.clean=function(...e){for(let t=0;t<e.length;t++)e[t].fill(0)},exports.createHasher=function(e){const t=t=>e().update(o(t)).digest(),r=e();return t.outputLen=r.outputLen,t.blockLen=r.blockLen,t.create=()=>e(),t},exports.createView=function(e){return new DataView(e.buffer,e.byteOffset,e.byteLength)},exports.isBytes=t,exports.randomBytes=function(t=32){if(e.crypto&&"function"==typeof e.crypto.getRandomValues)return e.crypto.getRandomValues(new Uint8Array(t));if(e.crypto&&"function"==typeof e.crypto.randomBytes)return Uint8Array.from(e.crypto.randomBytes(t));throw new Error("crypto.getRandomValues must be defined")},exports.rotr=function(e,t){return e<<32-t|e>>>t},exports.toBytes=o,exports.utf8ToBytes=n;
+"use strict";var t=require("./crypto.js");
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */function e(t){return t instanceof Uint8Array||ArrayBuffer.isView(t)&&"Uint8Array"===t.constructor.name}function r(t,...r){if(!e(t))throw new Error("Uint8Array expected");if(r.length>0&&!r.includes(t.length))throw new Error("Uint8Array expected of length "+r+", got length="+t.length)}const n=(()=>"function"==typeof Uint8Array.from([]).toHex&&"function"==typeof Uint8Array.fromHex)(),o=Array.from({length:256},(t,e)=>e.toString(16).padStart(2,"0"));const i=48,s=57,c=65,f=70,a=97,u=102;function p(t){return t>=i&&t<=s?t-i:t>=c&&t<=f?t-(c-10):t>=a&&t<=u?t-(a-10):void 0}function y(t){if("string"!=typeof t)throw new Error("string expected");return new Uint8Array((new TextEncoder).encode(t))}function h(t){return"string"==typeof t&&(t=y(t)),r(t),t}exports.Hash=class{},exports.abytes=r,exports.aexists=function(t,e=!0){if(t.destroyed)throw new Error("Hash instance has been destroyed");if(e&&t.finished)throw new Error("Hash#digest() has already been called")},exports.anumber=function(t){if(!Number.isSafeInteger(t)||t<0)throw new Error("positive integer expected, got "+t)},exports.aoutput=function(t,e){r(t);const n=e.outputLen;if(t.length<n)throw new Error("digestInto() expects output buffer of length at least "+n)},exports.bytesToHex=function(t){if(r(t),n)return t.toHex();let e="";for(let r=0;r<t.length;r++)e+=o[t[r]];return e},exports.clean=function(...t){for(let e=0;e<t.length;e++)t[e].fill(0)},exports.concatBytes=function(...t){let e=0;for(let n=0;n<t.length;n++){const o=t[n];r(o),e+=o.length}const n=new Uint8Array(e);for(let e=0,r=0;e<t.length;e++){const o=t[e];n.set(o,r),r+=o.length}return n},exports.createHasher=function(t){const e=e=>t().update(h(e)).digest(),r=t();return e.outputLen=r.outputLen,e.blockLen=r.blockLen,e.create=()=>t(),e},exports.createView=function(t){return new DataView(t.buffer,t.byteOffset,t.byteLength)},exports.hexToBytes=function(t){if("string"!=typeof t)throw new Error("hex string expected, got "+typeof t);if(n)return Uint8Array.fromHex(t);const e=t.length,r=e/2;if(e%2)throw new Error("hex string expected, got unpadded hex of length "+e);const o=new Uint8Array(r);for(let e=0,n=0;e<r;e++,n+=2){const r=p(t.charCodeAt(n)),i=p(t.charCodeAt(n+1));if(void 0===r||void 0===i){const e=t[n]+t[n+1];throw new Error('hex string expected, got non-hex character "'+e+'" at index '+n)}o[e]=16*r+i}return o},exports.isBytes=e,exports.randomBytes=function(e=32){if(t.crypto&&"function"==typeof t.crypto.getRandomValues)return t.crypto.getRandomValues(new Uint8Array(e));if(t.crypto&&"function"==typeof t.crypto.randomBytes)return Uint8Array.from(t.crypto.randomBytes(e));throw new Error("crypto.getRandomValues must be defined")},exports.rotr=function(t,e){return t<<32-e|t>>>e},exports.toBytes=h,exports.utf8ToBytes=y;
 //# sourceMappingURL=utils.js.map

package/dist/cjs/node_modules/@noble/hashes/esm/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sources":["../../../../../../node_modules/@noble/hashes/esm/utils.js"],"sourcesContent":["/**\n * Utilities for hex, bytes, CSPRNG.\n * @module\n */\n/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.\n// node.js versions earlier than v19 don't declare it in global scope.\n// For node.js, package.json#exports field mapping rewrites import\n// from `crypto` to `cryptoNode`, which imports native module.\n// Makes the utils un-importable in browsers without a bundler.\n// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.\nimport { crypto } from '@noble/hashes/crypto';\n/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */\nexport function isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n/** Asserts something is positive integer. */\nexport function anumber(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error('positive integer expected, got ' + n);\n}\n/** Asserts something is Uint8Array. */\nexport function abytes(b, ...lengths) {\n    if (!isBytes(b))\n        throw new Error('Uint8Array expected');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);\n}\n/** Asserts something is hash */\nexport function ahash(h) {\n    if (typeof h !== 'function' || typeof h.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.createHasher');\n    anumber(h.outputLen);\n    anumber(h.blockLen);\n}\n/** Asserts a hash instance has not been destroyed / finished */\nexport function aexists(instance, checkFinished = true) {\n    if (instance.destroyed)\n        throw new Error('Hash instance has been destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('Hash#digest() has already been called');\n}\n/** Asserts output is properly-sized byte array */\nexport function aoutput(out, instance) {\n    abytes(out);\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error('digestInto() expects output buffer of length at least ' + min);\n    }\n}\n/** Cast u8 / u16 / u32 to u8. */\nexport function u8(arr) {\n    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/** Cast u8 / u16 / u32 to u32. */\nexport function u32(arr) {\n    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n/** Zeroize a byte array. Warning: JS provides no guarantees. */\nexport function clean(...arrays) {\n    for (let i = 0; i < arrays.length; i++) {\n        arrays[i].fill(0);\n    }\n}\n/** Create DataView of an array for easy byte-level manipulation. */\nexport function createView(arr) {\n    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/** The rotate right (circular right shift) operation for uint32 */\nexport function rotr(word, shift) {\n    return (word << (32 - shift)) | (word >>> shift);\n}\n/** The rotate left (circular left shift) operation for uint32 */\nexport function rotl(word, shift) {\n    return (word << shift) | ((word >>> (32 - shift)) >>> 0);\n}\n/** Is current platform little-endian? Most are. Big-Endian platform: IBM */\nexport const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n/** The byte swap operation for uint32 */\nexport function byteSwap(word) {\n    return (((word << 24) & 0xff000000) |\n        ((word << 8) & 0xff0000) |\n        ((word >>> 8) & 0xff00) |\n        ((word >>> 24) & 0xff));\n}\n/** Conditionally byte swap if on a big-endian platform */\nexport const swap8IfBE = isLE\n    ? (n) => n\n    : (n) => byteSwap(n);\n/** @deprecated */\nexport const byteSwapIfBE = swap8IfBE;\n/** In place byte swap for Uint32Array */\nexport function byteSwap32(arr) {\n    for (let i = 0; i < arr.length; i++) {\n        arr[i] = byteSwap(arr[i]);\n    }\n    return arr;\n}\nexport const swap32IfBE = isLE\n    ? (u) => u\n    : byteSwap32;\n// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\nconst hasHexBuiltin = /* @__PURE__ */ (() => \n// @ts-ignore\ntypeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * Convert byte array to hex string. Uses built-in function, when available.\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    abytes(bytes);\n    // @ts-ignore\n    if (hasHexBuiltin)\n        return bytes.toHex();\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };\nfunction asciiToBase16(ch) {\n    if (ch >= asciis._0 && ch <= asciis._9)\n        return ch - asciis._0; // '2' => 50-48\n    if (ch >= asciis.A && ch <= asciis.F)\n        return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n    if (ch >= asciis.a && ch <= asciis.f)\n        return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n    return;\n}\n/**\n * Convert hex string to byte array. Uses built-in function, when available.\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    // @ts-ignore\n    if (hasHexBuiltin)\n        return Uint8Array.fromHex(hex);\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new Error('hex string expected, got unpadded hex of length ' + hl);\n    const array = new Uint8Array(al);\n    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n        const n1 = asciiToBase16(hex.charCodeAt(hi));\n        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n        if (n1 === undefined || n2 === undefined) {\n            const char = hex[hi] + hex[hi + 1];\n            throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n        }\n        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n    }\n    return array;\n}\n/**\n * There is no setImmediate in browser and setTimeout is slow.\n * Call of async fn will return Promise, which will be fullfiled only on\n * next scheduler queue processing step and this is exactly what we need.\n */\nexport const nextTick = async () => { };\n/** Returns control to thread each 'tick' ms to avoid blocking. */\nexport async function asyncLoop(iters, tick, cb) {\n    let ts = Date.now();\n    for (let i = 0; i < iters; i++) {\n        cb(i);\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < tick)\n            continue;\n        await nextTick();\n        ts += diff;\n    }\n}\n/**\n * Converts string to bytes using UTF8 encoding.\n * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error('string expected');\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Converts bytes to string using UTF8 encoding.\n * @example bytesToUtf8(Uint8Array.from([97, 98, 99])) // 'abc'\n */\nexport function bytesToUtf8(bytes) {\n    return new TextDecoder().decode(bytes);\n}\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    abytes(data);\n    return data;\n}\n/**\n * Helper for KDFs: consumes uint8array or string.\n * When string is passed, does utf8 decoding, using TextDecoder.\n */\nexport function kdfInputToBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    abytes(data);\n    return data;\n}\n/** Copies several Uint8Arrays into one. */\nexport function concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        abytes(a);\n        sum += a.length;\n    }\n    const res = new Uint8Array(sum);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        res.set(a, pad);\n        pad += a.length;\n    }\n    return res;\n}\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')\n        throw new Error('options should be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\n/** For runtime check if class implements interface */\nexport class Hash {\n}\n/** Wraps hash function, creating an interface on top of it */\nexport function createHasher(hashCons) {\n    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();\n    const tmp = hashCons();\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = () => hashCons();\n    return hashC;\n}\nexport function createOptHasher(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport function createXOFer(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport const wrapConstructor = createHasher;\nexport const wrapConstructorWithOpts = createOptHasher;\nexport const wrapXOFConstructorWithOpts = createXOFer;\n/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */\nexport function randomBytes(bytesLength = 32) {\n    if (crypto && typeof crypto.getRandomValues === 'function') {\n        return crypto.getRandomValues(new Uint8Array(bytesLength));\n    }\n    // Legacy Node.js compatibility\n    if (crypto && typeof crypto.randomBytes === 'function') {\n        return Uint8Array.from(crypto.randomBytes(bytesLength));\n    }\n    throw new Error('crypto.getRandomValues must be defined');\n}\n//# sourceMappingURL=utils.js.map"],"names":["isBytes","a","Uint8Array","ArrayBuffer","isView","constructor","name","abytes","b","lengths","Error","length","includes","utf8ToBytes","str","TextEncoder","encode","toBytes","data","instance","checkFinished","destroyed","finished","n","Number","isSafeInteger","out","min","outputLen","arrays","i","fill","arr","DataView","buffer","byteOffset","byteLength","word","shift"],"mappings":";sEAeA,SAAAA,EAAAC,GACE,OAAOA,aAAaC,YAAeC,YAAOC,OAAAH,IAAA,eAAAA,EAAAI,YAAAC,IAC5C,CAQM,SAAUC,EAAOC,KAA8BC,GACnD,IAAKT,EAAQQ,GAAI,MAAM,IAAIE,MAAM,uBACnC,GAAAD,EAAAE,OAAA,IAAAF,EAAAG,SAAAJ,EAAAG,QACI,MAAM,IAAID,MAAM,iCAAWD,EAAA,gBAAAD,EAAAG,OAC/B,CAyLM,SAASE,EAAAC,GACf,GAAA,iBAAAA,EAAA,MAAA,IAAAJ,MAAA,mBACE,OAAO,IAAIR,YAAW,IAAIa,aAAcC,OAAAF,GAC1C,CAiBM,SAAUG,EAAQC,GAGxB,MAFsB,iBAATA,IAAmBA,EAAOL,EAASK,IAC9CX,EAAOW,GACTA,CACA,uDAtMM,SAAkBC,EAAeC,GAAgB,GACvD,GAAAD,EAAAE,UAAA,MAAA,IAAAX,MAAA,oCACE,GAAIU,GAAiBD,EAASG,SAAU,MAAM,IAACZ,MAAA,wCACjD,kBAvBA,SAAAa,GACE,IAAKC,OAAOC,cAAcF,IAAMA,EAAI,EAAA,MAAA,IAAAb,MAAA,kCAAAa,EACtC,kBAwBM,SAAkBG,EAAEP,GACxBZ,EAAOmB,GACP,MAAEC,EAAAR,EAAAS,UACJ,GAAAF,EAAAf,OAAAgB,EACI,MAAM,IAAIjB,MAAM,yDAAYiB,EAEhC,gBAkBM,YAAmBE,GACzB,IAAA,IAAAC,EAAA,EAAAA,EAAAD,EAAAlB,OAAAmB,IACID,EAAOC,GAAGC,KAAK,EAEnB,0KAGM,SAAqBC,GACzB,OAAO,IAAIC,SAASD,EAAIE,OAAQF,EAAIG,WAAEH,EAAAI,WACxC,gVAGM,SAAeC,EAAWC,GAC9B,OAAQD,GAAS,GAAKC,EAAOD,IAAAC,CAC/B","x_google_ignoreList":[0]}
+{"version":3,"file":"utils.js","sources":["../../../../../../node_modules/@noble/hashes/esm/utils.js"],"sourcesContent":["/**\n * Utilities for hex, bytes, CSPRNG.\n * @module\n */\n/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.\n// node.js versions earlier than v19 don't declare it in global scope.\n// For node.js, package.json#exports field mapping rewrites import\n// from `crypto` to `cryptoNode`, which imports native module.\n// Makes the utils un-importable in browsers without a bundler.\n// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.\nimport { crypto } from '@noble/hashes/crypto';\n/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */\nexport function isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n/** Asserts something is positive integer. */\nexport function anumber(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error('positive integer expected, got ' + n);\n}\n/** Asserts something is Uint8Array. */\nexport function abytes(b, ...lengths) {\n    if (!isBytes(b))\n        throw new Error('Uint8Array expected');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);\n}\n/** Asserts something is hash */\nexport function ahash(h) {\n    if (typeof h !== 'function' || typeof h.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.createHasher');\n    anumber(h.outputLen);\n    anumber(h.blockLen);\n}\n/** Asserts a hash instance has not been destroyed / finished */\nexport function aexists(instance, checkFinished = true) {\n    if (instance.destroyed)\n        throw new Error('Hash instance has been destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('Hash#digest() has already been called');\n}\n/** Asserts output is properly-sized byte array */\nexport function aoutput(out, instance) {\n    abytes(out);\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error('digestInto() expects output buffer of length at least ' + min);\n    }\n}\n/** Cast u8 / u16 / u32 to u8. */\nexport function u8(arr) {\n    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/** Cast u8 / u16 / u32 to u32. */\nexport function u32(arr) {\n    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n/** Zeroize a byte array. Warning: JS provides no guarantees. */\nexport function clean(...arrays) {\n    for (let i = 0; i < arrays.length; i++) {\n        arrays[i].fill(0);\n    }\n}\n/** Create DataView of an array for easy byte-level manipulation. */\nexport function createView(arr) {\n    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/** The rotate right (circular right shift) operation for uint32 */\nexport function rotr(word, shift) {\n    return (word << (32 - shift)) | (word >>> shift);\n}\n/** The rotate left (circular left shift) operation for uint32 */\nexport function rotl(word, shift) {\n    return (word << shift) | ((word >>> (32 - shift)) >>> 0);\n}\n/** Is current platform little-endian? Most are. Big-Endian platform: IBM */\nexport const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n/** The byte swap operation for uint32 */\nexport function byteSwap(word) {\n    return (((word << 24) & 0xff000000) |\n        ((word << 8) & 0xff0000) |\n        ((word >>> 8) & 0xff00) |\n        ((word >>> 24) & 0xff));\n}\n/** Conditionally byte swap if on a big-endian platform */\nexport const swap8IfBE = isLE\n    ? (n) => n\n    : (n) => byteSwap(n);\n/** @deprecated */\nexport const byteSwapIfBE = swap8IfBE;\n/** In place byte swap for Uint32Array */\nexport function byteSwap32(arr) {\n    for (let i = 0; i < arr.length; i++) {\n        arr[i] = byteSwap(arr[i]);\n    }\n    return arr;\n}\nexport const swap32IfBE = isLE\n    ? (u) => u\n    : byteSwap32;\n// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\nconst hasHexBuiltin = /* @__PURE__ */ (() => \n// @ts-ignore\ntypeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * Convert byte array to hex string. Uses built-in function, when available.\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    abytes(bytes);\n    // @ts-ignore\n    if (hasHexBuiltin)\n        return bytes.toHex();\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };\nfunction asciiToBase16(ch) {\n    if (ch >= asciis._0 && ch <= asciis._9)\n        return ch - asciis._0; // '2' => 50-48\n    if (ch >= asciis.A && ch <= asciis.F)\n        return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n    if (ch >= asciis.a && ch <= asciis.f)\n        return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n    return;\n}\n/**\n * Convert hex string to byte array. Uses built-in function, when available.\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    // @ts-ignore\n    if (hasHexBuiltin)\n        return Uint8Array.fromHex(hex);\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new Error('hex string expected, got unpadded hex of length ' + hl);\n    const array = new Uint8Array(al);\n    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n        const n1 = asciiToBase16(hex.charCodeAt(hi));\n        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n        if (n1 === undefined || n2 === undefined) {\n            const char = hex[hi] + hex[hi + 1];\n            throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n        }\n        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n    }\n    return array;\n}\n/**\n * There is no setImmediate in browser and setTimeout is slow.\n * Call of async fn will return Promise, which will be fullfiled only on\n * next scheduler queue processing step and this is exactly what we need.\n */\nexport const nextTick = async () => { };\n/** Returns control to thread each 'tick' ms to avoid blocking. */\nexport async function asyncLoop(iters, tick, cb) {\n    let ts = Date.now();\n    for (let i = 0; i < iters; i++) {\n        cb(i);\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < tick)\n            continue;\n        await nextTick();\n        ts += diff;\n    }\n}\n/**\n * Converts string to bytes using UTF8 encoding.\n * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error('string expected');\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Converts bytes to string using UTF8 encoding.\n * @example bytesToUtf8(Uint8Array.from([97, 98, 99])) // 'abc'\n */\nexport function bytesToUtf8(bytes) {\n    return new TextDecoder().decode(bytes);\n}\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    abytes(data);\n    return data;\n}\n/**\n * Helper for KDFs: consumes uint8array or string.\n * When string is passed, does utf8 decoding, using TextDecoder.\n */\nexport function kdfInputToBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    abytes(data);\n    return data;\n}\n/** Copies several Uint8Arrays into one. */\nexport function concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        abytes(a);\n        sum += a.length;\n    }\n    const res = new Uint8Array(sum);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        res.set(a, pad);\n        pad += a.length;\n    }\n    return res;\n}\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')\n        throw new Error('options should be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\n/** For runtime check if class implements interface */\nexport class Hash {\n}\n/** Wraps hash function, creating an interface on top of it */\nexport function createHasher(hashCons) {\n    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();\n    const tmp = hashCons();\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = () => hashCons();\n    return hashC;\n}\nexport function createOptHasher(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport function createXOFer(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport const wrapConstructor = createHasher;\nexport const wrapConstructorWithOpts = createOptHasher;\nexport const wrapXOFConstructorWithOpts = createXOFer;\n/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */\nexport function randomBytes(bytesLength = 32) {\n    if (crypto && typeof crypto.getRandomValues === 'function') {\n        return crypto.getRandomValues(new Uint8Array(bytesLength));\n    }\n    // Legacy Node.js compatibility\n    if (crypto && typeof crypto.randomBytes === 'function') {\n        return Uint8Array.from(crypto.randomBytes(bytesLength));\n    }\n    throw new Error('crypto.getRandomValues must be defined');\n}\n//# sourceMappingURL=utils.js.map"],"names":["isBytes","a","Uint8Array","ArrayBuffer","isView","constructor","name","abytes","b","lengths","Error","length","includes","hasHexBuiltin","from","toHex","fromHex","hexes","Array","_","i","toString","padStart","asciis","asciiToBase16","ch","utf8ToBytes","str","TextEncoder","encode","toBytes","data","instance","checkFinished","destroyed","finished","n","Number","isSafeInteger","out","min","outputLen","bytes","hex","arrays","fill","sum","res","pad","set","arr","DataView","buffer","byteOffset","byteLength","hl","al","array","ai","hi","n1","charCodeAt","n2","undefined","char","word","shift"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@scure/base/lib/esm/index.js

@@ -1,3 +1,3 @@
 "use strict";
-/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */function r(r){return r instanceof Uint8Array||ArrayBuffer.isView(r)&&"Uint8Array"===r.constructor.name}function e(r,e){return!!Array.isArray(e)&&(0===e.length||(r?e.every((r=>"string"==typeof r)):e.every((r=>Number.isSafeInteger(r)))))}function o(r,e){if("string"!=typeof e)throw new Error(`${r}: string expected`);return!0}function n(r){if(!Number.isSafeInteger(r))throw new Error(`invalid integer: ${r}`)}function t(r){if(!Array.isArray(r))throw new Error("array expected")}function i(r,o){if(!e(!0,o))throw new Error(`${r}: array of strings expected`)}function c(r,o){if(!e(!1,o))throw new Error(`${r}: array of numbers expected`)}const d=(r,e)=>0===e?r:d(e,r%e),f=(r,e)=>r+(e-d(r,e)),s=(()=>{let r=[];for(let e=0;e<40;e++)r.push(2**e);return r})();function a(r,e,o,i){if(t(r),e<=0||e>32)throw new Error(`convertRadix2: wrong from=${e}`);if(o<=0||o>32)throw new Error(`convertRadix2: wrong to=${o}`);if(f(e,o)>32)throw new Error(`convertRadix2: carry overflow from=${e} to=${o} carryBits=${f(e,o)}`);let c=0,d=0;const a=s[e],w=s[o]-1,u=[];for(const t of r){if(n(t),t>=a)throw new Error(`convertRadix2: invalid data word=${t} from=${e}`);if(c=c<<e|t,d+e>32)throw new Error(`convertRadix2: carry overflow pos=${d} from=${e}`);for(d+=e;d>=o;d-=o)u.push((c>>d-o&w)>>>0);const r=s[d];if(void 0===r)throw new Error("invalid carry");c&=r-1}if(c=c<<o-d&w,!i&&d>=e)throw new Error("Excess padding");if(!i&&c>0)throw new Error(`Non-zero padding: ${c}`);return i&&d>0&&u.push(c>>>0),u}function w(r){return function(r){if("function"!=typeof r)throw new Error("function expected")}(r),function(...e){try{return r.apply(null,e)}catch(r){}}}const u=function(...r){const e=r=>r,o=(r,e)=>o=>r(e(o));return{encode:r.map((r=>r.encode)).reduceRight(o,e),decode:r.map((r=>r.decode)).reduce(o,e)}}(function(r){const e="string"==typeof r?r.split(""):r,n=e.length;i("alphabet",e);const c=new Map(e.map(((r,e)=>[r,e])));return{encode:o=>(t(o),o.map((o=>{if(!Number.isSafeInteger(o)||o<0||o>=n)throw new Error(`alphabet.encode: digit index outside alphabet "${o}". Allowed: ${r}`);return e[o]}))),decode:e=>(t(e),e.map((e=>{o("alphabet.decode",e);const n=c.get(e);if(void 0===n)throw new Error(`Unknown letter: "${e}". Allowed: ${r}`);return n})))}}("qpzry9x8gf2tvdw0s3jn54khce6mua7l"),function(r=""){return o("join",r),{encode:e=>(i("join.decode",e),e.join(r)),decode:e=>(o("join.decode",e),e.split(r))}}("")),h=[996825010,642813549,513874426,1027748829,705979059];function l(r){const e=r>>25;let o=(33554431&r)<<5;for(let r=0;r<h.length;r++)1==(e>>r&1)&&(o^=h[r]);return o}function p(r,e,o=1){const n=r.length;let t=1;for(let e=0;e<n;e++){const o=r.charCodeAt(e);if(o<33||o>126)throw new Error(`Invalid prefix (${r})`);t=l(t)^o>>5}t=l(t);for(let e=0;e<n;e++)t=l(t)^31&r.charCodeAt(e);for(let r of e)t=l(t)^r;for(let r=0;r<6;r++)t=l(t);return t^=o,u.encode(a([t%s[30]],30,5,!1))}const y=function(e){const t="bech32"===e?1:734539939,i=function(e,o=!1){if(n(e),e<=0||e>32)throw new Error("radix2: bits should be in (0..32]");if(f(8,e)>32||f(e,8)>32)throw new Error("radix2: carry overflow");return{encode:n=>{if(!r(n))throw new Error("radix2.encode input should be Uint8Array");return a(Array.from(n),8,e,!o)},decode:r=>(c("radix2.decode",r),Uint8Array.from(a(r,e,8,o)))}}(5),d=i.decode,s=i.encode,h=w(d);function l(e,n,i=90){o("bech32.encode prefix",e),r(n)&&(n=Array.from(n)),c("bech32.encode",n);const d=e.length;if(0===d)throw new TypeError(`Invalid prefix length ${d}`);const f=d+7+n.length;if(!1!==i&&f>i)throw new TypeError(`Length ${f} exceeds limit ${i}`);const s=e.toLowerCase(),a=p(s,n,t);return`${s}1${u.encode(n)}${a}`}function y(r,e=90){o("bech32.decode input",r);const n=r.length;if(n<8||!1!==e&&n>e)throw new TypeError(`invalid string length: ${n} (${r}). Expected (8..${e})`);const i=r.toLowerCase();if(r!==i&&r!==r.toUpperCase())throw new Error("String must be lowercase or uppercase");const c=i.lastIndexOf("1");if(0===c||-1===c)throw new Error('Letter "1" must be present between prefix and data only');const d=i.slice(0,c),f=i.slice(c+1);if(f.length<6)throw new Error("Data must be at least 6 characters long");const s=u.decode(f).slice(0,-6),a=p(d,s,t);if(!f.endsWith(a))throw new Error(`Invalid checksum in ${r}: expected "${a}"`);return{prefix:d,words:s}}return{encode:l,decode:y,encodeFromBytes:function(r,e){return l(r,s(e))},decodeToBytes:function(r){const{prefix:e,words:o}=y(r,!1);return{prefix:e,words:o,bytes:d(o)}},decodeUnsafe:w(y),fromWords:d,fromWordsUnsafe:h,toWords:s}}("bech32");exports.bech32=y;
+/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */function r(r){return r instanceof Uint8Array||ArrayBuffer.isView(r)&&"Uint8Array"===r.constructor.name}function e(r,e){return!!Array.isArray(e)&&(0===e.length||(r?e.every(r=>"string"==typeof r):e.every(r=>Number.isSafeInteger(r))))}function o(r,e){if("string"!=typeof e)throw new Error(`${r}: string expected`);return!0}function n(r){if(!Number.isSafeInteger(r))throw new Error(`invalid integer: ${r}`)}function t(r){if(!Array.isArray(r))throw new Error("array expected")}function i(r,o){if(!e(!0,o))throw new Error(`${r}: array of strings expected`)}function c(r,o){if(!e(!1,o))throw new Error(`${r}: array of numbers expected`)}const d=(r,e)=>0===e?r:d(e,r%e),f=(r,e)=>r+(e-d(r,e)),s=(()=>{let r=[];for(let e=0;e<40;e++)r.push(2**e);return r})();function a(r,e,o,i){if(t(r),e<=0||e>32)throw new Error(`convertRadix2: wrong from=${e}`);if(o<=0||o>32)throw new Error(`convertRadix2: wrong to=${o}`);if(f(e,o)>32)throw new Error(`convertRadix2: carry overflow from=${e} to=${o} carryBits=${f(e,o)}`);let c=0,d=0;const a=s[e],w=s[o]-1,u=[];for(const t of r){if(n(t),t>=a)throw new Error(`convertRadix2: invalid data word=${t} from=${e}`);if(c=c<<e|t,d+e>32)throw new Error(`convertRadix2: carry overflow pos=${d} from=${e}`);for(d+=e;d>=o;d-=o)u.push((c>>d-o&w)>>>0);const r=s[d];if(void 0===r)throw new Error("invalid carry");c&=r-1}if(c=c<<o-d&w,!i&&d>=e)throw new Error("Excess padding");if(!i&&c>0)throw new Error(`Non-zero padding: ${c}`);return i&&d>0&&u.push(c>>>0),u}function w(r){return function(r){if("function"!=typeof r)throw new Error("function expected")}(r),function(...e){try{return r.apply(null,e)}catch(r){}}}const u=function(...r){const e=r=>r,o=(r,e)=>o=>r(e(o));return{encode:r.map(r=>r.encode).reduceRight(o,e),decode:r.map(r=>r.decode).reduce(o,e)}}(function(r){const e="string"==typeof r?r.split(""):r,n=e.length;i("alphabet",e);const c=new Map(e.map((r,e)=>[r,e]));return{encode:o=>(t(o),o.map(o=>{if(!Number.isSafeInteger(o)||o<0||o>=n)throw new Error(`alphabet.encode: digit index outside alphabet "${o}". Allowed: ${r}`);return e[o]})),decode:e=>(t(e),e.map(e=>{o("alphabet.decode",e);const n=c.get(e);if(void 0===n)throw new Error(`Unknown letter: "${e}". Allowed: ${r}`);return n}))}}("qpzry9x8gf2tvdw0s3jn54khce6mua7l"),function(r=""){return o("join",r),{encode:e=>(i("join.decode",e),e.join(r)),decode:e=>(o("join.decode",e),e.split(r))}}("")),h=[996825010,642813549,513874426,1027748829,705979059];function l(r){const e=r>>25;let o=(33554431&r)<<5;for(let r=0;r<h.length;r++)1==(e>>r&1)&&(o^=h[r]);return o}function p(r,e,o=1){const n=r.length;let t=1;for(let e=0;e<n;e++){const o=r.charCodeAt(e);if(o<33||o>126)throw new Error(`Invalid prefix (${r})`);t=l(t)^o>>5}t=l(t);for(let e=0;e<n;e++)t=l(t)^31&r.charCodeAt(e);for(let r of e)t=l(t)^r;for(let r=0;r<6;r++)t=l(t);return t^=o,u.encode(a([t%s[30]],30,5,!1))}const y=function(e){const t="bech32"===e?1:734539939,i=function(e,o=!1){if(n(e),e<=0||e>32)throw new Error("radix2: bits should be in (0..32]");if(f(8,e)>32||f(e,8)>32)throw new Error("radix2: carry overflow");return{encode:n=>{if(!r(n))throw new Error("radix2.encode input should be Uint8Array");return a(Array.from(n),8,e,!o)},decode:r=>(c("radix2.decode",r),Uint8Array.from(a(r,e,8,o)))}}(5),d=i.decode,s=i.encode,h=w(d);function l(e,n,i=90){o("bech32.encode prefix",e),r(n)&&(n=Array.from(n)),c("bech32.encode",n);const d=e.length;if(0===d)throw new TypeError(`Invalid prefix length ${d}`);const f=d+7+n.length;if(!1!==i&&f>i)throw new TypeError(`Length ${f} exceeds limit ${i}`);const s=e.toLowerCase(),a=p(s,n,t);return`${s}1${u.encode(n)}${a}`}function y(r,e=90){o("bech32.decode input",r);const n=r.length;if(n<8||!1!==e&&n>e)throw new TypeError(`invalid string length: ${n} (${r}). Expected (8..${e})`);const i=r.toLowerCase();if(r!==i&&r!==r.toUpperCase())throw new Error("String must be lowercase or uppercase");const c=i.lastIndexOf("1");if(0===c||-1===c)throw new Error('Letter "1" must be present between prefix and data only');const d=i.slice(0,c),f=i.slice(c+1);if(f.length<6)throw new Error("Data must be at least 6 characters long");const s=u.decode(f).slice(0,-6),a=p(d,s,t);if(!f.endsWith(a))throw new Error(`Invalid checksum in ${r}: expected "${a}"`);return{prefix:d,words:s}}return{encode:l,decode:y,encodeFromBytes:function(r,e){return l(r,s(e))},decodeToBytes:function(r){const{prefix:e,words:o}=y(r,!1);return{prefix:e,words:o,bytes:d(o)}},decodeUnsafe:w(y),fromWords:d,fromWordsUnsafe:h,toWords:s}}("bech32");exports.bech32=y;
 //# sourceMappingURL=index.js.map