superstack-wallet-sdk 0.4.5 → 0.4.8

package/dist/esm/node_modules/.pnpm/@noble_hashes@1.8.0/node_modules/@noble/hashes/esm/sha2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha2.js","sources":["../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.8.0/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","sha256","createHasher"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/@noble_hashes@1.8.0/node_modules/@noble/hashes/esm/sha256.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.js","sources":["../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha256.js"],"sourcesContent":["/**\n * SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.\n *\n * To break sha256 using birthday attack, attackers need to try 2^128 hashes.\n * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.\n *\n * Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).\n * @module\n * @deprecated\n */\nimport { SHA224 as SHA224n, sha224 as sha224n, SHA256 as SHA256n, sha256 as sha256n, } from \"./sha2.js\";\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const SHA256 = SHA256n;\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const sha256 = sha256n;\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const SHA224 = SHA224n;\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const sha224 = sha224n;\n//# sourceMappingURL=sha256.js.map"],"names":["sha256","sha256n"],"mappings":"mCAcY,MAACA,EAASC","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/@noble_hashes@1.8.0/node_modules/@noble/hashes/esm/sha3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha3.js","sources":["../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha3.js"],"sourcesContent":["/**\n * SHA3 (keccak) hash function, based on a new \"Sponge function\" design.\n * Different from older hashes, the internal state is bigger than output size.\n *\n * Check out [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),\n * [Website](https://keccak.team/keccak.html),\n * [the differences between SHA-3 and Keccak](https://crypto.stackexchange.com/questions/15727/what-are-the-key-differences-between-the-draft-sha-3-standard-and-the-keccak-sub).\n *\n * Check out `sha3-addons` module for cSHAKE, k12, and others.\n * @module\n */\nimport { rotlBH, rotlBL, rotlSH, rotlSL, split } from \"./_u64.js\";\n// prettier-ignore\nimport { abytes, aexists, anumber, aoutput, clean, createHasher, createXOFer, Hash, swap32IfBE, toBytes, u32 } from \"./utils.js\";\n// No __PURE__ annotations in sha3 header:\n// EVERYTHING is in fact used on every export.\n// Various per round constants calculations\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nconst _2n = BigInt(2);\nconst _7n = BigInt(7);\nconst _256n = BigInt(256);\nconst _0x71n = BigInt(0x71);\nconst SHA3_PI = [];\nconst SHA3_ROTL = [];\nconst _SHA3_IOTA = [];\nfor (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {\n    // Pi\n    [x, y] = [y, (2 * x + 3 * y) % 5];\n    SHA3_PI.push(2 * (5 * y + x));\n    // Rotational\n    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);\n    // Iota\n    let t = _0n;\n    for (let j = 0; j < 7; j++) {\n        R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;\n        if (R & _2n)\n            t ^= _1n << ((_1n << /* @__PURE__ */ BigInt(j)) - _1n);\n    }\n    _SHA3_IOTA.push(t);\n}\nconst IOTAS = split(_SHA3_IOTA, true);\nconst SHA3_IOTA_H = IOTAS[0];\nconst SHA3_IOTA_L = IOTAS[1];\n// Left rotation (without 0, 32, 64)\nconst rotlH = (h, l, s) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));\nconst rotlL = (h, l, s) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));\n/** `keccakf1600` internal function, additionally allows to adjust round count. */\nexport function keccakP(s, rounds = 24) {\n    const B = new Uint32Array(5 * 2);\n    // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)\n    for (let round = 24 - rounds; round < 24; round++) {\n        // Theta θ\n        for (let x = 0; x < 10; x++)\n            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];\n        for (let x = 0; x < 10; x += 2) {\n            const idx1 = (x + 8) % 10;\n            const idx0 = (x + 2) % 10;\n            const B0 = B[idx0];\n            const B1 = B[idx0 + 1];\n            const Th = rotlH(B0, B1, 1) ^ B[idx1];\n            const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];\n            for (let y = 0; y < 50; y += 10) {\n                s[x + y] ^= Th;\n                s[x + y + 1] ^= Tl;\n            }\n        }\n        // Rho (ρ) and Pi (π)\n        let curH = s[2];\n        let curL = s[3];\n        for (let t = 0; t < 24; t++) {\n            const shift = SHA3_ROTL[t];\n            const Th = rotlH(curH, curL, shift);\n            const Tl = rotlL(curH, curL, shift);\n            const PI = SHA3_PI[t];\n            curH = s[PI];\n            curL = s[PI + 1];\n            s[PI] = Th;\n            s[PI + 1] = Tl;\n        }\n        // Chi (χ)\n        for (let y = 0; y < 50; y += 10) {\n            for (let x = 0; x < 10; x++)\n                B[x] = s[y + x];\n            for (let x = 0; x < 10; x++)\n                s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];\n        }\n        // Iota (ι)\n        s[0] ^= SHA3_IOTA_H[round];\n        s[1] ^= SHA3_IOTA_L[round];\n    }\n    clean(B);\n}\n/** Keccak sponge function. */\nexport class Keccak extends Hash {\n    // NOTE: we accept arguments in bytes instead of bits here.\n    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {\n        super();\n        this.pos = 0;\n        this.posOut = 0;\n        this.finished = false;\n        this.destroyed = false;\n        this.enableXOF = false;\n        this.blockLen = blockLen;\n        this.suffix = suffix;\n        this.outputLen = outputLen;\n        this.enableXOF = enableXOF;\n        this.rounds = rounds;\n        // Can be passed from user as dkLen\n        anumber(outputLen);\n        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes\n        // 0 < blockLen < 200\n        if (!(0 < blockLen && blockLen < 200))\n            throw new Error('only keccak-f1600 function is supported');\n        this.state = new Uint8Array(200);\n        this.state32 = u32(this.state);\n    }\n    clone() {\n        return this._cloneInto();\n    }\n    keccak() {\n        swap32IfBE(this.state32);\n        keccakP(this.state32, this.rounds);\n        swap32IfBE(this.state32);\n        this.posOut = 0;\n        this.pos = 0;\n    }\n    update(data) {\n        aexists(this);\n        data = toBytes(data);\n        abytes(data);\n        const { blockLen, state } = this;\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            for (let i = 0; i < take; i++)\n                state[this.pos++] ^= data[pos++];\n            if (this.pos === blockLen)\n                this.keccak();\n        }\n        return this;\n    }\n    finish() {\n        if (this.finished)\n            return;\n        this.finished = true;\n        const { state, suffix, pos, blockLen } = this;\n        // Do the padding\n        state[pos] ^= suffix;\n        if ((suffix & 0x80) !== 0 && pos === blockLen - 1)\n            this.keccak();\n        state[blockLen - 1] ^= 0x80;\n        this.keccak();\n    }\n    writeInto(out) {\n        aexists(this, false);\n        abytes(out);\n        this.finish();\n        const bufferOut = this.state;\n        const { blockLen } = this;\n        for (let pos = 0, len = out.length; pos < len;) {\n            if (this.posOut >= blockLen)\n                this.keccak();\n            const take = Math.min(blockLen - this.posOut, len - pos);\n            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);\n            this.posOut += take;\n            pos += take;\n        }\n        return out;\n    }\n    xofInto(out) {\n        // Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF\n        if (!this.enableXOF)\n            throw new Error('XOF is not possible for this instance');\n        return this.writeInto(out);\n    }\n    xof(bytes) {\n        anumber(bytes);\n        return this.xofInto(new Uint8Array(bytes));\n    }\n    digestInto(out) {\n        aoutput(out, this);\n        if (this.finished)\n            throw new Error('digest() was already called');\n        this.writeInto(out);\n        this.destroy();\n        return out;\n    }\n    digest() {\n        return this.digestInto(new Uint8Array(this.outputLen));\n    }\n    destroy() {\n        this.destroyed = true;\n        clean(this.state);\n    }\n    _cloneInto(to) {\n        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;\n        to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));\n        to.state32.set(this.state32);\n        to.pos = this.pos;\n        to.posOut = this.posOut;\n        to.finished = this.finished;\n        to.rounds = rounds;\n        // Suffix can change in cSHAKE\n        to.suffix = suffix;\n        to.outputLen = outputLen;\n        to.enableXOF = enableXOF;\n        to.destroyed = this.destroyed;\n        return to;\n    }\n}\nconst gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));\n/** SHA3-224 hash function. */\nexport const sha3_224 = /* @__PURE__ */ (() => gen(0x06, 144, 224 / 8))();\n/** SHA3-256 hash function. Different from keccak-256. */\nexport const sha3_256 = /* @__PURE__ */ (() => gen(0x06, 136, 256 / 8))();\n/** SHA3-384 hash function. */\nexport const sha3_384 = /* @__PURE__ */ (() => gen(0x06, 104, 384 / 8))();\n/** SHA3-512 hash function. */\nexport const sha3_512 = /* @__PURE__ */ (() => gen(0x06, 72, 512 / 8))();\n/** keccak-224 hash function. */\nexport const keccak_224 = /* @__PURE__ */ (() => gen(0x01, 144, 224 / 8))();\n/** keccak-256 hash function. Different from SHA3-256. */\nexport const keccak_256 = /* @__PURE__ */ (() => gen(0x01, 136, 256 / 8))();\n/** keccak-384 hash function. */\nexport const keccak_384 = /* @__PURE__ */ (() => gen(0x01, 104, 384 / 8))();\n/** keccak-512 hash function. */\nexport const keccak_512 = /* @__PURE__ */ (() => gen(0x01, 72, 512 / 8))();\nconst genShake = (suffix, blockLen, outputLen) => createXOFer((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true));\n/** SHAKE128 XOF with 128-bit security. */\nexport const shake128 = /* @__PURE__ */ (() => genShake(0x1f, 168, 128 / 8))();\n/** SHAKE256 XOF with 256-bit security. */\nexport const shake256 = /* @__PURE__ */ (() => genShake(0x1f, 136, 256 / 8))();\n//# sourceMappingURL=sha3.js.map"],"names":["_0n","BigInt","_1n","_2n","_7n","_256n","_0x71n","SHA3_PI","SHA3_ROTL","_SHA3_IOTA","round","R","x","y","push","t","j","IOTAS","split","SHA3_IOTA_H","SHA3_IOTA_L","rotlH","h","l","s","rotlBH","rotlSH","rotlL","rotlBL","rotlSL","keccakP","rounds","B","Uint32Array","idx1","idx0","B0","B1","Th","Tl","curH","curL","shift","PI","clean","Keccak","Hash","constructor","blockLen","suffix","outputLen","enableXOF","super","this","pos","posOut","finished","destroyed","anumber","Error","state","Uint8Array","state32","u32","clone","_cloneInto","keccak","swap32IfBE","update","data","aexists","toBytes","abytes","len","length","take","Math","min","i","finish","writeInto","out","bufferOut","set","subarray","xofInto","xof","bytes","digestInto","aoutput","destroy","digest","to","keccak_256","gen","createHasher"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/@noble_hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.8.0/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","anumber","n","Number","isSafeInteger","Error","abytes","b","lengths","length","includes","ahash","h","create","outputLen","blockLen","aexists","instance","checkFinished","destroyed","finished","aoutput","out","min","u32","arr","Uint32Array","buffer","byteOffset","Math","floor","byteLength","clean","arrays","i","fill","createView","DataView","rotr","word","shift","isLE","byteSwap","byteSwap32","swap32IfBE","u","utf8ToBytes","str","TextEncoder","encode","toBytes","data","concatBytes","sum","res","pad","set","Hash","createHasher","hashCons","hashC","msg","update","digest","tmp","randomBytes","bytesLength","crypto","getRandomValues","from"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/@rollup_plugin-typescript@11.1.6_rollup@4.52.2_tslib@2.8.1_typescript@5.9.2/node_modules/tslib/tslib.es6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tslib.es6.js","sources":["../../../../../../../node_modules/.pnpm/@rollup+plugin-typescript@11.1.6_rollup@4.52.2_tslib@2.8.1_typescript@5.9.2/node_modules/tslib/tslib.es6.js"],"sourcesContent":["/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.unshift(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.unshift(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\r\n    return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\r\n    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nvar ownKeys = function(o) {\r\n    ownKeys = Object.getOwnPropertyNames || function (o) {\r\n        var ar = [];\r\n        for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\r\n        return ar;\r\n    };\r\n    return ownKeys(o);\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport function __addDisposableResource(env, value, async) {\r\n    if (value !== null && value !== void 0) {\r\n        if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\r\n        var dispose, inner;\r\n        if (async) {\r\n            if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\r\n            dispose = value[Symbol.asyncDispose];\r\n        }\r\n        if (dispose === void 0) {\r\n            if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\r\n            dispose = value[Symbol.dispose];\r\n            if (async) inner = dispose;\r\n        }\r\n        if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\r\n        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\r\n        env.stack.push({ value: value, dispose: dispose, async: async });\r\n    }\r\n    else if (async) {\r\n        env.stack.push({ async: true });\r\n    }\r\n    return value;\r\n\r\n}\r\n\r\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\r\n\r\nexport function __disposeResources(env) {\r\n    function fail(e) {\r\n        env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\r\n        env.hasError = true;\r\n    }\r\n    var r, s = 0;\r\n    function next() {\r\n        while (r = env.stack.pop()) {\r\n            try {\r\n                if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\r\n                if (r.dispose) {\r\n                    var result = r.dispose.call(r.value);\r\n                    if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\r\n                }\r\n                else s |= 1;\r\n            }\r\n            catch (e) {\r\n                fail(e);\r\n            }\r\n        }\r\n        if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\r\n        if (env.hasError) throw env.error;\r\n    }\r\n    return next();\r\n}\r\n\r\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\r\n    if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\r\n        return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\r\n            return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\r\n        });\r\n    }\r\n    return path;\r\n}\r\n\r\nexport default {\r\n    __extends: __extends,\r\n    __assign: __assign,\r\n    __rest: __rest,\r\n    __decorate: __decorate,\r\n    __param: __param,\r\n    __esDecorate: __esDecorate,\r\n    __runInitializers: __runInitializers,\r\n    __propKey: __propKey,\r\n    __setFunctionName: __setFunctionName,\r\n    __metadata: __metadata,\r\n    __awaiter: __awaiter,\r\n    __generator: __generator,\r\n    __createBinding: __createBinding,\r\n    __exportStar: __exportStar,\r\n    __values: __values,\r\n    __read: __read,\r\n    __spread: __spread,\r\n    __spreadArrays: __spreadArrays,\r\n    __spreadArray: __spreadArray,\r\n    __await: __await,\r\n    __asyncGenerator: __asyncGenerator,\r\n    __asyncDelegator: __asyncDelegator,\r\n    __asyncValues: __asyncValues,\r\n    __makeTemplateObject: __makeTemplateObject,\r\n    __importStar: __importStar,\r\n    __importDefault: __importDefault,\r\n    __classPrivateFieldGet: __classPrivateFieldGet,\r\n    __classPrivateFieldSet: __classPrivateFieldSet,\r\n    __classPrivateFieldIn: __classPrivateFieldIn,\r\n    __addDisposableResource: __addDisposableResource,\r\n    __disposeResources: __disposeResources,\r\n    __rewriteRelativeImportExtension: __rewriteRelativeImportExtension,\r\n};\r\n"],"names":["__assign","Object","assign","t","s","i","n","arguments","length","p","prototype","hasOwnProperty","call","apply","this","__spreadArray","to","from","pack","ar","l","Array","slice","concat","SuppressedError"],"mappings":"AA+BU,IAACA,EAAW,WAQlB,OAPAA,EAAWC,OAAOC,QAAU,SAAkBC,GAC1C,IAAK,IAAIC,EAAGC,EAAI,EAAGC,EAAIC,UAAUC,OAAQH,EAAIC,EAAGD,IAE5C,IAAK,IAAII,KADTL,EAAIG,UAAUF,GACOJ,OAAOS,UAAUC,eAAeC,KAAKR,EAAGK,KAAIN,EAAEM,GAAKL,EAAEK,IAE9E,OAAON,CACX,EACOH,EAASa,MAAMC,KAAMP,UAChC,EA6KO,SAASQ,EAAcC,EAAIC,EAAMC,GACpC,GAAIA,GAA6B,IAArBX,UAAUC,OAAc,IAAK,IAA4BW,EAAxBd,EAAI,EAAGe,EAAIH,EAAKT,OAAYH,EAAIe,EAAGf,KACxEc,GAAQd,KAAKY,IACRE,IAAIA,EAAKE,MAAMX,UAAUY,MAAMV,KAAKK,EAAM,EAAGZ,IAClDc,EAAGd,GAAKY,EAAKZ,IAGrB,OAAOW,EAAGO,OAAOJ,GAAME,MAAMX,UAAUY,MAAMV,KAAKK,GACtD,CA2GkD,mBAApBO,iBAAiCA","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/@solana_wallet-adapter-base@0.9.27_@solana_web3.js@1.98.4_bufferutil@4.0.9_typescript@5.9.2_utf-8-validate@5.0.10_/node_modules/@solana/wallet-adapter-base/lib/esm/adapter.js

@@ -0,0 +1,2 @@
+import e from"../../../../../../eventemitter3@5.0.1/node_modules/eventemitter3/index.js";import{WalletNotConnectedError as t}from"./errors.js";var n;!function(e){e.Installed="Installed",e.NotDetected="NotDetected",e.Loadable="Loadable",e.Unsupported="Unsupported"}(n||(n={}));class o extends e{get connected(){return!!this.publicKey}async autoConnect(){await this.connect()}async prepareTransaction(e,n,o={}){const r=this.publicKey;if(!r)throw new t;return e.feePayer=e.feePayer||r,e.recentBlockhash=e.recentBlockhash||(await n.getLatestBlockhash({commitment:o.preflightCommitment,minContextSlot:o.minContextSlot})).blockhash,e}}function r(e){if("undefined"==typeof window||"undefined"==typeof document)return;const t=[];function n(){if(e())for(const e of t)e()}const o=setInterval(n,1e3);t.push(()=>clearInterval(o)),"loading"===document.readyState&&(document.addEventListener("DOMContentLoaded",n,{once:!0}),t.push(()=>document.removeEventListener("DOMContentLoaded",n))),"complete"!==document.readyState&&(window.addEventListener("load",n,{once:!0}),t.push(()=>window.removeEventListener("load",n))),n()}function a(){if(!navigator)return!1;const e=navigator.userAgent.toLowerCase(),t=e.includes("iphone")||e.includes("ipad"),n=e.includes("safari");return t&&n}export{o as BaseWalletAdapter,e as EventEmitter,n as WalletReadyState,a as isIosAndRedirectable,r as scopePollingDetectionStrategy};
+//# sourceMappingURL=adapter.js.map

package/dist/esm/node_modules/.pnpm/@solana_wallet-adapter-base@0.9.27_@solana_web3.js@1.98.4_bufferutil@4.0.9_typescript@5.9.2_utf-8-validate@5.0.10_/node_modules/@solana/wallet-adapter-base/lib/esm/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sources":["../../../../../../../../../../node_modules/.pnpm/@solana+wallet-adapter-base@0.9.27_@solana+web3.js@1.98.4_bufferutil@4.0.9_typescript@5.9.2_utf-8-validate@5.0.10_/node_modules/@solana/wallet-adapter-base/lib/esm/adapter.js"],"sourcesContent":["import EventEmitter from 'eventemitter3';\nimport { WalletNotConnectedError } from './errors.js';\nexport { EventEmitter };\n/**\n * A wallet's readiness describes a series of states that the wallet can be in,\n * depending on what kind of wallet it is. An installable wallet (eg. a browser\n * extension like Phantom) might be `Installed` if we've found the Phantom API\n * in the global scope, or `NotDetected` otherwise. A loadable, zero-install\n * runtime (eg. Torus Wallet) might simply signal that it's `Loadable`. Use this\n * metadata to personalize the wallet list for each user (eg. to show their\n * installed wallets first).\n */\nexport var WalletReadyState;\n(function (WalletReadyState) {\n    /**\n     * User-installable wallets can typically be detected by scanning for an API\n     * that they've injected into the global context. If such an API is present,\n     * we consider the wallet to have been installed.\n     */\n    WalletReadyState[\"Installed\"] = \"Installed\";\n    WalletReadyState[\"NotDetected\"] = \"NotDetected\";\n    /**\n     * Loadable wallets are always available to you. Since you can load them at\n     * any time, it's meaningless to say that they have been detected.\n     */\n    WalletReadyState[\"Loadable\"] = \"Loadable\";\n    /**\n     * If a wallet is not supported on a given platform (eg. server-rendering, or\n     * mobile) then it will stay in the `Unsupported` state.\n     */\n    WalletReadyState[\"Unsupported\"] = \"Unsupported\";\n})(WalletReadyState || (WalletReadyState = {}));\nexport class BaseWalletAdapter extends EventEmitter {\n    get connected() {\n        return !!this.publicKey;\n    }\n    async autoConnect() {\n        await this.connect();\n    }\n    async prepareTransaction(transaction, connection, options = {}) {\n        const publicKey = this.publicKey;\n        if (!publicKey)\n            throw new WalletNotConnectedError();\n        transaction.feePayer = transaction.feePayer || publicKey;\n        transaction.recentBlockhash =\n            transaction.recentBlockhash ||\n                (await connection.getLatestBlockhash({\n                    commitment: options.preflightCommitment,\n                    minContextSlot: options.minContextSlot,\n                })).blockhash;\n        return transaction;\n    }\n}\nexport function scopePollingDetectionStrategy(detect) {\n    // Early return when server-side rendering\n    if (typeof window === 'undefined' || typeof document === 'undefined')\n        return;\n    const disposers = [];\n    function detectAndDispose() {\n        const detected = detect();\n        if (detected) {\n            for (const dispose of disposers) {\n                dispose();\n            }\n        }\n    }\n    // Strategy #1: Try detecting every second.\n    const interval = \n    // TODO: #334 Replace with idle callback strategy.\n    setInterval(detectAndDispose, 1000);\n    disposers.push(() => clearInterval(interval));\n    // Strategy #2: Detect as soon as the DOM becomes 'ready'/'interactive'.\n    if (\n    // Implies that `DOMContentLoaded` has not yet fired.\n    document.readyState === 'loading') {\n        document.addEventListener('DOMContentLoaded', detectAndDispose, { once: true });\n        disposers.push(() => document.removeEventListener('DOMContentLoaded', detectAndDispose));\n    }\n    // Strategy #3: Detect after the `window` has fully loaded.\n    if (\n    // If the `complete` state has been reached, we're too late.\n    document.readyState !== 'complete') {\n        window.addEventListener('load', detectAndDispose, { once: true });\n        disposers.push(() => window.removeEventListener('load', detectAndDispose));\n    }\n    // Strategy #4: Detect synchronously, now.\n    detectAndDispose();\n}\n/**\n * Users on iOS can be redirected into a wallet's in-app browser automatically,\n * if that wallet has a universal link configured to do so\n * But should not be redirected from within a webview, eg. if they're already\n * inside a wallet's browser\n * This function can be used to identify users who are on iOS and can be redirected\n *\n * @returns true if the user can be redirected\n */\nexport function isIosAndRedirectable() {\n    // SSR: return false\n    if (!navigator)\n        return false;\n    const userAgent = navigator.userAgent.toLowerCase();\n    // if on iOS the user agent will contain either iPhone or iPad\n    // caveat: if requesting desktop site then this won't work\n    const isIos = userAgent.includes('iphone') || userAgent.includes('ipad');\n    // if in a webview then it will not include Safari\n    // note that other iOS browsers also include Safari\n    // so we will redirect only if Safari is also included\n    const isSafari = userAgent.includes('safari');\n    return isIos && isSafari;\n}\n//# sourceMappingURL=adapter.js.map"],"names":["WalletReadyState","BaseWalletAdapter","EventEmitter","connected","this","publicKey","autoConnect","connect","prepareTransaction","transaction","connection","options","WalletNotConnectedError","feePayer","recentBlockhash","getLatestBlockhash","commitment","preflightCommitment","minContextSlot","blockhash","scopePollingDetectionStrategy","detect","window","document","disposers","detectAndDispose","dispose","interval","setInterval","push","clearInterval","readyState","addEventListener","once","removeEventListener","isIosAndRedirectable","navigator","userAgent","toLowerCase","isIos","includes","isSafari"],"mappings":"+IAYU,IAACA,GACX,SAAWA,GAMPA,EAA4B,UAAI,YAChCA,EAA8B,YAAI,cAKlCA,EAA2B,SAAI,WAK/BA,EAA8B,YAAI,aACrC,CAlBD,CAkBGA,IAAqBA,EAAmB,CAAA,IACpC,MAAMC,UAA0BC,EACnC,aAAIC,GACA,QAASC,KAAKC,SAClB,CACA,iBAAMC,SACIF,KAAKG,SACf,CACA,wBAAMC,CAAmBC,EAAaC,EAAYC,EAAU,CAAA,GACxD,MAAMN,EAAYD,KAAKC,UACvB,IAAKA,EACD,MAAM,IAAIO,EAQd,OAPAH,EAAYI,SAAWJ,EAAYI,UAAYR,EAC/CI,EAAYK,gBACRL,EAAYK,wBACDJ,EAAWK,mBAAmB,CACjCC,WAAYL,EAAQM,oBACpBC,eAAgBP,EAAQO,kBACxBC,UACLV,CACX,EAEG,SAASW,EAA8BC,GAE1C,GAAsB,oBAAXC,QAA8C,oBAAbC,SACxC,OACJ,MAAMC,EAAY,GAClB,SAASC,IAEL,GADiBJ,IAEb,IAAK,MAAMK,KAAWF,EAClBE,GAGZ,CAEA,MAAMC,EAENC,YAAYH,EAAkB,KAC9BD,EAAUK,KAAK,IAAMC,cAAcH,IAIX,YAAxBJ,SAASQ,aACLR,SAASS,iBAAiB,mBAAoBP,EAAkB,CAAEQ,MAAM,IACxET,EAAUK,KAAK,IAAMN,SAASW,oBAAoB,mBAAoBT,KAKlD,aAAxBF,SAASQ,aACLT,OAAOU,iBAAiB,OAAQP,EAAkB,CAAEQ,MAAM,IAC1DT,EAAUK,KAAK,IAAMP,OAAOY,oBAAoB,OAAQT,KAG5DA,GACJ,CAUO,SAASU,IAEZ,IAAKC,UACD,OAAO,EACX,MAAMC,EAAYD,UAAUC,UAAUC,cAGhCC,EAAQF,EAAUG,SAAS,WAAaH,EAAUG,SAAS,QAI3DC,EAAWJ,EAAUG,SAAS,UACpC,OAAOD,GAASE,CACpB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/@solana_wallet-adapter-base@0.9.27_@solana_web3.js@1.98.4_bufferutil@4.0.9_typescript@5.9.2_utf-8-validate@5.0.10_/node_modules/@solana/wallet-adapter-base/lib/esm/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sources":["../../../../../../../../../../node_modules/.pnpm/@solana+wallet-adapter-base@0.9.27_@solana+web3.js@1.98.4_bufferutil@4.0.9_typescript@5.9.2_utf-8-validate@5.0.10_/node_modules/@solana/wallet-adapter-base/lib/esm/errors.js"],"sourcesContent":["export class WalletError extends Error {\n    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\n    constructor(message, error) {\n        super(message);\n        this.error = error;\n    }\n}\nexport class WalletNotReadyError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletNotReadyError';\n    }\n}\nexport class WalletLoadError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletLoadError';\n    }\n}\nexport class WalletConfigError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletConfigError';\n    }\n}\nexport class WalletConnectionError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletConnectionError';\n    }\n}\nexport class WalletDisconnectedError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletDisconnectedError';\n    }\n}\nexport class WalletDisconnectionError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletDisconnectionError';\n    }\n}\nexport class WalletAccountError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletAccountError';\n    }\n}\nexport class WalletPublicKeyError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletPublicKeyError';\n    }\n}\nexport class WalletKeypairError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletKeypairError';\n    }\n}\nexport class WalletNotConnectedError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletNotConnectedError';\n    }\n}\nexport class WalletSendTransactionError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletSendTransactionError';\n    }\n}\nexport class WalletSignTransactionError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletSignTransactionError';\n    }\n}\nexport class WalletSignMessageError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletSignMessageError';\n    }\n}\nexport class WalletSignInError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletSignInError';\n    }\n}\nexport class WalletTimeoutError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletTimeoutError';\n    }\n}\nexport class WalletWindowBlockedError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletWindowBlockedError';\n    }\n}\nexport class WalletWindowClosedError extends WalletError {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalletWindowClosedError';\n    }\n}\n//# sourceMappingURL=errors.js.map"],"names":["WalletError","Error","constructor","message","error","super","this","WalletNotReadyError","arguments","name","WalletConnectionError","WalletDisconnectedError","WalletDisconnectionError","WalletAccountError","WalletPublicKeyError","WalletNotConnectedError","WalletSendTransactionError","WalletSignTransactionError","WalletSignMessageError"],"mappings":"AAAO,MAAMA,UAAoBC,MAE7B,WAAAC,CAAYC,EAASC,GACjBC,MAAMF,GACNG,KAAKF,MAAQA,CACjB,EAEG,MAAMG,UAA4BP,EACrC,WAAAE,GACIG,SAASG,WACTF,KAAKG,KAAO,qBAChB,EAcG,MAAMC,UAA8BV,EACvC,WAAAE,GACIG,SAASG,WACTF,KAAKG,KAAO,uBAChB,EAEG,MAAME,UAAgCX,EACzC,WAAAE,GACIG,SAASG,WACTF,KAAKG,KAAO,yBAChB,EAEG,MAAMG,UAAiCZ,EAC1C,WAAAE,GACIG,SAASG,WACTF,KAAKG,KAAO,0BAChB,EAEG,MAAMI,UAA2Bb,EACpC,WAAAE,GACIG,SAASG,WACTF,KAAKG,KAAO,oBAChB,EAEG,MAAMK,UAA6Bd,EACtC,WAAAE,GACIG,SAASG,WACTF,KAAKG,KAAO,sBAChB,EAQG,MAAMM,UAAgCf,EACzC,WAAAE,GACIG,SAASG,WACTF,KAAKG,KAAO,yBAChB,EAEG,MAAMO,UAAmChB,EAC5C,WAAAE,GACIG,SAASG,WACTF,KAAKG,KAAO,4BAChB,EAEG,MAAMQ,UAAmCjB,EAC5C,WAAAE,GACIG,SAASG,WACTF,KAAKG,KAAO,4BAChB,EAEG,MAAMS,UAA+BlB,EACxC,WAAAE,GACIG,SAASG,WACTF,KAAKG,KAAO,wBAChB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/@solana_wallet-adapter-base@0.9.27_@solana_web3.js@1.98.4_bufferutil@4.0.9_typescript@5.9.2_utf-8-validate@5.0.10_/node_modules/@solana/wallet-adapter-base/lib/esm/signer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer.js","sources":["../../../../../../../../../../node_modules/.pnpm/@solana+wallet-adapter-base@0.9.27_@solana+web3.js@1.98.4_bufferutil@4.0.9_typescript@5.9.2_utf-8-validate@5.0.10_/node_modules/@solana/wallet-adapter-base/lib/esm/signer.js"],"sourcesContent":["import { BaseWalletAdapter, } from './adapter.js';\nimport { WalletSendTransactionError, WalletSignTransactionError } from './errors.js';\nimport { isVersionedTransaction } from './transaction.js';\nexport class BaseSignerWalletAdapter extends BaseWalletAdapter {\n    async sendTransaction(transaction, connection, options = {}) {\n        let emit = true;\n        try {\n            if (isVersionedTransaction(transaction)) {\n                if (!this.supportedTransactionVersions)\n                    throw new WalletSendTransactionError(`Sending versioned transactions isn't supported by this wallet`);\n                if (!this.supportedTransactionVersions.has(transaction.version))\n                    throw new WalletSendTransactionError(`Sending transaction version ${transaction.version} isn't supported by this wallet`);\n                try {\n                    transaction = await this.signTransaction(transaction);\n                    const rawTransaction = transaction.serialize();\n                    return await connection.sendRawTransaction(rawTransaction, options);\n                }\n                catch (error) {\n                    // If the error was thrown by `signTransaction`, rethrow it and don't emit a duplicate event\n                    if (error instanceof WalletSignTransactionError) {\n                        emit = false;\n                        throw error;\n                    }\n                    throw new WalletSendTransactionError(error?.message, error);\n                }\n            }\n            else {\n                try {\n                    const { signers, ...sendOptions } = options;\n                    transaction = await this.prepareTransaction(transaction, connection, sendOptions);\n                    signers?.length && transaction.partialSign(...signers);\n                    transaction = await this.signTransaction(transaction);\n                    const rawTransaction = transaction.serialize();\n                    return await connection.sendRawTransaction(rawTransaction, sendOptions);\n                }\n                catch (error) {\n                    // If the error was thrown by `signTransaction`, rethrow it and don't emit a duplicate event\n                    if (error instanceof WalletSignTransactionError) {\n                        emit = false;\n                        throw error;\n                    }\n                    throw new WalletSendTransactionError(error?.message, error);\n                }\n            }\n        }\n        catch (error) {\n            if (emit) {\n                this.emit('error', error);\n            }\n            throw error;\n        }\n    }\n    async signAllTransactions(transactions) {\n        for (const transaction of transactions) {\n            if (isVersionedTransaction(transaction)) {\n                if (!this.supportedTransactionVersions)\n                    throw new WalletSignTransactionError(`Signing versioned transactions isn't supported by this wallet`);\n                if (!this.supportedTransactionVersions.has(transaction.version))\n                    throw new WalletSignTransactionError(`Signing transaction version ${transaction.version} isn't supported by this wallet`);\n            }\n        }\n        const signedTransactions = [];\n        for (const transaction of transactions) {\n            signedTransactions.push(await this.signTransaction(transaction));\n        }\n        return signedTransactions;\n    }\n}\nexport class BaseMessageSignerWalletAdapter extends BaseSignerWalletAdapter {\n}\nexport class BaseSignInMessageSignerWalletAdapter extends BaseMessageSignerWalletAdapter {\n}\n//# sourceMappingURL=signer.js.map"],"names":["BaseSignerWalletAdapter","BaseWalletAdapter","sendTransaction","transaction","connection","options","emit","isVersionedTransaction","this","supportedTransactionVersions","WalletSendTransactionError","has","version","rawTransaction","signTransaction","serialize","sendRawTransaction","error","WalletSignTransactionError","message","signers","sendOptions","prepareTransaction","length","partialSign","signAllTransactions","transactions","signedTransactions","push","BaseMessageSignerWalletAdapter"],"mappings":"oMAGO,MAAMA,UAAgCC,EACzC,qBAAMC,CAAgBC,EAAaC,EAAYC,EAAU,CAAA,GACrD,IAAIC,GAAO,EACX,IACI,GAAIC,EAAuBJ,GAAc,CACrC,IAAKK,KAAKC,6BACN,MAAM,IAAIC,EAA2B,iEACzC,IAAKF,KAAKC,6BAA6BE,IAAIR,EAAYS,SACnD,MAAM,IAAIF,EAA2B,+BAA+BP,EAAYS,0CACpF,IAEI,MAAMC,GADNV,QAAoBK,KAAKM,gBAAgBX,IACNY,YACnC,aAAaX,EAAWY,mBAAmBH,EAAgBR,EAC/D,CACA,MAAOY,GAEH,GAAIA,aAAiBC,EAEjB,MADAZ,GAAO,EACDW,EAEV,MAAM,IAAIP,EAA2BO,GAAOE,QAASF,EACzD,CACJ,MAEI,IACI,MAAMG,QAAEA,KAAYC,GAAgBhB,EACpCF,QAAoBK,KAAKc,mBAAmBnB,EAAaC,EAAYiB,GACrED,GAASG,QAAUpB,EAAYqB,eAAeJ,GAE9C,MAAMP,GADNV,QAAoBK,KAAKM,gBAAgBX,IACNY,YACnC,aAAaX,EAAWY,mBAAmBH,EAAgBQ,EAC/D,CACA,MAAOJ,GAEH,GAAIA,aAAiBC,EAEjB,MADAZ,GAAO,EACDW,EAEV,MAAM,IAAIP,EAA2BO,GAAOE,QAASF,EACzD,CAER,CACA,MAAOA,GAIH,MAHIX,GACAE,KAAKF,KAAK,QAASW,GAEjBA,CACV,CACJ,CACA,yBAAMQ,CAAoBC,GACtB,IAAK,MAAMvB,KAAeuB,EACtB,GAAInB,EAAuBJ,GAAc,CACrC,IAAKK,KAAKC,6BACN,MAAM,IAAIS,EAA2B,iEACzC,IAAKV,KAAKC,6BAA6BE,IAAIR,EAAYS,SACnD,MAAM,IAAIM,EAA2B,+BAA+Bf,EAAYS,yCACxF,CAEJ,MAAMe,EAAqB,GAC3B,IAAK,MAAMxB,KAAeuB,EACtBC,EAAmBC,WAAWpB,KAAKM,gBAAgBX,IAEvD,OAAOwB,CACX,EAEG,MAAME,UAAuC7B","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/@solana_wallet-adapter-base@0.9.27_@solana_web3.js@1.98.4_bufferutil@4.0.9_typescript@5.9.2_utf-8-validate@5.0.10_/node_modules/@solana/wallet-adapter-base/lib/esm/transaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.js","sources":["../../../../../../../../../../node_modules/.pnpm/@solana+wallet-adapter-base@0.9.27_@solana+web3.js@1.98.4_bufferutil@4.0.9_typescript@5.9.2_utf-8-validate@5.0.10_/node_modules/@solana/wallet-adapter-base/lib/esm/transaction.js"],"sourcesContent":["export function isVersionedTransaction(transaction) {\n    return 'version' in transaction;\n}\n//# sourceMappingURL=transaction.js.map"],"names":["isVersionedTransaction","transaction"],"mappings":"AAAO,SAASA,EAAuBC,GACnC,MAAO,YAAaA,CACxB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sources":["../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/errors.js"],"sourcesContent":["import { version } from './version.js';\nexport class BaseError extends Error {\n    constructor(shortMessage, args = {}) {\n        const details = args.cause instanceof BaseError\n            ? args.cause.details\n            : args.cause?.message\n                ? args.cause.message\n                : args.details;\n        const docsPath = args.cause instanceof BaseError\n            ? args.cause.docsPath || args.docsPath\n            : args.docsPath;\n        const message = [\n            shortMessage || 'An error occurred.',\n            '',\n            ...(args.metaMessages ? [...args.metaMessages, ''] : []),\n            ...(docsPath ? [`Docs: https://abitype.dev${docsPath}`] : []),\n            ...(details ? [`Details: ${details}`] : []),\n            `Version: abitype@${version}`,\n        ].join('\\n');\n        super(message);\n        Object.defineProperty(this, \"details\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        Object.defineProperty(this, \"docsPath\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        Object.defineProperty(this, \"metaMessages\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        Object.defineProperty(this, \"shortMessage\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiTypeError'\n        });\n        if (args.cause)\n            this.cause = args.cause;\n        this.details = details;\n        this.docsPath = docsPath;\n        this.metaMessages = args.metaMessages;\n        this.shortMessage = shortMessage;\n    }\n}\n//# sourceMappingURL=errors.js.map"],"names":["BaseError","Error","constructor","shortMessage","args","details","cause","message","docsPath","super","metaMessages","version","join","Object","defineProperty","this","enumerable","configurable","writable","value"],"mappings":"uCACO,MAAMA,UAAkBC,MAC3B,WAAAC,CAAYC,EAAcC,EAAO,IAC7B,MAAMC,EAAUD,EAAKE,iBAAiBN,EAChCI,EAAKE,MAAMD,QACXD,EAAKE,OAAOC,QACRH,EAAKE,MAAMC,QACXH,EAAKC,QACTG,EAAWJ,EAAKE,iBAAiBN,GACjCI,EAAKE,MAAME,UACXJ,EAAKI,SASXC,MARgB,CACZN,GAAgB,qBAChB,MACIC,EAAKM,aAAe,IAAIN,EAAKM,aAAc,IAAM,MACjDF,EAAW,CAAC,4BAA4BA,KAAc,MACtDH,EAAU,CAAC,YAAYA,KAAa,GACxC,oBAAoBM,KACtBC,KAAK,OAEPC,OAAOC,eAAeC,KAAM,UAAW,CACnCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,WAAO,IAEXN,OAAOC,eAAeC,KAAM,WAAY,CACpCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,WAAO,IAEXN,OAAOC,eAAeC,KAAM,eAAgB,CACxCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,WAAO,IAEXN,OAAOC,eAAeC,KAAM,eAAgB,CACxCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,WAAO,IAEXN,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,MAAO,iBAEPf,EAAKE,QACLS,KAAKT,MAAQF,EAAKE,OACtBS,KAAKV,QAAUA,EACfU,KAAKP,SAAWA,EAChBO,KAAKL,aAAeN,EAAKM,aACzBK,KAAKZ,aAAeA,CACxB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abiItem.js","sources":["../../../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js"],"sourcesContent":["import { BaseError } from '../../errors.js';\nexport class InvalidAbiItemError extends BaseError {\n    constructor({ signature }) {\n        super('Failed to parse ABI item.', {\n            details: `parseAbiItem(${JSON.stringify(signature, null, 2)})`,\n            docsPath: '/api/human#parseabiitem-1',\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'InvalidAbiItemError'\n        });\n    }\n}\nexport class UnknownTypeError extends BaseError {\n    constructor({ type }) {\n        super('Unknown type.', {\n            metaMessages: [\n                `Type \"${type}\" is not a valid ABI type. Perhaps you forgot to include a struct signature?`,\n            ],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'UnknownTypeError'\n        });\n    }\n}\nexport class UnknownSolidityTypeError extends BaseError {\n    constructor({ type }) {\n        super('Unknown type.', {\n            metaMessages: [`Type \"${type}\" is not a valid ABI type.`],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'UnknownSolidityTypeError'\n        });\n    }\n}\n//# sourceMappingURL=abiItem.js.map"],"names":["InvalidAbiItemError","BaseError","constructor","signature","super","details","JSON","stringify","docsPath","Object","defineProperty","this","enumerable","configurable","writable","value","UnknownTypeError","type","metaMessages","UnknownSolidityTypeError"],"mappings":"4CACO,MAAMA,UAA4BC,EACrC,WAAAC,EAAYC,UAAEA,IACVC,MAAM,4BAA6B,CAC/BC,QAAS,gBAAgBC,KAAKC,UAAUJ,EAAW,KAAM,MACzDK,SAAU,8BAEdC,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,MAAO,uBAEf,EAEG,MAAMC,UAAyBf,EAClC,WAAAC,EAAYe,KAAEA,IACVb,MAAM,gBAAiB,CACnBc,aAAc,CACV,SAASD,mFAGjBR,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,MAAO,oBAEf,EAEG,MAAMI,UAAiClB,EAC1C,WAAAC,EAAYe,KAAEA,IACVb,MAAM,gBAAiB,CACnBc,aAAc,CAAC,SAASD,iCAE5BR,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,MAAO,4BAEf","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abiParameter.js","sources":["../../../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js"],"sourcesContent":["import { BaseError } from '../../errors.js';\nexport class InvalidAbiParameterError extends BaseError {\n    constructor({ param }) {\n        super('Failed to parse ABI parameter.', {\n            details: `parseAbiParameter(${JSON.stringify(param, null, 2)})`,\n            docsPath: '/api/human#parseabiparameter-1',\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'InvalidAbiParameterError'\n        });\n    }\n}\nexport class InvalidAbiParametersError extends BaseError {\n    constructor({ params }) {\n        super('Failed to parse ABI parameters.', {\n            details: `parseAbiParameters(${JSON.stringify(params, null, 2)})`,\n            docsPath: '/api/human#parseabiparameters-1',\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'InvalidAbiParametersError'\n        });\n    }\n}\nexport class InvalidParameterError extends BaseError {\n    constructor({ param }) {\n        super('Invalid ABI parameter.', {\n            details: param,\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'InvalidParameterError'\n        });\n    }\n}\nexport class SolidityProtectedKeywordError extends BaseError {\n    constructor({ param, name }) {\n        super('Invalid ABI parameter.', {\n            details: param,\n            metaMessages: [\n                `\"${name}\" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`,\n            ],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'SolidityProtectedKeywordError'\n        });\n    }\n}\nexport class InvalidModifierError extends BaseError {\n    constructor({ param, type, modifier, }) {\n        super('Invalid ABI parameter.', {\n            details: param,\n            metaMessages: [\n                `Modifier \"${modifier}\" not allowed${type ? ` in \"${type}\" type` : ''}.`,\n            ],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'InvalidModifierError'\n        });\n    }\n}\nexport class InvalidFunctionModifierError extends BaseError {\n    constructor({ param, type, modifier, }) {\n        super('Invalid ABI parameter.', {\n            details: param,\n            metaMessages: [\n                `Modifier \"${modifier}\" not allowed${type ? ` in \"${type}\" type` : ''}.`,\n                `Data location can only be specified for array, struct, or mapping types, but \"${modifier}\" was given.`,\n            ],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'InvalidFunctionModifierError'\n        });\n    }\n}\nexport class InvalidAbiTypeParameterError extends BaseError {\n    constructor({ abiParameter, }) {\n        super('Invalid ABI parameter.', {\n            details: JSON.stringify(abiParameter, null, 2),\n            metaMessages: ['ABI parameter type is invalid.'],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'InvalidAbiTypeParameterError'\n        });\n    }\n}\n//# sourceMappingURL=abiParameter.js.map"],"names":["InvalidAbiParametersError","BaseError","constructor","params","super","details","JSON","stringify","docsPath","Object","defineProperty","this","enumerable","configurable","writable","value","InvalidParameterError","param","SolidityProtectedKeywordError","name","metaMessages","InvalidModifierError","type","modifier","InvalidFunctionModifierError","InvalidAbiTypeParameterError","abiParameter"],"mappings":"4CAeO,MAAMA,UAAkCC,EAC3C,WAAAC,EAAYC,OAAEA,IACVC,MAAM,kCAAmC,CACrCC,QAAS,sBAAsBC,KAAKC,UAAUJ,EAAQ,KAAM,MAC5DK,SAAU,oCAEdC,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,MAAO,6BAEf,EAEG,MAAMC,UAA8Bf,EACvC,WAAAC,EAAYe,MAAEA,IACVb,MAAM,yBAA0B,CAC5BC,QAASY,IAEbR,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,MAAO,yBAEf,EAEG,MAAMG,UAAsCjB,EAC/C,WAAAC,EAAYe,MAAEA,EAAKE,KAAEA,IACjBf,MAAM,yBAA0B,CAC5BC,QAASY,EACTG,aAAc,CACV,IAAID,4GAGZV,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,MAAO,iCAEf,EAEG,MAAMM,UAA6BpB,EACtC,WAAAC,EAAYe,MAAEA,EAAKK,KAAEA,EAAIC,SAAEA,IACvBnB,MAAM,yBAA0B,CAC5BC,QAASY,EACTG,aAAc,CACV,aAAaG,iBAAwBD,EAAO,QAAQA,UAAe,SAG3Eb,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,MAAO,wBAEf,EAEG,MAAMS,UAAqCvB,EAC9C,WAAAC,EAAYe,MAAEA,EAAKK,KAAEA,EAAIC,SAAEA,IACvBnB,MAAM,yBAA0B,CAC5BC,QAASY,EACTG,aAAc,CACV,aAAaG,iBAAwBD,EAAO,QAAQA,UAAe,MACnE,iFAAiFC,mBAGzFd,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,MAAO,gCAEf,EAEG,MAAMU,UAAqCxB,EAC9C,WAAAC,EAAYwB,aAAEA,IACVtB,MAAM,yBAA0B,CAC5BC,QAASC,KAAKC,UAAUmB,EAAc,KAAM,GAC5CN,aAAc,CAAC,oCAEnBX,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,MAAO,gCAEf","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/errors/signature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.js","sources":["../../../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/errors/signature.js"],"sourcesContent":["import { BaseError } from '../../errors.js';\nexport class InvalidSignatureError extends BaseError {\n    constructor({ signature, type, }) {\n        super(`Invalid ${type} signature.`, {\n            details: signature,\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'InvalidSignatureError'\n        });\n    }\n}\nexport class UnknownSignatureError extends BaseError {\n    constructor({ signature }) {\n        super('Unknown signature.', {\n            details: signature,\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'UnknownSignatureError'\n        });\n    }\n}\nexport class InvalidStructSignatureError extends BaseError {\n    constructor({ signature }) {\n        super('Invalid struct signature.', {\n            details: signature,\n            metaMessages: ['No properties exist.'],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'InvalidStructSignatureError'\n        });\n    }\n}\n//# sourceMappingURL=signature.js.map"],"names":["InvalidSignatureError","BaseError","constructor","signature","type","super","details","Object","defineProperty","this","enumerable","configurable","writable","value","UnknownSignatureError","InvalidStructSignatureError","metaMessages"],"mappings":"4CACO,MAAMA,UAA8BC,EACvC,WAAAC,EAAYC,UAAEA,EAASC,KAAEA,IACrBC,MAAM,WAAWD,eAAmB,CAChCE,QAASH,IAEbI,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,MAAO,yBAEf,EAEG,MAAMC,UAA8Bb,EACvC,WAAAC,EAAYC,UAAEA,IACVE,MAAM,qBAAsB,CACxBC,QAASH,IAEbI,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,MAAO,yBAEf,EAEG,MAAME,UAAoCd,EAC7C,WAAAC,EAAYC,UAAEA,IACVE,MAAM,4BAA6B,CAC/BC,QAASH,EACTa,aAAc,CAAC,0BAEnBT,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,MAAO,+BAEf","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splitParameters.js","sources":["../../../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js"],"sourcesContent":["import { BaseError } from '../../errors.js';\nexport class InvalidParenthesisError extends BaseError {\n    constructor({ current, depth }) {\n        super('Unbalanced parentheses.', {\n            metaMessages: [\n                `\"${current.trim()}\" has too many ${depth > 0 ? 'opening' : 'closing'} parentheses.`,\n            ],\n            details: `Depth \"${depth}\"`,\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'InvalidParenthesisError'\n        });\n    }\n}\n//# sourceMappingURL=splitParameters.js.map"],"names":["InvalidParenthesisError","BaseError","constructor","current","depth","super","metaMessages","trim","details","Object","defineProperty","this","enumerable","configurable","writable","value"],"mappings":"4CACO,MAAMA,UAAgCC,EACzC,WAAAC,EAAYC,QAAEA,EAAOC,MAAEA,IACnBC,MAAM,0BAA2B,CAC7BC,aAAc,CACV,IAAIH,EAAQI,wBAAwBH,EAAQ,EAAI,UAAY,0BAEhEI,QAAS,UAAUJ,OAEvBK,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,MAAO,2BAEf","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/errors/struct.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"struct.js","sources":["../../../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/errors/struct.js"],"sourcesContent":["import { BaseError } from '../../errors.js';\nexport class CircularReferenceError extends BaseError {\n    constructor({ type }) {\n        super('Circular reference detected.', {\n            metaMessages: [`Struct \"${type}\" is a circular reference.`],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'CircularReferenceError'\n        });\n    }\n}\n//# sourceMappingURL=struct.js.map"],"names":["CircularReferenceError","BaseError","constructor","type","super","metaMessages","Object","defineProperty","this","enumerable","configurable","writable","value"],"mappings":"4CACO,MAAMA,UAA+BC,EACxC,WAAAC,EAAYC,KAAEA,IACVC,MAAM,+BAAgC,CAClCC,aAAc,CAAC,WAAWF,iCAE9BG,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,MAAO,0BAEf","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatAbiItem.js","sources":["../../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js"],"sourcesContent":["import { formatAbiParameters, } from './formatAbiParameters.js';\n/**\n * Formats ABI item (e.g. error, event, function) into human-readable ABI item\n *\n * @param abiItem - ABI item\n * @returns Human-readable ABI item\n */\nexport function formatAbiItem(abiItem) {\n    if (abiItem.type === 'function')\n        return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== 'nonpayable'\n            ? ` ${abiItem.stateMutability}`\n            : ''}${abiItem.outputs?.length\n            ? ` returns (${formatAbiParameters(abiItem.outputs)})`\n            : ''}`;\n    if (abiItem.type === 'event')\n        return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;\n    if (abiItem.type === 'error')\n        return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;\n    if (abiItem.type === 'constructor')\n        return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === 'payable' ? ' payable' : ''}`;\n    if (abiItem.type === 'fallback')\n        return `fallback() external${abiItem.stateMutability === 'payable' ? ' payable' : ''}`;\n    return 'receive() external payable';\n}\n//# sourceMappingURL=formatAbiItem.js.map"],"names":["formatAbiItem","abiItem","type","name","formatAbiParameters","inputs","stateMutability","outputs","length"],"mappings":"+DAOO,SAASA,EAAcC,GAC1B,MAAqB,aAAjBA,EAAQC,KACD,YAAYD,EAAQE,QAAQC,EAAoBH,EAAQI,WAAWJ,EAAQK,iBAA+C,eAA5BL,EAAQK,gBACvG,IAAIL,EAAQK,kBACZ,KAAKL,EAAQM,SAASC,OACtB,aAAaJ,EAAoBH,EAAQM,YACzC,KACW,UAAjBN,EAAQC,KACD,SAASD,EAAQE,QAAQC,EAAoBH,EAAQI,WAC3C,UAAjBJ,EAAQC,KACD,SAASD,EAAQE,QAAQC,EAAoBH,EAAQI,WAC3C,gBAAjBJ,EAAQC,KACD,eAAeE,EAAoBH,EAAQI,WAAuC,YAA5BJ,EAAQK,gBAAgC,WAAa,KACjG,aAAjBL,EAAQC,KACD,uBAAkD,YAA5BD,EAAQK,gBAAgC,WAAa,IAC/E,4BACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatAbiParameter.js","sources":["../../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js"],"sourcesContent":["import { execTyped } from '../regex.js';\n// https://regexr.com/7f7rv\nconst tupleRegex = /^tuple(?<array>(\\[(\\d*)\\])*)$/;\n/**\n * Formats {@link AbiParameter} to human-readable ABI parameter.\n *\n * @param abiParameter - ABI parameter\n * @returns Human-readable ABI parameter\n *\n * @example\n * const result = formatAbiParameter({ type: 'address', name: 'from' })\n * //    ^? const result: 'address from'\n */\nexport function formatAbiParameter(abiParameter) {\n    let type = abiParameter.type;\n    if (tupleRegex.test(abiParameter.type) && 'components' in abiParameter) {\n        type = '(';\n        const length = abiParameter.components.length;\n        for (let i = 0; i < length; i++) {\n            const component = abiParameter.components[i];\n            type += formatAbiParameter(component);\n            if (i < length - 1)\n                type += ', ';\n        }\n        const result = execTyped(tupleRegex, abiParameter.type);\n        type += `)${result?.array ?? ''}`;\n        return formatAbiParameter({\n            ...abiParameter,\n            type,\n        });\n    }\n    // Add `indexed` to type if in `abiParameter`\n    if ('indexed' in abiParameter && abiParameter.indexed)\n        type = `${type} indexed`;\n    // Return human-readable ABI parameter\n    if (abiParameter.name)\n        return `${type} ${abiParameter.name}`;\n    return type;\n}\n//# sourceMappingURL=formatAbiParameter.js.map"],"names":["tupleRegex","formatAbiParameter","abiParameter","type","test","length","components","i","result","execTyped","array","indexed","name"],"mappings":"wCAEA,MAAMA,EAAa,gCAWZ,SAASC,EAAmBC,GAC/B,IAAIC,EAAOD,EAAaC,KACxB,GAAIH,EAAWI,KAAKF,EAAaC,OAAS,eAAgBD,EAAc,CACpEC,EAAO,IACP,MAAME,EAASH,EAAaI,WAAWD,OACvC,IAAK,IAAIE,EAAI,EAAGA,EAAIF,EAAQE,IAAK,CAE7BJ,GAAQF,EADUC,EAAaI,WAAWC,IAEtCA,EAAIF,EAAS,IACbF,GAAQ,KAChB,CACA,MAAMK,EAASC,EAAUT,EAAYE,EAAaC,MAElD,OADAA,GAAQ,IAAIK,GAAQE,OAAS,KACtBT,EAAmB,IACnBC,EACHC,QAER,CAKA,MAHI,YAAaD,GAAgBA,EAAaS,UAC1CR,EAAO,GAAGA,aAEVD,EAAaU,KACN,GAAGT,KAAQD,EAAaU,OAC5BT,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatAbiParameters.js","sources":["../../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js"],"sourcesContent":["import { formatAbiParameter, } from './formatAbiParameter.js';\n/**\n * Formats {@link AbiParameter}s to human-readable ABI parameters.\n *\n * @param abiParameters - ABI parameters\n * @returns Human-readable ABI parameters\n *\n * @example\n * const result = formatAbiParameters([\n *   //  ^? const result: 'address from, uint256 tokenId'\n *   { type: 'address', name: 'from' },\n *   { type: 'uint256', name: 'tokenId' },\n * ])\n */\nexport function formatAbiParameters(abiParameters) {\n    let params = '';\n    const length = abiParameters.length;\n    for (let i = 0; i < length; i++) {\n        const abiParameter = abiParameters[i];\n        params += formatAbiParameter(abiParameter);\n        if (i !== length - 1)\n            params += ', ';\n    }\n    return params;\n}\n//# sourceMappingURL=formatAbiParameters.js.map"],"names":["formatAbiParameters","abiParameters","params","length","i","abiParameter","formatAbiParameter"],"mappings":"6DAcO,SAASA,EAAoBC,GAChC,IAAIC,EAAS,GACb,MAAMC,EAASF,EAAcE,OAC7B,IAAK,IAAIC,EAAI,EAAGA,EAAID,EAAQC,IAAK,CAC7B,MAAMC,EAAeJ,EAAcG,GACnCF,GAAUI,EAAmBD,GACzBD,IAAMD,EAAS,IACfD,GAAU,KAClB,CACA,OAAOA,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/parseAbi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseAbi.js","sources":["../../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/parseAbi.js"],"sourcesContent":["import { isStructSignature } from './runtime/signatures.js';\nimport { parseStructs } from './runtime/structs.js';\nimport { parseSignature } from './runtime/utils.js';\n/**\n * Parses human-readable ABI into JSON {@link Abi}\n *\n * @param signatures - Human-Readable ABI\n * @returns Parsed {@link Abi}\n *\n * @example\n * const abi = parseAbi([\n *   //  ^? const abi: readonly [{ name: \"balanceOf\"; type: \"function\"; stateMutability:...\n *   'function balanceOf(address owner) view returns (uint256)',\n *   'event Transfer(address indexed from, address indexed to, uint256 amount)',\n * ])\n */\nexport function parseAbi(signatures) {\n    const structs = parseStructs(signatures);\n    const abi = [];\n    const length = signatures.length;\n    for (let i = 0; i < length; i++) {\n        const signature = signatures[i];\n        if (isStructSignature(signature))\n            continue;\n        abi.push(parseSignature(signature, structs));\n    }\n    return abi;\n}\n//# sourceMappingURL=parseAbi.js.map"],"names":["parseAbi","signatures","structs","parseStructs","abi","length","i","signature","isStructSignature","push","parseSignature"],"mappings":"oKAgBO,SAASA,EAASC,GACrB,MAAMC,EAAUC,EAAaF,GACvBG,EAAM,GACNC,EAASJ,EAAWI,OAC1B,IAAK,IAAIC,EAAI,EAAGA,EAAID,EAAQC,IAAK,CAC7B,MAAMC,EAAYN,EAAWK,GACzBE,EAAkBD,IAEtBH,EAAIK,KAAKC,EAAeH,EAAWL,GACvC,CACA,OAAOE,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseAbiItem.js","sources":["../../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js"],"sourcesContent":["import { InvalidAbiItemError } from './errors/abiItem.js';\nimport { isStructSignature } from './runtime/signatures.js';\nimport { parseStructs } from './runtime/structs.js';\nimport { parseSignature } from './runtime/utils.js';\n/**\n * Parses human-readable ABI item (e.g. error, event, function) into {@link Abi} item\n *\n * @param signature - Human-readable ABI item\n * @returns Parsed {@link Abi} item\n *\n * @example\n * const abiItem = parseAbiItem('function balanceOf(address owner) view returns (uint256)')\n * //    ^? const abiItem: { name: \"balanceOf\"; type: \"function\"; stateMutability: \"view\";...\n *\n * @example\n * const abiItem = parseAbiItem([\n *   //  ^? const abiItem: { name: \"foo\"; type: \"function\"; stateMutability: \"view\"; inputs:...\n *   'function foo(Baz bar) view returns (string)',\n *   'struct Baz { string name; }',\n * ])\n */\nexport function parseAbiItem(signature) {\n    let abiItem;\n    if (typeof signature === 'string')\n        abiItem = parseSignature(signature);\n    else {\n        const structs = parseStructs(signature);\n        const length = signature.length;\n        for (let i = 0; i < length; i++) {\n            const signature_ = signature[i];\n            if (isStructSignature(signature_))\n                continue;\n            abiItem = parseSignature(signature_, structs);\n            break;\n        }\n    }\n    if (!abiItem)\n        throw new InvalidAbiItemError({ signature });\n    return abiItem;\n}\n//# sourceMappingURL=parseAbiItem.js.map"],"names":["parseAbiItem","signature","abiItem","parseSignature","structs","parseStructs","length","i","signature_","isStructSignature","InvalidAbiItemError"],"mappings":"8NAqBO,SAASA,EAAaC,GACzB,IAAIC,EACJ,GAAyB,iBAAdD,EACPC,EAAUC,EAAeF,OACxB,CACD,MAAMG,EAAUC,EAAaJ,GACvBK,EAASL,EAAUK,OACzB,IAAK,IAAIC,EAAI,EAAGA,EAAID,EAAQC,IAAK,CAC7B,MAAMC,EAAaP,EAAUM,GAC7B,IAAIE,EAAkBD,GAAtB,CAEAN,EAAUC,EAAeK,EAAYJ,GACrC,KAFI,CAGR,CACJ,CACA,IAAKF,EACD,MAAM,IAAIQ,EAAoB,CAAET,cACpC,OAAOC,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseAbiParameters.js","sources":["../../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js"],"sourcesContent":["import { InvalidAbiParametersError } from './errors/abiParameter.js';\nimport { isStructSignature, modifiers } from './runtime/signatures.js';\nimport { parseStructs } from './runtime/structs.js';\nimport { splitParameters } from './runtime/utils.js';\nimport { parseAbiParameter as parseAbiParameter_ } from './runtime/utils.js';\n/**\n * Parses human-readable ABI parameters into {@link AbiParameter}s\n *\n * @param params - Human-readable ABI parameters\n * @returns Parsed {@link AbiParameter}s\n *\n * @example\n * const abiParameters = parseAbiParameters('address from, address to, uint256 amount')\n * //    ^? const abiParameters: [{ type: \"address\"; name: \"from\"; }, { type: \"address\";...\n *\n * @example\n * const abiParameters = parseAbiParameters([\n *   //  ^? const abiParameters: [{ type: \"tuple\"; components: [{ type: \"string\"; name:...\n *   'Baz bar',\n *   'struct Baz { string name; }',\n * ])\n */\nexport function parseAbiParameters(params) {\n    const abiParameters = [];\n    if (typeof params === 'string') {\n        const parameters = splitParameters(params);\n        const length = parameters.length;\n        for (let i = 0; i < length; i++) {\n            abiParameters.push(parseAbiParameter_(parameters[i], { modifiers }));\n        }\n    }\n    else {\n        const structs = parseStructs(params);\n        const length = params.length;\n        for (let i = 0; i < length; i++) {\n            const signature = params[i];\n            if (isStructSignature(signature))\n                continue;\n            const parameters = splitParameters(signature);\n            const length = parameters.length;\n            for (let k = 0; k < length; k++) {\n                abiParameters.push(parseAbiParameter_(parameters[k], { modifiers, structs }));\n            }\n        }\n    }\n    if (abiParameters.length === 0)\n        throw new InvalidAbiParametersError({ params });\n    return abiParameters;\n}\n//# sourceMappingURL=parseAbiParameters.js.map"],"names":["parseAbiParameters","params","abiParameters","parameters","splitParameters","length","i","push","parseAbiParameter_","modifiers","structs","parseStructs","signature","isStructSignature","k","InvalidAbiParametersError"],"mappings":"gRAsBO,SAASA,EAAmBC,GAC/B,MAAMC,EAAgB,GACtB,GAAsB,iBAAXD,EAAqB,CAC5B,MAAME,EAAaC,EAAgBH,GAC7BI,EAASF,EAAWE,OAC1B,IAAK,IAAIC,EAAI,EAAGA,EAAID,EAAQC,IACxBJ,EAAcK,KAAKC,EAAmBL,EAAWG,GAAI,CAAEG,cAE/D,KACK,CACD,MAAMC,EAAUC,EAAaV,GACvBI,EAASJ,EAAOI,OACtB,IAAK,IAAIC,EAAI,EAAGA,EAAID,EAAQC,IAAK,CAC7B,MAAMM,EAAYX,EAAOK,GACzB,GAAIO,EAAkBD,GAClB,SACJ,MAAMT,EAAaC,EAAgBQ,GAC7BP,EAASF,EAAWE,OAC1B,IAAK,IAAIS,EAAI,EAAGA,EAAIT,EAAQS,IACxBZ,EAAcK,KAAKC,EAAmBL,EAAWW,GAAI,CAAEL,YAAWC,YAE1E,CACJ,CACA,GAA6B,IAAzBR,EAAcG,OACd,MAAM,IAAIU,EAA0B,CAAEd,WAC1C,OAAOC,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/runtime/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sources":["../../../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/runtime/cache.js"],"sourcesContent":["/**\n * Gets {@link parameterCache} cache key namespaced by {@link type}. This prevents parameters from being accessible to types that don't allow them (e.g. `string indexed foo` not allowed outside of `type: 'event'`).\n * @param param ABI parameter string\n * @param type ABI parameter type\n * @returns Cache key for {@link parameterCache}\n */\nexport function getParameterCacheKey(param, type, structs) {\n    let structKey = '';\n    if (structs)\n        for (const struct of Object.entries(structs)) {\n            if (!struct)\n                continue;\n            let propertyKey = '';\n            for (const property of struct[1]) {\n                propertyKey += `[${property.type}${property.name ? `:${property.name}` : ''}]`;\n            }\n            structKey += `(${struct[0]}{${propertyKey}})`;\n        }\n    if (type)\n        return `${type}:${param}${structKey}`;\n    return param;\n}\n/**\n * Basic cache seeded with common ABI parameter strings.\n *\n * **Note: When seeding more parameters, make sure you benchmark performance. The current number is the ideal balance between performance and having an already existing cache.**\n */\nexport const parameterCache = new Map([\n    // Unnamed\n    ['address', { type: 'address' }],\n    ['bool', { type: 'bool' }],\n    ['bytes', { type: 'bytes' }],\n    ['bytes32', { type: 'bytes32' }],\n    ['int', { type: 'int256' }],\n    ['int256', { type: 'int256' }],\n    ['string', { type: 'string' }],\n    ['uint', { type: 'uint256' }],\n    ['uint8', { type: 'uint8' }],\n    ['uint16', { type: 'uint16' }],\n    ['uint24', { type: 'uint24' }],\n    ['uint32', { type: 'uint32' }],\n    ['uint64', { type: 'uint64' }],\n    ['uint96', { type: 'uint96' }],\n    ['uint112', { type: 'uint112' }],\n    ['uint160', { type: 'uint160' }],\n    ['uint192', { type: 'uint192' }],\n    ['uint256', { type: 'uint256' }],\n    // Named\n    ['address owner', { type: 'address', name: 'owner' }],\n    ['address to', { type: 'address', name: 'to' }],\n    ['bool approved', { type: 'bool', name: 'approved' }],\n    ['bytes _data', { type: 'bytes', name: '_data' }],\n    ['bytes data', { type: 'bytes', name: 'data' }],\n    ['bytes signature', { type: 'bytes', name: 'signature' }],\n    ['bytes32 hash', { type: 'bytes32', name: 'hash' }],\n    ['bytes32 r', { type: 'bytes32', name: 'r' }],\n    ['bytes32 root', { type: 'bytes32', name: 'root' }],\n    ['bytes32 s', { type: 'bytes32', name: 's' }],\n    ['string name', { type: 'string', name: 'name' }],\n    ['string symbol', { type: 'string', name: 'symbol' }],\n    ['string tokenURI', { type: 'string', name: 'tokenURI' }],\n    ['uint tokenId', { type: 'uint256', name: 'tokenId' }],\n    ['uint8 v', { type: 'uint8', name: 'v' }],\n    ['uint256 balance', { type: 'uint256', name: 'balance' }],\n    ['uint256 tokenId', { type: 'uint256', name: 'tokenId' }],\n    ['uint256 value', { type: 'uint256', name: 'value' }],\n    // Indexed\n    [\n        'event:address indexed from',\n        { type: 'address', name: 'from', indexed: true },\n    ],\n    ['event:address indexed to', { type: 'address', name: 'to', indexed: true }],\n    [\n        'event:uint indexed tokenId',\n        { type: 'uint256', name: 'tokenId', indexed: true },\n    ],\n    [\n        'event:uint256 indexed tokenId',\n        { type: 'uint256', name: 'tokenId', indexed: true },\n    ],\n]);\n//# sourceMappingURL=cache.js.map"],"names":["getParameterCacheKey","param","type","structs","structKey","struct","Object","entries","propertyKey","property","name","parameterCache","Map","indexed"],"mappings":"AAMO,SAASA,EAAqBC,EAAOC,EAAMC,GAC9C,IAAIC,EAAY,GAChB,GAAID,EACA,IAAK,MAAME,KAAUC,OAAOC,QAAQJ,GAAU,CAC1C,IAAKE,EACD,SACJ,IAAIG,EAAc,GAClB,IAAK,MAAMC,KAAYJ,EAAO,GAC1BG,GAAe,IAAIC,EAASP,OAAOO,EAASC,KAAO,IAAID,EAASC,OAAS,MAE7EN,GAAa,IAAIC,EAAO,MAAMG,KAClC,CACJ,OAAIN,EACO,GAAGA,KAAQD,IAAQG,IACvBH,CACX,CAMY,MAACU,EAAiB,IAAIC,IAAI,CAElC,CAAC,UAAW,CAAEV,KAAM,YACpB,CAAC,OAAQ,CAAEA,KAAM,SACjB,CAAC,QAAS,CAAEA,KAAM,UAClB,CAAC,UAAW,CAAEA,KAAM,YACpB,CAAC,MAAO,CAAEA,KAAM,WAChB,CAAC,SAAU,CAAEA,KAAM,WACnB,CAAC,SAAU,CAAEA,KAAM,WACnB,CAAC,OAAQ,CAAEA,KAAM,YACjB,CAAC,QAAS,CAAEA,KAAM,UAClB,CAAC,SAAU,CAAEA,KAAM,WACnB,CAAC,SAAU,CAAEA,KAAM,WACnB,CAAC,SAAU,CAAEA,KAAM,WACnB,CAAC,SAAU,CAAEA,KAAM,WACnB,CAAC,SAAU,CAAEA,KAAM,WACnB,CAAC,UAAW,CAAEA,KAAM,YACpB,CAAC,UAAW,CAAEA,KAAM,YACpB,CAAC,UAAW,CAAEA,KAAM,YACpB,CAAC,UAAW,CAAEA,KAAM,YAEpB,CAAC,gBAAiB,CAAEA,KAAM,UAAWQ,KAAM,UAC3C,CAAC,aAAc,CAAER,KAAM,UAAWQ,KAAM,OACxC,CAAC,gBAAiB,CAAER,KAAM,OAAQQ,KAAM,aACxC,CAAC,cAAe,CAAER,KAAM,QAASQ,KAAM,UACvC,CAAC,aAAc,CAAER,KAAM,QAASQ,KAAM,SACtC,CAAC,kBAAmB,CAAER,KAAM,QAASQ,KAAM,cAC3C,CAAC,eAAgB,CAAER,KAAM,UAAWQ,KAAM,SAC1C,CAAC,YAAa,CAAER,KAAM,UAAWQ,KAAM,MACvC,CAAC,eAAgB,CAAER,KAAM,UAAWQ,KAAM,SAC1C,CAAC,YAAa,CAAER,KAAM,UAAWQ,KAAM,MACvC,CAAC,cAAe,CAAER,KAAM,SAAUQ,KAAM,SACxC,CAAC,gBAAiB,CAAER,KAAM,SAAUQ,KAAM,WAC1C,CAAC,kBAAmB,CAAER,KAAM,SAAUQ,KAAM,aAC5C,CAAC,eAAgB,CAAER,KAAM,UAAWQ,KAAM,YAC1C,CAAC,UAAW,CAAER,KAAM,QAASQ,KAAM,MACnC,CAAC,kBAAmB,CAAER,KAAM,UAAWQ,KAAM,YAC7C,CAAC,kBAAmB,CAAER,KAAM,UAAWQ,KAAM,YAC7C,CAAC,gBAAiB,CAAER,KAAM,UAAWQ,KAAM,UAE3C,CACI,6BACA,CAAER,KAAM,UAAWQ,KAAM,OAAQG,SAAS,IAE9C,CAAC,2BAA4B,CAAEX,KAAM,UAAWQ,KAAM,KAAMG,SAAS,IACrE,CACI,6BACA,CAAEX,KAAM,UAAWQ,KAAM,UAAWG,SAAS,IAEjD,CACI,gCACA,CAAEX,KAAM,UAAWQ,KAAM,UAAWG,SAAS","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signatures.js","sources":["../../../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js"],"sourcesContent":["import { execTyped } from '../../regex.js';\n// https://regexr.com/7gmok\nconst errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\\((?<parameters>.*?)\\)$/;\nexport function isErrorSignature(signature) {\n    return errorSignatureRegex.test(signature);\n}\nexport function execErrorSignature(signature) {\n    return execTyped(errorSignatureRegex, signature);\n}\n// https://regexr.com/7gmoq\nconst eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\\((?<parameters>.*?)\\)$/;\nexport function isEventSignature(signature) {\n    return eventSignatureRegex.test(signature);\n}\nexport function execEventSignature(signature) {\n    return execTyped(eventSignatureRegex, signature);\n}\n// https://regexr.com/7gmot\nconst functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\\((?<parameters>.*?)\\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\\s?\\((?<returns>.*?)\\))?$/;\nexport function isFunctionSignature(signature) {\n    return functionSignatureRegex.test(signature);\n}\nexport function execFunctionSignature(signature) {\n    return execTyped(functionSignatureRegex, signature);\n}\n// https://regexr.com/7gmp3\nconst structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \\{(?<properties>.*?)\\}$/;\nexport function isStructSignature(signature) {\n    return structSignatureRegex.test(signature);\n}\nexport function execStructSignature(signature) {\n    return execTyped(structSignatureRegex, signature);\n}\n// https://regexr.com/78u01\nconst constructorSignatureRegex = /^constructor\\((?<parameters>.*?)\\)(?:\\s(?<stateMutability>payable{1}))?$/;\nexport function isConstructorSignature(signature) {\n    return constructorSignatureRegex.test(signature);\n}\nexport function execConstructorSignature(signature) {\n    return execTyped(constructorSignatureRegex, signature);\n}\n// https://regexr.com/7srtn\nconst fallbackSignatureRegex = /^fallback\\(\\) external(?:\\s(?<stateMutability>payable{1}))?$/;\nexport function isFallbackSignature(signature) {\n    return fallbackSignatureRegex.test(signature);\n}\nexport function execFallbackSignature(signature) {\n    return execTyped(fallbackSignatureRegex, signature);\n}\n// https://regexr.com/78u1k\nconst receiveSignatureRegex = /^receive\\(\\) external payable$/;\nexport function isReceiveSignature(signature) {\n    return receiveSignatureRegex.test(signature);\n}\nexport const modifiers = new Set([\n    'memory',\n    'indexed',\n    'storage',\n    'calldata',\n]);\nexport const eventModifiers = new Set(['indexed']);\nexport const functionModifiers = new Set([\n    'calldata',\n    'memory',\n    'storage',\n]);\n//# sourceMappingURL=signatures.js.map"],"names":["errorSignatureRegex","isErrorSignature","signature","test","execErrorSignature","execTyped","eventSignatureRegex","isEventSignature","execEventSignature","functionSignatureRegex","isFunctionSignature","execFunctionSignature","structSignatureRegex","isStructSignature","execStructSignature","constructorSignatureRegex","isConstructorSignature","execConstructorSignature","fallbackSignatureRegex","isFallbackSignature","execFallbackSignature","receiveSignatureRegex","isReceiveSignature","modifiers","Set","eventModifiers","functionModifiers"],"mappings":"2CAEA,MAAMA,EAAsB,kEACrB,SAASC,EAAiBC,GAC7B,OAAOF,EAAoBG,KAAKD,EACpC,CACO,SAASE,EAAmBF,GAC/B,OAAOG,EAAUL,EAAqBE,EAC1C,CAEA,MAAMI,EAAsB,kEACrB,SAASC,EAAiBL,GAC7B,OAAOI,EAAoBH,KAAKD,EACpC,CACO,SAASM,EAAmBN,GAC/B,OAAOG,EAAUC,EAAqBJ,EAC1C,CAEA,MAAMO,EAAyB,mMACxB,SAASC,EAAoBR,GAChC,OAAOO,EAAuBN,KAAKD,EACvC,CACO,SAASS,EAAsBT,GAClC,OAAOG,EAAUI,EAAwBP,EAC7C,CAEA,MAAMU,EAAuB,oEACtB,SAASC,EAAkBX,GAC9B,OAAOU,EAAqBT,KAAKD,EACrC,CACO,SAASY,EAAoBZ,GAChC,OAAOG,EAAUO,EAAsBV,EAC3C,CAEA,MAAMa,EAA4B,2EAC3B,SAASC,EAAuBd,GACnC,OAAOa,EAA0BZ,KAAKD,EAC1C,CACO,SAASe,EAAyBf,GACrC,OAAOG,EAAUU,EAA2Bb,EAChD,CAEA,MAAMgB,EAAyB,+DACxB,SAASC,EAAoBjB,GAChC,OAAOgB,EAAuBf,KAAKD,EACvC,CACO,SAASkB,EAAsBlB,GAClC,OAAOG,EAAUa,EAAwBhB,EAC7C,CAEA,MAAMmB,EAAwB,iCACvB,SAASC,EAAmBpB,GAC/B,OAAOmB,EAAsBlB,KAAKD,EACtC,CACY,MAACqB,EAAY,IAAIC,IAAI,CAC7B,SACA,UACA,UACA,aAESC,EAAiB,IAAID,IAAI,CAAC,YAC1BE,EAAoB,IAAIF,IAAI,CACrC,WACA,SACA","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/runtime/structs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"structs.js","sources":["../../../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/runtime/structs.js"],"sourcesContent":["import { execTyped, isTupleRegex } from '../../regex.js';\nimport { UnknownTypeError } from '../errors/abiItem.js';\nimport { InvalidAbiTypeParameterError } from '../errors/abiParameter.js';\nimport { InvalidSignatureError, InvalidStructSignatureError, } from '../errors/signature.js';\nimport { CircularReferenceError } from '../errors/struct.js';\nimport { execStructSignature, isStructSignature } from './signatures.js';\nimport { isSolidityType, parseAbiParameter } from './utils.js';\nexport function parseStructs(signatures) {\n    // Create \"shallow\" version of each struct (and filter out non-structs or invalid structs)\n    const shallowStructs = {};\n    const signaturesLength = signatures.length;\n    for (let i = 0; i < signaturesLength; i++) {\n        const signature = signatures[i];\n        if (!isStructSignature(signature))\n            continue;\n        const match = execStructSignature(signature);\n        if (!match)\n            throw new InvalidSignatureError({ signature, type: 'struct' });\n        const properties = match.properties.split(';');\n        const components = [];\n        const propertiesLength = properties.length;\n        for (let k = 0; k < propertiesLength; k++) {\n            const property = properties[k];\n            const trimmed = property.trim();\n            if (!trimmed)\n                continue;\n            const abiParameter = parseAbiParameter(trimmed, {\n                type: 'struct',\n            });\n            components.push(abiParameter);\n        }\n        if (!components.length)\n            throw new InvalidStructSignatureError({ signature });\n        shallowStructs[match.name] = components;\n    }\n    // Resolve nested structs inside each parameter\n    const resolvedStructs = {};\n    const entries = Object.entries(shallowStructs);\n    const entriesLength = entries.length;\n    for (let i = 0; i < entriesLength; i++) {\n        const [name, parameters] = entries[i];\n        resolvedStructs[name] = resolveStructs(parameters, shallowStructs);\n    }\n    return resolvedStructs;\n}\nconst typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\\[\\d*?\\])+?)?$/;\nfunction resolveStructs(abiParameters, structs, ancestors = new Set()) {\n    const components = [];\n    const length = abiParameters.length;\n    for (let i = 0; i < length; i++) {\n        const abiParameter = abiParameters[i];\n        const isTuple = isTupleRegex.test(abiParameter.type);\n        if (isTuple)\n            components.push(abiParameter);\n        else {\n            const match = execTyped(typeWithoutTupleRegex, abiParameter.type);\n            if (!match?.type)\n                throw new InvalidAbiTypeParameterError({ abiParameter });\n            const { array, type } = match;\n            if (type in structs) {\n                if (ancestors.has(type))\n                    throw new CircularReferenceError({ type });\n                components.push({\n                    ...abiParameter,\n                    type: `tuple${array ?? ''}`,\n                    components: resolveStructs(structs[type] ?? [], structs, new Set([...ancestors, type])),\n                });\n            }\n            else {\n                if (isSolidityType(type))\n                    components.push(abiParameter);\n                else\n                    throw new UnknownTypeError({ type });\n            }\n        }\n    }\n    return components;\n}\n//# sourceMappingURL=structs.js.map"],"names":["parseStructs","signatures","shallowStructs","signaturesLength","length","i","signature","isStructSignature","match","execStructSignature","InvalidSignatureError","type","properties","split","components","propertiesLength","k","trimmed","trim","abiParameter","parseAbiParameter","push","InvalidStructSignatureError","name","resolvedStructs","entries","Object","entriesLength","parameters","resolveStructs","typeWithoutTupleRegex","abiParameters","structs","ancestors","Set","isTupleRegex","test","execTyped","InvalidAbiTypeParameterError","array","has","CircularReferenceError","isSolidityType","UnknownTypeError"],"mappings":"2eAOO,SAASA,EAAaC,GAEzB,MAAMC,EAAiB,CAAA,EACjBC,EAAmBF,EAAWG,OACpC,IAAK,IAAIC,EAAI,EAAGA,EAAIF,EAAkBE,IAAK,CACvC,MAAMC,EAAYL,EAAWI,GAC7B,IAAKE,EAAkBD,GACnB,SACJ,MAAME,EAAQC,EAAoBH,GAClC,IAAKE,EACD,MAAM,IAAIE,EAAsB,CAAEJ,YAAWK,KAAM,WACvD,MAAMC,EAAaJ,EAAMI,WAAWC,MAAM,KACpCC,EAAa,GACbC,EAAmBH,EAAWR,OACpC,IAAK,IAAIY,EAAI,EAAGA,EAAID,EAAkBC,IAAK,CACvC,MACMC,EADWL,EAAWI,GACHE,OACzB,IAAKD,EACD,SACJ,MAAME,EAAeC,EAAkBH,EAAS,CAC5CN,KAAM,WAEVG,EAAWO,KAAKF,EACpB,CACA,IAAKL,EAAWV,OACZ,MAAM,IAAIkB,EAA4B,CAAEhB,cAC5CJ,EAAeM,EAAMe,MAAQT,CACjC,CAEA,MAAMU,EAAkB,CAAA,EAClBC,EAAUC,OAAOD,QAAQvB,GACzByB,EAAgBF,EAAQrB,OAC9B,IAAK,IAAIC,EAAI,EAAGA,EAAIsB,EAAetB,IAAK,CACpC,MAAOkB,EAAMK,GAAcH,EAAQpB,GACnCmB,EAAgBD,GAAQM,EAAeD,EAAY1B,EACvD,CACA,OAAOsB,CACX,CACA,MAAMM,EAAwB,+DAC9B,SAASD,EAAeE,EAAeC,EAASC,EAAY,IAAIC,KAC5D,MAAMpB,EAAa,GACbV,EAAS2B,EAAc3B,OAC7B,IAAK,IAAIC,EAAI,EAAGA,EAAID,EAAQC,IAAK,CAC7B,MAAMc,EAAeY,EAAc1B,GAEnC,GADgB8B,EAAaC,KAAKjB,EAAaR,MAE3CG,EAAWO,KAAKF,OACf,CACD,MAAMX,EAAQ6B,EAAUP,EAAuBX,EAAaR,MAC5D,IAAKH,GAAOG,KACR,MAAM,IAAI2B,EAA6B,CAAEnB,iBAC7C,MAAMoB,MAAEA,EAAK5B,KAAEA,GAASH,EACxB,GAAIG,KAAQqB,EAAS,CACjB,GAAIC,EAAUO,IAAI7B,GACd,MAAM,IAAI8B,EAAuB,CAAE9B,SACvCG,EAAWO,KAAK,IACTF,EACHR,KAAM,QAAQ4B,GAAS,KACvBzB,WAAYe,EAAeG,EAAQrB,IAAS,GAAIqB,EAAS,IAAIE,IAAI,IAAID,EAAWtB,MAExF,KACK,CACD,IAAI+B,EAAe/B,GAGf,MAAM,IAAIgC,EAAiB,CAAEhC,SAF7BG,EAAWO,KAAKF,EAGxB,CACJ,CACJ,CACA,OAAOL,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/runtime/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/human-readable/runtime/utils.js"],"sourcesContent":["import { bytesRegex, execTyped, integerRegex, isTupleRegex, } from '../../regex.js';\nimport { UnknownSolidityTypeError } from '../errors/abiItem.js';\nimport { InvalidFunctionModifierError, InvalidModifierError, InvalidParameterError, SolidityProtectedKeywordError, } from '../errors/abiParameter.js';\nimport { InvalidSignatureError, UnknownSignatureError, } from '../errors/signature.js';\nimport { InvalidParenthesisError } from '../errors/splitParameters.js';\nimport { getParameterCacheKey, parameterCache } from './cache.js';\nimport { eventModifiers, execConstructorSignature, execErrorSignature, execEventSignature, execFallbackSignature, execFunctionSignature, functionModifiers, isConstructorSignature, isErrorSignature, isEventSignature, isFallbackSignature, isFunctionSignature, isReceiveSignature, } from './signatures.js';\nexport function parseSignature(signature, structs = {}) {\n    if (isFunctionSignature(signature))\n        return parseFunctionSignature(signature, structs);\n    if (isEventSignature(signature))\n        return parseEventSignature(signature, structs);\n    if (isErrorSignature(signature))\n        return parseErrorSignature(signature, structs);\n    if (isConstructorSignature(signature))\n        return parseConstructorSignature(signature, structs);\n    if (isFallbackSignature(signature))\n        return parseFallbackSignature(signature);\n    if (isReceiveSignature(signature))\n        return {\n            type: 'receive',\n            stateMutability: 'payable',\n        };\n    throw new UnknownSignatureError({ signature });\n}\nexport function parseFunctionSignature(signature, structs = {}) {\n    const match = execFunctionSignature(signature);\n    if (!match)\n        throw new InvalidSignatureError({ signature, type: 'function' });\n    const inputParams = splitParameters(match.parameters);\n    const inputs = [];\n    const inputLength = inputParams.length;\n    for (let i = 0; i < inputLength; i++) {\n        inputs.push(parseAbiParameter(inputParams[i], {\n            modifiers: functionModifiers,\n            structs,\n            type: 'function',\n        }));\n    }\n    const outputs = [];\n    if (match.returns) {\n        const outputParams = splitParameters(match.returns);\n        const outputLength = outputParams.length;\n        for (let i = 0; i < outputLength; i++) {\n            outputs.push(parseAbiParameter(outputParams[i], {\n                modifiers: functionModifiers,\n                structs,\n                type: 'function',\n            }));\n        }\n    }\n    return {\n        name: match.name,\n        type: 'function',\n        stateMutability: match.stateMutability ?? 'nonpayable',\n        inputs,\n        outputs,\n    };\n}\nexport function parseEventSignature(signature, structs = {}) {\n    const match = execEventSignature(signature);\n    if (!match)\n        throw new InvalidSignatureError({ signature, type: 'event' });\n    const params = splitParameters(match.parameters);\n    const abiParameters = [];\n    const length = params.length;\n    for (let i = 0; i < length; i++)\n        abiParameters.push(parseAbiParameter(params[i], {\n            modifiers: eventModifiers,\n            structs,\n            type: 'event',\n        }));\n    return { name: match.name, type: 'event', inputs: abiParameters };\n}\nexport function parseErrorSignature(signature, structs = {}) {\n    const match = execErrorSignature(signature);\n    if (!match)\n        throw new InvalidSignatureError({ signature, type: 'error' });\n    const params = splitParameters(match.parameters);\n    const abiParameters = [];\n    const length = params.length;\n    for (let i = 0; i < length; i++)\n        abiParameters.push(parseAbiParameter(params[i], { structs, type: 'error' }));\n    return { name: match.name, type: 'error', inputs: abiParameters };\n}\nexport function parseConstructorSignature(signature, structs = {}) {\n    const match = execConstructorSignature(signature);\n    if (!match)\n        throw new InvalidSignatureError({ signature, type: 'constructor' });\n    const params = splitParameters(match.parameters);\n    const abiParameters = [];\n    const length = params.length;\n    for (let i = 0; i < length; i++)\n        abiParameters.push(parseAbiParameter(params[i], { structs, type: 'constructor' }));\n    return {\n        type: 'constructor',\n        stateMutability: match.stateMutability ?? 'nonpayable',\n        inputs: abiParameters,\n    };\n}\nexport function parseFallbackSignature(signature) {\n    const match = execFallbackSignature(signature);\n    if (!match)\n        throw new InvalidSignatureError({ signature, type: 'fallback' });\n    return {\n        type: 'fallback',\n        stateMutability: match.stateMutability ?? 'nonpayable',\n    };\n}\nconst abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*(?:\\spayable)?)(?<array>(?:\\[\\d*?\\])+?)?(?:\\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;\nconst abiParameterWithTupleRegex = /^\\((?<type>.+?)\\)(?<array>(?:\\[\\d*?\\])+?)?(?:\\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;\nconst dynamicIntegerRegex = /^u?int$/;\nexport function parseAbiParameter(param, options) {\n    // optional namespace cache by `type`\n    const parameterCacheKey = getParameterCacheKey(param, options?.type, options?.structs);\n    if (parameterCache.has(parameterCacheKey))\n        return parameterCache.get(parameterCacheKey);\n    const isTuple = isTupleRegex.test(param);\n    const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);\n    if (!match)\n        throw new InvalidParameterError({ param });\n    if (match.name && isSolidityKeyword(match.name))\n        throw new SolidityProtectedKeywordError({ param, name: match.name });\n    const name = match.name ? { name: match.name } : {};\n    const indexed = match.modifier === 'indexed' ? { indexed: true } : {};\n    const structs = options?.structs ?? {};\n    let type;\n    let components = {};\n    if (isTuple) {\n        type = 'tuple';\n        const params = splitParameters(match.type);\n        const components_ = [];\n        const length = params.length;\n        for (let i = 0; i < length; i++) {\n            // remove `modifiers` from `options` to prevent from being added to tuple components\n            components_.push(parseAbiParameter(params[i], { structs }));\n        }\n        components = { components: components_ };\n    }\n    else if (match.type in structs) {\n        type = 'tuple';\n        components = { components: structs[match.type] };\n    }\n    else if (dynamicIntegerRegex.test(match.type)) {\n        type = `${match.type}256`;\n    }\n    else if (match.type === 'address payable') {\n        type = 'address';\n    }\n    else {\n        type = match.type;\n        if (!(options?.type === 'struct') && !isSolidityType(type))\n            throw new UnknownSolidityTypeError({ type });\n    }\n    if (match.modifier) {\n        // Check if modifier exists, but is not allowed (e.g. `indexed` in `functionModifiers`)\n        if (!options?.modifiers?.has?.(match.modifier))\n            throw new InvalidModifierError({\n                param,\n                type: options?.type,\n                modifier: match.modifier,\n            });\n        // Check if resolved `type` is valid if there is a function modifier\n        if (functionModifiers.has(match.modifier) &&\n            !isValidDataLocation(type, !!match.array))\n            throw new InvalidFunctionModifierError({\n                param,\n                type: options?.type,\n                modifier: match.modifier,\n            });\n    }\n    const abiParameter = {\n        type: `${type}${match.array ?? ''}`,\n        ...name,\n        ...indexed,\n        ...components,\n    };\n    parameterCache.set(parameterCacheKey, abiParameter);\n    return abiParameter;\n}\n// s/o latika for this\nexport function splitParameters(params, result = [], current = '', depth = 0) {\n    const length = params.trim().length;\n    // biome-ignore lint/correctness/noUnreachable: recursive\n    for (let i = 0; i < length; i++) {\n        const char = params[i];\n        const tail = params.slice(i + 1);\n        switch (char) {\n            case ',':\n                return depth === 0\n                    ? splitParameters(tail, [...result, current.trim()])\n                    : splitParameters(tail, result, `${current}${char}`, depth);\n            case '(':\n                return splitParameters(tail, result, `${current}${char}`, depth + 1);\n            case ')':\n                return splitParameters(tail, result, `${current}${char}`, depth - 1);\n            default:\n                return splitParameters(tail, result, `${current}${char}`, depth);\n        }\n    }\n    if (current === '')\n        return result;\n    if (depth !== 0)\n        throw new InvalidParenthesisError({ current, depth });\n    result.push(current.trim());\n    return result;\n}\nexport function isSolidityType(type) {\n    return (type === 'address' ||\n        type === 'bool' ||\n        type === 'function' ||\n        type === 'string' ||\n        bytesRegex.test(type) ||\n        integerRegex.test(type));\n}\nconst protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;\n/** @internal */\nexport function isSolidityKeyword(name) {\n    return (name === 'address' ||\n        name === 'bool' ||\n        name === 'function' ||\n        name === 'string' ||\n        name === 'tuple' ||\n        bytesRegex.test(name) ||\n        integerRegex.test(name) ||\n        protectedKeywordsRegex.test(name));\n}\n/** @internal */\nexport function isValidDataLocation(type, isArray) {\n    return isArray || type === 'bytes' || type === 'string' || type === 'tuple';\n}\n//# sourceMappingURL=utils.js.map"],"names":["parseSignature","signature","structs","isFunctionSignature","parseFunctionSignature","isEventSignature","parseEventSignature","isErrorSignature","parseErrorSignature","isConstructorSignature","parseConstructorSignature","isFallbackSignature","parseFallbackSignature","isReceiveSignature","type","stateMutability","UnknownSignatureError","match","execFunctionSignature","InvalidSignatureError","inputParams","splitParameters","parameters","inputs","inputLength","length","i","push","parseAbiParameter","modifiers","functionModifiers","outputs","returns","outputParams","outputLength","name","execEventSignature","params","abiParameters","eventModifiers","execErrorSignature","execConstructorSignature","execFallbackSignature","abiParameterWithoutTupleRegex","abiParameterWithTupleRegex","dynamicIntegerRegex","param","options","parameterCacheKey","getParameterCacheKey","parameterCache","has","get","isTuple","isTupleRegex","test","execTyped","InvalidParameterError","isSolidityKeyword","SolidityProtectedKeywordError","indexed","modifier","components","components_","isSolidityType","UnknownSolidityTypeError","InvalidModifierError","isValidDataLocation","array","InvalidFunctionModifierError","abiParameter","set","result","current","depth","trim","char","tail","slice","InvalidParenthesisError","bytesRegex","integerRegex","protectedKeywordsRegex","isArray"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/regex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex.js","sources":["../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/regex.js"],"sourcesContent":["// TODO: This looks cool. Need to check the performance of `new RegExp` versus defined inline though.\n// https://twitter.com/GabrielVergnaud/status/1622906834343366657\nexport function execTyped(regex, string) {\n    const match = regex.exec(string);\n    return match?.groups;\n}\n// `bytes<M>`: binary type of `M` bytes, `0 < M <= 32`\n// https://regexr.com/6va55\nexport const bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;\n// `(u)int<M>`: (un)signed integer type of `M` bits, `0 < M <= 256`, `M % 8 == 0`\n// https://regexr.com/6v8hp\nexport const integerRegex = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;\nexport const isTupleRegex = /^\\(.+?\\).*?$/;\n//# sourceMappingURL=regex.js.map"],"names":["execTyped","regex","string","match","exec","groups","bytesRegex","integerRegex","isTupleRegex"],"mappings":"AAEO,SAASA,EAAUC,EAAOC,GAC7B,MAAMC,EAAQF,EAAMG,KAAKF,GACzB,OAAOC,GAAOE,MAClB,CAGY,MAACC,EAAa,uCAGbC,EAAe,+HACfC,EAAe","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sources":["../../../../../../../../../node_modules/.pnpm/abitype@1.1.0_typescript@5.9.2/node_modules/abitype/dist/esm/version.js"],"sourcesContent":["export const version = '1.1.0';\n//# sourceMappingURL=version.js.map"],"names":["version"],"mappings":"AAAY,MAACA,EAAU","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ethers@6.15.0_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/_version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_version.js","sources":["../../../../../../../../node_modules/.pnpm/ethers@6.15.0_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/_version.js"],"sourcesContent":["/* Do NOT modify this file; see /src.ts/_admin/update-version.ts */\n/**\n *  The current version of Ethers.\n */\nexport const version = \"6.15.0\";\n//# sourceMappingURL=_version.js.map"],"names":["version"],"mappings":"AAIY,MAACA,EAAU","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ethers@6.15.0_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/utils/data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.js","sources":["../../../../../../../../../node_modules/.pnpm/ethers@6.15.0_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/utils/data.js"],"sourcesContent":["/**\n *  Some data helpers.\n *\n *\n *  @_subsection api/utils:Data Helpers  [about-data]\n */\nimport { assert, assertArgument } from \"./errors.js\";\nfunction _getBytes(value, name, copy) {\n    if (value instanceof Uint8Array) {\n        if (copy) {\n            return new Uint8Array(value);\n        }\n        return value;\n    }\n    if (typeof (value) === \"string\" && value.match(/^0x(?:[0-9a-f][0-9a-f])*$/i)) {\n        const result = new Uint8Array((value.length - 2) / 2);\n        let offset = 2;\n        for (let i = 0; i < result.length; i++) {\n            result[i] = parseInt(value.substring(offset, offset + 2), 16);\n            offset += 2;\n        }\n        return result;\n    }\n    assertArgument(false, \"invalid BytesLike value\", name || \"value\", value);\n}\n/**\n *  Get a typed Uint8Array for %%value%%. If already a Uint8Array\n *  the original %%value%% is returned; if a copy is required use\n *  [[getBytesCopy]].\n *\n *  @see: getBytesCopy\n */\nexport function getBytes(value, name) {\n    return _getBytes(value, name, false);\n}\n/**\n *  Get a typed Uint8Array for %%value%%, creating a copy if necessary\n *  to prevent any modifications of the returned value from being\n *  reflected elsewhere.\n *\n *  @see: getBytes\n */\nexport function getBytesCopy(value, name) {\n    return _getBytes(value, name, true);\n}\n/**\n *  Returns true if %%value%% is a valid [[HexString]].\n *\n *  If %%length%% is ``true`` or a //number//, it also checks that\n *  %%value%% is a valid [[DataHexString]] of %%length%% (if a //number//)\n *  bytes of data (e.g. ``0x1234`` is 2 bytes).\n */\nexport function isHexString(value, length) {\n    if (typeof (value) !== \"string\" || !value.match(/^0x[0-9A-Fa-f]*$/)) {\n        return false;\n    }\n    if (typeof (length) === \"number\" && value.length !== 2 + 2 * length) {\n        return false;\n    }\n    if (length === true && (value.length % 2) !== 0) {\n        return false;\n    }\n    return true;\n}\n/**\n *  Returns true if %%value%% is a valid representation of arbitrary\n *  data (i.e. a valid [[DataHexString]] or a Uint8Array).\n */\nexport function isBytesLike(value) {\n    return (isHexString(value, true) || (value instanceof Uint8Array));\n}\nconst HexCharacters = \"0123456789abcdef\";\n/**\n *  Returns a [[DataHexString]] representation of %%data%%.\n */\nexport function hexlify(data) {\n    const bytes = getBytes(data);\n    let result = \"0x\";\n    for (let i = 0; i < bytes.length; i++) {\n        const v = bytes[i];\n        result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];\n    }\n    return result;\n}\n/**\n *  Returns a [[DataHexString]] by concatenating all values\n *  within %%data%%.\n */\nexport function concat(datas) {\n    return \"0x\" + datas.map((d) => hexlify(d).substring(2)).join(\"\");\n}\n/**\n *  Returns the length of %%data%%, in bytes.\n */\nexport function dataLength(data) {\n    if (isHexString(data, true)) {\n        return (data.length - 2) / 2;\n    }\n    return getBytes(data).length;\n}\n/**\n *  Returns a [[DataHexString]] by slicing %%data%% from the %%start%%\n *  offset to the %%end%% offset.\n *\n *  By default %%start%% is 0 and %%end%% is the length of %%data%%.\n */\nexport function dataSlice(data, start, end) {\n    const bytes = getBytes(data);\n    if (end != null && end > bytes.length) {\n        assert(false, \"cannot slice beyond data bounds\", \"BUFFER_OVERRUN\", {\n            buffer: bytes, length: bytes.length, offset: end\n        });\n    }\n    return hexlify(bytes.slice((start == null) ? 0 : start, (end == null) ? bytes.length : end));\n}\n/**\n *  Return the [[DataHexString]] result by stripping all **leading**\n ** zero bytes from %%data%%.\n */\nexport function stripZerosLeft(data) {\n    let bytes = hexlify(data).substring(2);\n    while (bytes.startsWith(\"00\")) {\n        bytes = bytes.substring(2);\n    }\n    return \"0x\" + bytes;\n}\nfunction zeroPad(data, length, left) {\n    const bytes = getBytes(data);\n    assert(length >= bytes.length, \"padding exceeds data length\", \"BUFFER_OVERRUN\", {\n        buffer: new Uint8Array(bytes),\n        length: length,\n        offset: length + 1\n    });\n    const result = new Uint8Array(length);\n    result.fill(0);\n    if (left) {\n        result.set(bytes, length - bytes.length);\n    }\n    else {\n        result.set(bytes, 0);\n    }\n    return hexlify(result);\n}\n/**\n *  Return the [[DataHexString]] of %%data%% padded on the **left**\n *  to %%length%% bytes.\n *\n *  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is\n *  thrown.\n *\n *  This pads data the same as **values** are in Solidity\n *  (e.g. ``uint128``).\n */\nexport function zeroPadValue(data, length) {\n    return zeroPad(data, length, true);\n}\n/**\n *  Return the [[DataHexString]] of %%data%% padded on the **right**\n *  to %%length%% bytes.\n *\n *  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is\n *  thrown.\n *\n *  This pads data the same as **bytes** are in Solidity\n *  (e.g. ``bytes16``).\n */\nexport function zeroPadBytes(data, length) {\n    return zeroPad(data, length, false);\n}\n//# sourceMappingURL=data.js.map"],"names":["getBytes","value","name","Uint8Array","match","result","length","offset","i","parseInt","substring","assertArgument","_getBytes"],"mappings":"6CAgCO,SAASA,EAASC,EAAOC,GAC5B,OA1BJ,SAAmBD,EAAOC,GACtB,GAAID,aAAiBE,WAIjB,OAAOF,EAEX,GAAuB,iBAAnB,GAA+BA,EAAMG,MAAM,8BAA+B,CAC1E,MAAMC,EAAS,IAAIF,YAAYF,EAAMK,OAAS,GAAK,GACnD,IAAIC,EAAS,EACb,IAAK,IAAIC,EAAI,EAAGA,EAAIH,EAAOC,OAAQE,IAC/BH,EAAOG,GAAKC,SAASR,EAAMS,UAAUH,EAAQA,EAAS,GAAI,IAC1DA,GAAU,EAEd,OAAOF,CACX,CACAM,GAAe,EAAO,0BAA2BT,EAAiBD,EACtE,CASWW,CAAUX,EAAOC,EAC5B","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ethers@6.15.0_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/utils/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sources":["../../../../../../../../../node_modules/.pnpm/ethers@6.15.0_bufferutil@4.0.9_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/utils/errors.js"],"sourcesContent":["/**\n *  All errors in ethers include properties to ensure they are both\n *  human-readable (i.e. ``.message``) and machine-readable (i.e. ``.code``).\n *\n *  The [[isError]] function can be used to check the error ``code`` and\n *  provide a type guard for the properties present on that error interface.\n *\n *  @_section: api/utils/errors:Errors  [about-errors]\n */\nimport { version } from \"../_version.js\";\nimport { defineProperties } from \"./properties.js\";\nfunction stringify(value, seen) {\n    if (value == null) {\n        return \"null\";\n    }\n    if (seen == null) {\n        seen = new Set();\n    }\n    if (typeof (value) === \"object\") {\n        if (seen.has(value)) {\n            return \"[Circular]\";\n        }\n        seen.add(value);\n    }\n    if (Array.isArray(value)) {\n        return \"[ \" + (value.map((v) => stringify(v, seen))).join(\", \") + \" ]\";\n    }\n    if (value instanceof Uint8Array) {\n        const HEX = \"0123456789abcdef\";\n        let result = \"0x\";\n        for (let i = 0; i < value.length; i++) {\n            result += HEX[value[i] >> 4];\n            result += HEX[value[i] & 0xf];\n        }\n        return result;\n    }\n    if (typeof (value) === \"object\" && typeof (value.toJSON) === \"function\") {\n        return stringify(value.toJSON(), seen);\n    }\n    switch (typeof (value)) {\n        case \"boolean\":\n        case \"number\":\n        case \"symbol\":\n            return value.toString();\n        case \"bigint\":\n            return BigInt(value).toString();\n        case \"string\":\n            return JSON.stringify(value);\n        case \"object\": {\n            const keys = Object.keys(value);\n            keys.sort();\n            return \"{ \" + keys.map((k) => `${stringify(k, seen)}: ${stringify(value[k], seen)}`).join(\", \") + \" }\";\n        }\n    }\n    return `[ COULD NOT SERIALIZE ]`;\n}\n/**\n *  Returns true if the %%error%% matches an error thrown by ethers\n *  that matches the error %%code%%.\n *\n *  In TypeScript environments, this can be used to check that %%error%%\n *  matches an EthersError type, which means the expected properties will\n *  be set.\n *\n *  @See [ErrorCodes](api:ErrorCode)\n *  @example\n *    try {\n *      // code....\n *    } catch (e) {\n *      if (isError(e, \"CALL_EXCEPTION\")) {\n *          // The Type Guard has validated this object\n *          console.log(e.data);\n *      }\n *    }\n */\nexport function isError(error, code) {\n    return (error && error.code === code);\n}\n/**\n *  Returns true if %%error%% is a [[CallExceptionError].\n */\nexport function isCallException(error) {\n    return isError(error, \"CALL_EXCEPTION\");\n}\n/**\n *  Returns a new Error configured to the format ethers emits errors, with\n *  the %%message%%, [[api:ErrorCode]] %%code%% and additional properties\n *  for the corresponding EthersError.\n *\n *  Each error in ethers includes the version of ethers, a\n *  machine-readable [[ErrorCode]], and depending on %%code%%, additional\n *  required properties. The error message will also include the %%message%%,\n *  ethers version, %%code%% and all additional properties, serialized.\n */\nexport function makeError(message, code, info) {\n    let shortMessage = message;\n    {\n        const details = [];\n        if (info) {\n            if (\"message\" in info || \"code\" in info || \"name\" in info) {\n                throw new Error(`value will overwrite populated values: ${stringify(info)}`);\n            }\n            for (const key in info) {\n                if (key === \"shortMessage\") {\n                    continue;\n                }\n                const value = (info[key]);\n                //                try {\n                details.push(key + \"=\" + stringify(value));\n                //                } catch (error: any) {\n                //                console.log(\"MMM\", error.message);\n                //                    details.push(key + \"=[could not serialize object]\");\n                //                }\n            }\n        }\n        details.push(`code=${code}`);\n        details.push(`version=${version}`);\n        if (details.length) {\n            message += \" (\" + details.join(\", \") + \")\";\n        }\n    }\n    let error;\n    switch (code) {\n        case \"INVALID_ARGUMENT\":\n            error = new TypeError(message);\n            break;\n        case \"NUMERIC_FAULT\":\n        case \"BUFFER_OVERRUN\":\n            error = new RangeError(message);\n            break;\n        default:\n            error = new Error(message);\n    }\n    defineProperties(error, { code });\n    if (info) {\n        Object.assign(error, info);\n    }\n    if (error.shortMessage == null) {\n        defineProperties(error, { shortMessage });\n    }\n    return error;\n}\n/**\n *  Throws an EthersError with %%message%%, %%code%% and additional error\n *  %%info%% when %%check%% is falsish..\n *\n *  @see [[api:makeError]]\n */\nexport function assert(check, message, code, info) {\n    if (!check) {\n        throw makeError(message, code, info);\n    }\n}\n/**\n *  A simple helper to simply ensuring provided arguments match expected\n *  constraints, throwing if not.\n *\n *  In TypeScript environments, the %%check%% has been asserted true, so\n *  any further code does not need additional compile-time checks.\n */\nexport function assertArgument(check, message, name, value) {\n    assert(check, message, \"INVALID_ARGUMENT\", { argument: name, value: value });\n}\nexport function assertArgumentCount(count, expectedCount, message) {\n    if (message == null) {\n        message = \"\";\n    }\n    if (message) {\n        message = \": \" + message;\n    }\n    assert(count >= expectedCount, \"missing argument\" + message, \"MISSING_ARGUMENT\", {\n        count: count,\n        expectedCount: expectedCount\n    });\n    assert(count <= expectedCount, \"too many arguments\" + message, \"UNEXPECTED_ARGUMENT\", {\n        count: count,\n        expectedCount: expectedCount\n    });\n}\nconst _normalizeForms = [\"NFD\", \"NFC\", \"NFKD\", \"NFKC\"].reduce((accum, form) => {\n    try {\n        // General test for normalize\n        /* c8 ignore start */\n        if (\"test\".normalize(form) !== \"test\") {\n            throw new Error(\"bad\");\n        }\n        ;\n        /* c8 ignore stop */\n        if (form === \"NFD\") {\n            const check = String.fromCharCode(0xe9).normalize(\"NFD\");\n            const expected = String.fromCharCode(0x65, 0x0301);\n            /* c8 ignore start */\n            if (check !== expected) {\n                throw new Error(\"broken\");\n            }\n            /* c8 ignore stop */\n        }\n        accum.push(form);\n    }\n    catch (error) { }\n    return accum;\n}, []);\n/**\n *  Throws if the normalization %%form%% is not supported.\n */\nexport function assertNormalize(form) {\n    assert(_normalizeForms.indexOf(form) >= 0, \"platform missing String.prototype.normalize\", \"UNSUPPORTED_OPERATION\", {\n        operation: \"String.prototype.normalize\", info: { form }\n    });\n}\n/**\n *  Many classes use file-scoped values to guard the constructor,\n *  making it effectively private. This facilitates that pattern\n *  by ensuring the %%givenGaurd%% matches the file-scoped %%guard%%,\n *  throwing if not, indicating the %%className%% if provided.\n */\nexport function assertPrivate(givenGuard, guard, className) {\n    if (className == null) {\n        className = \"\";\n    }\n    if (givenGuard !== guard) {\n        let method = className, operation = \"new\";\n        if (className) {\n            method += \".\";\n            operation += \" \" + className;\n        }\n        assert(false, `private constructor; use ${method}from* methods`, \"UNSUPPORTED_OPERATION\", {\n            operation\n        });\n    }\n}\n//# sourceMappingURL=errors.js.map"],"names":["stringify","value","seen","Set","has","add","Array","isArray","map","v","join","Uint8Array","HEX","result","i","length","toJSON","toString","BigInt","JSON","keys","Object","sort","k","makeError","message","code","info","error","shortMessage","details","Error","key","push","version","TypeError","RangeError","defineProperties","assign","assert","check","assertArgument","name","argument","assertPrivate","givenGuard","guard","className","method","operation","reduce","accum","form","normalize","String","fromCharCode"],"mappings":"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","x_google_ignoreList":[0]}