@bonfida/spl-name-service 3.0.13 → 3.0.15

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

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

package/dist/esm/node_modules/@noble/hashes/esm/_u64.js

@@ -0,0 +1,2 @@
+const n=BigInt(2**32-1),t=BigInt(32);function r(r,e=!1){return e?{h:Number(r&n),l:Number(r>>t&n)}:{h:0|Number(r>>t&n),l:0|Number(r&n)}}function e(n,t=!1){const e=n.length;let o=new Uint32Array(e),u=new Uint32Array(e);for(let c=0;c<e;c++){const{h:e,l:i}=r(n[c],t);[o[c],u[c]]=[e,i]}return[o,u]}const o=(n,t,r)=>n>>>r,u=(n,t,r)=>n<<32-r|t>>>r,c=(n,t,r)=>n>>>r|t<<32-r,i=(n,t,r)=>n<<32-r|t>>>r,l=(n,t,r)=>n<<64-r|t>>>r-32,s=(n,t,r)=>n>>>r-32|t<<64-r;function h(n,t,r,e){const o=(t>>>0)+(e>>>0);return{h:n+r+(o/2**32|0)|0,l:0|o}}const b=(n,t,r)=>(n>>>0)+(t>>>0)+(r>>>0),f=(n,t,r,e)=>t+r+e+(n/2**32|0)|0,m=(n,t,r,e)=>(n>>>0)+(t>>>0)+(r>>>0)+(e>>>0),N=(n,t,r,e,o)=>t+r+e+o+(n/2**32|0)|0,g=(n,t,r,e,o)=>(n>>>0)+(t>>>0)+(r>>>0)+(e>>>0)+(o>>>0),a=(n,t,r,e,o,u)=>t+r+e+o+u+(n/2**32|0)|0;export{h as add,f as add3H,b as add3L,N as add4H,m as add4L,a as add5H,g as add5L,r as fromBig,l as rotrBH,s as rotrBL,c as rotrSH,i as rotrSL,o as shrSH,u as shrSL,e as split};
+//# sourceMappingURL=_u64.js.map

package/dist/esm/node_modules/@noble/hashes/esm/_u64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_u64.js","sources":["../../../../../../node_modules/@noble/hashes/esm/_u64.js"],"sourcesContent":["/**\n * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.\n * @todo re-check https://issues.chromium.org/issues/42212588\n * @module\n */\nconst U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);\nconst _32n = /* @__PURE__ */ BigInt(32);\nfunction fromBig(n, le = false) {\n    if (le)\n        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };\n    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };\n}\nfunction split(lst, le = false) {\n    const len = lst.length;\n    let Ah = new Uint32Array(len);\n    let Al = new Uint32Array(len);\n    for (let i = 0; i < len; i++) {\n        const { h, l } = fromBig(lst[i], le);\n        [Ah[i], Al[i]] = [h, l];\n    }\n    return [Ah, Al];\n}\nconst toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);\n// for Shift in [0, 32)\nconst shrSH = (h, _l, s) => h >>> s;\nconst shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in [1, 32)\nconst rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));\nconst rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));\nconst rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));\n// Right rotate for shift===32 (just swaps l&h)\nconst rotr32H = (_h, l) => l;\nconst rotr32L = (h, _l) => h;\n// Left rotate for Shift in [1, 32)\nconst rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));\nconst rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));\n// Left rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));\nconst rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));\n// JS uses 32-bit signed integers for bitwise operations which means we cannot\n// simple take carry out of low bit sum by shift, we need to use division.\nfunction add(Ah, Al, Bh, Bl) {\n    const l = (Al >>> 0) + (Bl >>> 0);\n    return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };\n}\n// Addition with more than 2 elements\nconst add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);\nconst add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;\nconst add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);\nconst add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;\nconst add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);\nconst add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;\n// prettier-ignore\nexport { add, add3H, add3L, add4H, add4L, add5H, add5L, fromBig, rotlBH, rotlBL, rotlSH, rotlSL, rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL, shrSH, shrSL, split, toBig };\n// prettier-ignore\nconst u64 = {\n    fromBig, split, toBig,\n    shrSH, shrSL,\n    rotrSH, rotrSL, rotrBH, rotrBL,\n    rotr32H, rotr32L,\n    rotlSH, rotlSL, rotlBH, rotlBL,\n    add, add3L, add3H, add4L, add4H, add5H, add5L,\n};\nexport default u64;\n//# sourceMappingURL=_u64.js.map"],"names":["U32_MASK64","BigInt","_32n","fromBig","n","le","h","Number","l","split","lst","len","length","Ah","Uint32Array","Al","i","shrSH","_l","s","shrSL","rotrSH","rotrSL","rotrBH","rotrBL","add","Bh","Bl","add3L","Cl","add3H","low","Ch","add4L","Dl","add4H","Dh","add5L","El","add5H","Eh"],"mappings":"AAKA,MAAMA,EAA6BC,OAAO,GAAK,GAAK,GAC9CC,EAAuBD,OAAO,IAEpC,SAASE,EACPC,EACAC,GAAK,GAKL,OAAIA,EAAW,CAAEC,EAAGC,OAAOH,EAAIJ,GAAaQ,EAAGD,OAAQH,GAAKF,EAAQF,IAC7D,CAAEM,EAAsC,EAAnCC,OAAQH,GAAKF,EAAQF,GAAiBQ,EAA4B,EAAzBD,OAAOH,EAAIJ,GAClE,CAEA,SAASS,EAAMC,EAAeL,GAAK,GACjC,MAAMM,EAAMD,EAAIE,OAChB,IAAIC,EAAK,IAAIC,YAAYH,GACrBI,EAAK,IAAID,YAAYH,GACzB,IAAK,IAAIK,EAAI,EAAGA,EAAIL,EAAKK,IAAK,CAC5B,MAAMV,EAAEA,EAACE,EAAEA,GAAML,EAAQO,EAAIM,GAAIX,IAChCQ,EAAGG,GAAID,EAAGC,IAAM,CAACV,EAAGE,EACvB,CACA,MAAO,CAACK,EAAIE,EACd,CAIME,MAAAA,EAAQA,CAACX,EAAWY,EAAYC,IAAsBb,IAAMa,EAC5DC,EAAQA,CAACd,EAAWE,EAAWW,IAAuBb,GAAM,GAAKa,EAAOX,IAAMW,EAE9EE,EAASA,CAACf,EAAWE,EAAWW,IAAuBb,IAAMa,EAAMX,GAAM,GAAKW,EAC9EG,EAASA,CAAChB,EAAWE,EAAWW,IAAuBb,GAAM,GAAKa,EAAOX,IAAMW,EAE/EI,EAASA,CAACjB,EAAWE,EAAWW,IAAuBb,GAAM,GAAKa,EAAOX,IAAOW,EAAI,GACpFK,EAASA,CAAClB,EAAWE,EAAWW,IAAuBb,IAAOa,EAAI,GAAQX,GAAM,GAAKW,EAa3F,SAASM,EACPZ,EACAE,EACAW,EACAC,GAKA,MAAMnB,GAAKO,IAAO,IAAMY,IAAO,GAC/B,MAAO,CAAErB,EAAIO,EAAKa,GAAOlB,EAAI,GAAK,GAAM,GAAM,EAAGA,EAAO,EAAJA,EACtD,CAEMoB,MAAAA,EAAQA,CAACb,EAAYY,EAAYE,KAAwBd,IAAO,IAAMY,IAAO,IAAME,IAAO,GAC1FC,EAAQA,CAACC,EAAalB,EAAYa,EAAYM,IACjDnB,EAAKa,EAAKM,GAAOD,EAAM,GAAK,GAAM,GAAM,EACrCE,EAAQA,CAAClB,EAAYY,EAAYE,EAAYK,KAChDnB,IAAO,IAAMY,IAAO,IAAME,IAAO,IAAMK,IAAO,GAC3CC,EAAQA,CAACJ,EAAalB,EAAYa,EAAYM,EAAYI,IAC7DvB,EAAKa,EAAKM,EAAKI,GAAOL,EAAM,GAAK,GAAM,GAAM,EAC1CM,EAAQA,CAACtB,EAAYY,EAAYE,EAAYK,EAAYI,KAC5DvB,IAAO,IAAMY,IAAO,IAAME,IAAO,IAAMK,IAAO,IAAMI,IAAO,GACxDC,EAAQA,CAACR,EAAalB,EAAYa,EAAYM,EAAYI,EAAYI,IACzE3B,EAAKa,EAAKM,EAAKI,EAAKI,GAAOT,EAAM,GAAK,GAAM,GAAM","x_google_ignoreList":[0]}

package/dist/esm/node_modules/@noble/hashes/esm/crypto.js

@@ -0,0 +1,2 @@
+const o="object"==typeof globalThis&&"crypto"in globalThis?globalThis.crypto:void 0;export{o as crypto};
+//# sourceMappingURL=crypto.js.map

package/dist/esm/node_modules/@noble/hashes/esm/crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.js","sources":["../../../../../../node_modules/@noble/hashes/esm/crypto.js"],"sourcesContent":["export const crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;\n//# sourceMappingURL=crypto.js.map"],"names":["crypto","globalThis","undefined"],"mappings":"MAOaA,EACW,iBAAfC,YAA2B,WAAYA,WAAaA,WAAWD,YAASE","x_google_ignoreList":[0]}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"sha2.js","sources":["../../../../../../node_modules/@noble/hashes/esm/sha2.js"],"sourcesContent":["/**\n * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.\n * SHA256 is the fastest hash implementable in JS, even faster than Blake3.\n * Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and\n * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).\n * @module\n */\nimport { Chi, HashMD, Maj, SHA224_IV, SHA256_IV, SHA384_IV, SHA512_IV } from \"./_md.js\";\nimport * as u64 from \"./_u64.js\";\nimport { clean, createHasher, rotr } from \"./utils.js\";\n/**\n * Round constants:\n * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)\n */\n// prettier-ignore\nconst SHA256_K = /* @__PURE__ */ Uint32Array.from([\n    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\n/** Reusable temporary buffer. \"W\" comes straight from spec. */\nconst SHA256_W = /* @__PURE__ */ new Uint32Array(64);\nexport class SHA256 extends HashMD {\n    constructor(outputLen = 32) {\n        super(64, outputLen, 8, false);\n        // We cannot use array here since array allows indexing by variable\n        // which means optimizer/compiler cannot use registers.\n        this.A = SHA256_IV[0] | 0;\n        this.B = SHA256_IV[1] | 0;\n        this.C = SHA256_IV[2] | 0;\n        this.D = SHA256_IV[3] | 0;\n        this.E = SHA256_IV[4] | 0;\n        this.F = SHA256_IV[5] | 0;\n        this.G = SHA256_IV[6] | 0;\n        this.H = SHA256_IV[7] | 0;\n    }\n    get() {\n        const { A, B, C, D, E, F, G, H } = this;\n        return [A, B, C, D, E, F, G, H];\n    }\n    // prettier-ignore\n    set(A, B, C, D, E, F, G, H) {\n        this.A = A | 0;\n        this.B = B | 0;\n        this.C = C | 0;\n        this.D = D | 0;\n        this.E = E | 0;\n        this.F = F | 0;\n        this.G = G | 0;\n        this.H = H | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4)\n            SHA256_W[i] = view.getUint32(offset, false);\n        for (let i = 16; i < 64; i++) {\n            const W15 = SHA256_W[i - 15];\n            const W2 = SHA256_W[i - 2];\n            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);\n            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);\n            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;\n        }\n        // Compression function main loop, 64 rounds\n        let { A, B, C, D, E, F, G, H } = this;\n        for (let i = 0; i < 64; i++) {\n            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);\n            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);\n            const T2 = (sigma0 + Maj(A, B, C)) | 0;\n            H = G;\n            G = F;\n            F = E;\n            E = (D + T1) | 0;\n            D = C;\n            C = B;\n            B = A;\n            A = (T1 + T2) | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        A = (A + this.A) | 0;\n        B = (B + this.B) | 0;\n        C = (C + this.C) | 0;\n        D = (D + this.D) | 0;\n        E = (E + this.E) | 0;\n        F = (F + this.F) | 0;\n        G = (G + this.G) | 0;\n        H = (H + this.H) | 0;\n        this.set(A, B, C, D, E, F, G, H);\n    }\n    roundClean() {\n        clean(SHA256_W);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n        clean(this.buffer);\n    }\n}\nexport class SHA224 extends SHA256 {\n    constructor() {\n        super(28);\n        this.A = SHA224_IV[0] | 0;\n        this.B = SHA224_IV[1] | 0;\n        this.C = SHA224_IV[2] | 0;\n        this.D = SHA224_IV[3] | 0;\n        this.E = SHA224_IV[4] | 0;\n        this.F = SHA224_IV[5] | 0;\n        this.G = SHA224_IV[6] | 0;\n        this.H = SHA224_IV[7] | 0;\n    }\n}\n// SHA2-512 is slower than sha256 in js because u64 operations are slow.\n// Round contants\n// First 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409\n// prettier-ignore\nconst K512 = /* @__PURE__ */ (() => u64.split([\n    '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',\n    '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',\n    '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',\n    '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',\n    '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',\n    '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',\n    '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',\n    '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',\n    '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',\n    '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',\n    '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',\n    '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',\n    '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',\n    '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',\n    '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',\n    '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',\n    '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',\n    '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',\n    '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',\n    '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'\n].map(n => BigInt(n))))();\nconst SHA512_Kh = /* @__PURE__ */ (() => K512[0])();\nconst SHA512_Kl = /* @__PURE__ */ (() => K512[1])();\n// Reusable temporary buffers\nconst SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);\nconst SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);\nexport class SHA512 extends HashMD {\n    constructor(outputLen = 64) {\n        super(128, outputLen, 16, false);\n        // We cannot use array here since array allows indexing by variable\n        // which means optimizer/compiler cannot use registers.\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = SHA512_IV[0] | 0;\n        this.Al = SHA512_IV[1] | 0;\n        this.Bh = SHA512_IV[2] | 0;\n        this.Bl = SHA512_IV[3] | 0;\n        this.Ch = SHA512_IV[4] | 0;\n        this.Cl = SHA512_IV[5] | 0;\n        this.Dh = SHA512_IV[6] | 0;\n        this.Dl = SHA512_IV[7] | 0;\n        this.Eh = SHA512_IV[8] | 0;\n        this.El = SHA512_IV[9] | 0;\n        this.Fh = SHA512_IV[10] | 0;\n        this.Fl = SHA512_IV[11] | 0;\n        this.Gh = SHA512_IV[12] | 0;\n        this.Gl = SHA512_IV[13] | 0;\n        this.Hh = SHA512_IV[14] | 0;\n        this.Hl = SHA512_IV[15] | 0;\n    }\n    // prettier-ignore\n    get() {\n        const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];\n    }\n    // prettier-ignore\n    set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {\n        this.Ah = Ah | 0;\n        this.Al = Al | 0;\n        this.Bh = Bh | 0;\n        this.Bl = Bl | 0;\n        this.Ch = Ch | 0;\n        this.Cl = Cl | 0;\n        this.Dh = Dh | 0;\n        this.Dl = Dl | 0;\n        this.Eh = Eh | 0;\n        this.El = El | 0;\n        this.Fh = Fh | 0;\n        this.Fl = Fl | 0;\n        this.Gh = Gh | 0;\n        this.Gl = Gl | 0;\n        this.Hh = Hh | 0;\n        this.Hl = Hl | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4) {\n            SHA512_W_H[i] = view.getUint32(offset);\n            SHA512_W_L[i] = view.getUint32((offset += 4));\n        }\n        for (let i = 16; i < 80; i++) {\n            // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)\n            const W15h = SHA512_W_H[i - 15] | 0;\n            const W15l = SHA512_W_L[i - 15] | 0;\n            const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);\n            const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);\n            // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)\n            const W2h = SHA512_W_H[i - 2] | 0;\n            const W2l = SHA512_W_L[i - 2] | 0;\n            const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);\n            const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);\n            // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];\n            const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\n            const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);\n            SHA512_W_H[i] = SUMh | 0;\n            SHA512_W_L[i] = SUMl | 0;\n        }\n        let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        // Compression function main loop, 80 rounds\n        for (let i = 0; i < 80; i++) {\n            // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)\n            const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);\n            const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);\n            //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const CHIh = (Eh & Fh) ^ (~Eh & Gh);\n            const CHIl = (El & Fl) ^ (~El & Gl);\n            // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]\n            // prettier-ignore\n            const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\n            const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);\n            const T1l = T1ll | 0;\n            // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)\n            const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);\n            const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);\n            const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);\n            const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);\n            Hh = Gh | 0;\n            Hl = Gl | 0;\n            Gh = Fh | 0;\n            Gl = Fl | 0;\n            Fh = Eh | 0;\n            Fl = El | 0;\n            ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));\n            Dh = Ch | 0;\n            Dl = Cl | 0;\n            Ch = Bh | 0;\n            Cl = Bl | 0;\n            Bh = Ah | 0;\n            Bl = Al | 0;\n            const All = u64.add3L(T1l, sigma0l, MAJl);\n            Ah = u64.add3H(All, T1h, sigma0h, MAJh);\n            Al = All | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));\n        ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));\n        ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));\n        ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));\n        ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));\n        ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));\n        ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));\n        ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));\n        this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);\n    }\n    roundClean() {\n        clean(SHA512_W_H, SHA512_W_L);\n    }\n    destroy() {\n        clean(this.buffer);\n        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n    }\n}\nexport class SHA384 extends SHA512 {\n    constructor() {\n        super(48);\n        this.Ah = SHA384_IV[0] | 0;\n        this.Al = SHA384_IV[1] | 0;\n        this.Bh = SHA384_IV[2] | 0;\n        this.Bl = SHA384_IV[3] | 0;\n        this.Ch = SHA384_IV[4] | 0;\n        this.Cl = SHA384_IV[5] | 0;\n        this.Dh = SHA384_IV[6] | 0;\n        this.Dl = SHA384_IV[7] | 0;\n        this.Eh = SHA384_IV[8] | 0;\n        this.El = SHA384_IV[9] | 0;\n        this.Fh = SHA384_IV[10] | 0;\n        this.Fl = SHA384_IV[11] | 0;\n        this.Gh = SHA384_IV[12] | 0;\n        this.Gl = SHA384_IV[13] | 0;\n        this.Hh = SHA384_IV[14] | 0;\n        this.Hl = SHA384_IV[15] | 0;\n    }\n}\n/**\n * Truncated SHA512/256 and SHA512/224.\n * SHA512_IV is XORed with 0xa5a5a5a5a5a5a5a5, then used as \"intermediary\" IV of SHA512/t.\n * Then t hashes string to produce result IV.\n * See `test/misc/sha2-gen-iv.js`.\n */\n/** SHA512/224 IV */\nconst T224_IV = /* @__PURE__ */ Uint32Array.from([\n    0x8c3d37c8, 0x19544da2, 0x73e19966, 0x89dcd4d6, 0x1dfab7ae, 0x32ff9c82, 0x679dd514, 0x582f9fcf,\n    0x0f6d2b69, 0x7bd44da8, 0x77e36f73, 0x04c48942, 0x3f9d85a8, 0x6a1d36c8, 0x1112e6ad, 0x91d692a1,\n]);\n/** SHA512/256 IV */\nconst T256_IV = /* @__PURE__ */ Uint32Array.from([\n    0x22312194, 0xfc2bf72c, 0x9f555fa3, 0xc84c64c2, 0x2393b86b, 0x6f53b151, 0x96387719, 0x5940eabd,\n    0x96283ee2, 0xa88effe3, 0xbe5e1e25, 0x53863992, 0x2b0199fc, 0x2c85b8aa, 0x0eb72ddc, 0x81c52ca2,\n]);\nexport class SHA512_224 extends SHA512 {\n    constructor() {\n        super(28);\n        this.Ah = T224_IV[0] | 0;\n        this.Al = T224_IV[1] | 0;\n        this.Bh = T224_IV[2] | 0;\n        this.Bl = T224_IV[3] | 0;\n        this.Ch = T224_IV[4] | 0;\n        this.Cl = T224_IV[5] | 0;\n        this.Dh = T224_IV[6] | 0;\n        this.Dl = T224_IV[7] | 0;\n        this.Eh = T224_IV[8] | 0;\n        this.El = T224_IV[9] | 0;\n        this.Fh = T224_IV[10] | 0;\n        this.Fl = T224_IV[11] | 0;\n        this.Gh = T224_IV[12] | 0;\n        this.Gl = T224_IV[13] | 0;\n        this.Hh = T224_IV[14] | 0;\n        this.Hl = T224_IV[15] | 0;\n    }\n}\nexport class SHA512_256 extends SHA512 {\n    constructor() {\n        super(32);\n        this.Ah = T256_IV[0] | 0;\n        this.Al = T256_IV[1] | 0;\n        this.Bh = T256_IV[2] | 0;\n        this.Bl = T256_IV[3] | 0;\n        this.Ch = T256_IV[4] | 0;\n        this.Cl = T256_IV[5] | 0;\n        this.Dh = T256_IV[6] | 0;\n        this.Dl = T256_IV[7] | 0;\n        this.Eh = T256_IV[8] | 0;\n        this.El = T256_IV[9] | 0;\n        this.Fh = T256_IV[10] | 0;\n        this.Fl = T256_IV[11] | 0;\n        this.Gh = T256_IV[12] | 0;\n        this.Gl = T256_IV[13] | 0;\n        this.Hh = T256_IV[14] | 0;\n        this.Hl = T256_IV[15] | 0;\n    }\n}\n/**\n * SHA2-256 hash function from RFC 4634.\n *\n * It is the fastest JS hash, even faster than Blake3.\n * To break sha256 using birthday attack, attackers need to try 2^128 hashes.\n * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.\n */\nexport const sha256 = /* @__PURE__ */ createHasher(() => new SHA256());\n/** SHA2-224 hash function from RFC 4634 */\nexport const sha224 = /* @__PURE__ */ createHasher(() => new SHA224());\n/** SHA2-512 hash function from RFC 4634. */\nexport const sha512 = /* @__PURE__ */ createHasher(() => new SHA512());\n/** SHA2-384 hash function from RFC 4634. */\nexport const sha384 = /* @__PURE__ */ createHasher(() => new SHA384());\n/**\n * SHA2-512/256 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_256 = /* @__PURE__ */ createHasher(() => new SHA512_256());\n/**\n * SHA2-512/224 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_224 = /* @__PURE__ */ createHasher(() => new SHA512_224());\n//# sourceMappingURL=sha2.js.map"],"names":["SHA256_K","Uint32Array","from","SHA256_W","SHA256","HashMD","constructor","outputLen","super","this","A","SHA256_IV","B","C","D","E","F","G","H","get","set","process","view","offset","i","getUint32","W15","W2","s0","rotr","s1","T1","Chi","T2","Maj","roundClean","clean","destroy","buffer","K512","u64","map","n","BigInt","SHA512_Kh","SHA512_Kl","SHA512_W_H","SHA512_W_L","SHA512","Ah","SHA512_IV","Al","Bh","Bl","Ch","Cl","Dh","Dl","Eh","El","Fh","Fl","Gh","Gl","Hh","Hl","W15h","W15l","s0h","s0l","W2h","W2l","s1h","s1l","SUMl","SUMh","sigma1h","sigma1l","CHIh","T1ll","T1h","T1l","sigma0h","sigma0l","MAJh","MAJl","h","l","All","sha256","createHasher","sha512"],"mappings":"oUAgBA,MAAMA,EAA2BC,YAAYC,KAAK,CAChD,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WACpF,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WACpF,WAAY,WAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WACpF,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UACpF,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WACpF,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UACpF,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WACpF,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,aAIhFC,EAA2B,IAAIF,YAAY,IAC3C,MAAOG,UAAeC,EAY1BC,WAAAA,CAAYC,EAAoB,IAC9BC,MAAM,GAAID,EAAW,GAAG,GAVhBE,KAAAC,EAA2B,EAAfC,EAAU,GACtBF,KAAAG,EAA2B,EAAfD,EAAU,GACtBF,KAAAI,EAA2B,EAAfF,EAAU,GACtBF,KAAAK,EAA2B,EAAfH,EAAU,GACtBF,KAAAM,EAA2B,EAAfJ,EAAU,GACtBF,KAAAO,EAA2B,EAAfL,EAAU,GACtBF,KAAAQ,EAA2B,EAAfN,EAAU,GACtBF,KAAAS,EAA2B,EAAfP,EAAU,EAIhC,CACUQ,GAAAA,GACR,MAAMT,EAAEA,EAACE,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,EAAEA,GAAMT,KACnC,MAAO,CAACC,EAAGE,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAC/B,CAEUE,GAAAA,CACRV,EAAWE,EAAWC,EAAWC,EAAWC,EAAWC,EAAWC,EAAWC,GAE7ET,KAAKC,EAAQ,EAAJA,EACTD,KAAKG,EAAQ,EAAJA,EACTH,KAAKI,EAAQ,EAAJA,EACTJ,KAAKK,EAAQ,EAAJA,EACTL,KAAKM,EAAQ,EAAJA,EACTN,KAAKO,EAAQ,EAAJA,EACTP,KAAKQ,EAAQ,EAAJA,EACTR,KAAKS,EAAQ,EAAJA,CACX,CACUG,OAAAA,CAAQC,EAAgBC,GAEhC,IAAK,IAAIC,EAAI,EAAGA,EAAI,GAAIA,IAAKD,GAAU,EAAGpB,EAASqB,GAAKF,EAAKG,UAAUF,GAAQ,GAC/E,IAAK,IAAIC,EAAI,GAAIA,EAAI,GAAIA,IAAK,CAC5B,MAAME,EAAMvB,EAASqB,EAAI,IACnBG,EAAKxB,EAASqB,EAAI,GAClBI,EAAKC,EAAKH,EAAK,GAAKG,EAAKH,EAAK,IAAOA,IAAQ,EAC7CI,EAAKD,EAAKF,EAAI,IAAME,EAAKF,EAAI,IAAOA,IAAO,GACjDxB,EAASqB,GAAMM,EAAK3B,EAASqB,EAAI,GAAKI,EAAKzB,EAASqB,EAAI,IAAO,CACjE,CAEA,IAAId,EAAEA,EAACE,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,EAAEA,GAAMT,KACjC,IAAK,IAAIe,EAAI,EAAGA,EAAI,GAAIA,IAAK,CAC3B,MACMO,EAAMb,GADGW,EAAKd,EAAG,GAAKc,EAAKd,EAAG,IAAMc,EAAKd,EAAG,KACzBiB,EAAIjB,EAAGC,EAAGC,GAAKjB,EAASwB,GAAKrB,EAASqB,GAAM,EAE/DS,GADSJ,EAAKnB,EAAG,GAAKmB,EAAKnB,EAAG,IAAMmB,EAAKnB,EAAG,KAC7BwB,EAAIxB,EAAGE,EAAGC,GAAM,EACrCK,EAAID,EACJA,EAAID,EACJA,EAAID,EACJA,EAAKD,EAAIiB,EAAM,EACfjB,EAAID,EACJA,EAAID,EACJA,EAAIF,EACJA,EAAKqB,EAAKE,EAAM,CAClB,CAEAvB,EAAKA,EAAID,KAAKC,EAAK,EACnBE,EAAKA,EAAIH,KAAKG,EAAK,EACnBC,EAAKA,EAAIJ,KAAKI,EAAK,EACnBC,EAAKA,EAAIL,KAAKK,EAAK,EACnBC,EAAKA,EAAIN,KAAKM,EAAK,EACnBC,EAAKA,EAAIP,KAAKO,EAAK,EACnBC,EAAKA,EAAIR,KAAKQ,EAAK,EACnBC,EAAKA,EAAIT,KAAKS,EAAK,EACnBT,KAAKW,IAAIV,EAAGE,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAChC,CACUiB,UAAAA,GACRC,EAAMjC,EACR,CACAkC,OAAAA,GACE5B,KAAKW,IAAI,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAC9BgB,EAAM3B,KAAK6B,OACb,EAsBF,MAAMC,EAAuB,KAAOC,EAAU,CAC5C,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,sBAClEC,KAAIC,GAAKC,OAAOD,MArBW,GAsBvBE,EAA4B,KAAOL,EAAK,GAAZ,GAC5BM,EAA4B,KAAON,EAAK,GAAZ,GAG5BO,EAA6B,IAAI7C,YAAY,IAC7C8C,EAA6B,IAAI9C,YAAY,IAE7C,MAAO+C,UAAe3C,EAqB1BC,WAAAA,CAAYC,EAAoB,IAC9BC,MAAM,IAAKD,EAAW,IAAI,GAlBlBE,KAAAwC,GAA4B,EAAfC,EAAU,GACvBzC,KAAA0C,GAA4B,EAAfD,EAAU,GACvBzC,KAAA2C,GAA4B,EAAfF,EAAU,GACvBzC,KAAA4C,GAA4B,EAAfH,EAAU,GACvBzC,KAAA6C,GAA4B,EAAfJ,EAAU,GACvBzC,KAAA8C,GAA4B,EAAfL,EAAU,GACvBzC,KAAA+C,GAA4B,EAAfN,EAAU,GACvBzC,KAAAgD,GAA4B,EAAfP,EAAU,GACvBzC,KAAAiD,GAA4B,EAAfR,EAAU,GACvBzC,KAAAkD,GAA4B,EAAfT,EAAU,GACvBzC,KAAAmD,GAA6B,EAAhBV,EAAU,IACvBzC,KAAAoD,GAA6B,EAAhBX,EAAU,IACvBzC,KAAAqD,GAA6B,EAAhBZ,EAAU,IACvBzC,KAAAsD,GAA6B,EAAhBb,EAAU,IACvBzC,KAAAuD,GAA6B,EAAhBd,EAAU,IACvBzC,KAAAwD,GAA6B,EAAhBf,EAAU,GAIjC,CAEU/B,GAAAA,GAIR,MAAM8B,GAAEA,EAAEE,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,GAAOxD,KAC3E,MAAO,CAACwC,EAAIE,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EACtE,CAEU7C,GAAAA,CACR6B,EAAYE,EAAYC,EAAYC,EAAYC,EAAYC,EAAYC,EAAYC,EACpFC,EAAYC,EAAYC,EAAYC,EAAYC,EAAYC,EAAYC,EAAYC,GAEpFxD,KAAKwC,GAAU,EAALA,EACVxC,KAAK0C,GAAU,EAALA,EACV1C,KAAK2C,GAAU,EAALA,EACV3C,KAAK4C,GAAU,EAALA,EACV5C,KAAK6C,GAAU,EAALA,EACV7C,KAAK8C,GAAU,EAALA,EACV9C,KAAK+C,GAAU,EAALA,EACV/C,KAAKgD,GAAU,EAALA,EACVhD,KAAKiD,GAAU,EAALA,EACVjD,KAAKkD,GAAU,EAALA,EACVlD,KAAKmD,GAAU,EAALA,EACVnD,KAAKoD,GAAU,EAALA,EACVpD,KAAKqD,GAAU,EAALA,EACVrD,KAAKsD,GAAU,EAALA,EACVtD,KAAKuD,GAAU,EAALA,EACVvD,KAAKwD,GAAU,EAALA,CACZ,CACU5C,OAAAA,CAAQC,EAAgBC,GAEhC,IAAK,IAAIC,EAAI,EAAGA,EAAI,GAAIA,IAAKD,GAAU,EACrCuB,EAAWtB,GAAKF,EAAKG,UAAUF,GAC/BwB,EAAWvB,GAAKF,EAAKG,UAAWF,GAAU,GAE5C,IAAK,IAAIC,EAAI,GAAIA,EAAI,GAAIA,IAAK,CAE5B,MAAM0C,EAA4B,EAArBpB,EAAWtB,EAAI,IACtB2C,EAA4B,EAArBpB,EAAWvB,EAAI,IACtB4C,EAAM5B,EAAW0B,EAAMC,EAAM,GAAK3B,EAAW0B,EAAMC,EAAM,GAAK3B,EAAU0B,EAAMC,EAAM,GACpFE,EAAM7B,EAAW0B,EAAMC,EAAM,GAAK3B,EAAW0B,EAAMC,EAAM,GAAK3B,EAAU0B,EAAMC,EAAM,GAEpFG,EAA0B,EAApBxB,EAAWtB,EAAI,GACrB+C,EAA0B,EAApBxB,EAAWvB,EAAI,GACrBgD,EAAMhC,EAAW8B,EAAKC,EAAK,IAAM/B,EAAW8B,EAAKC,EAAK,IAAM/B,EAAU8B,EAAKC,EAAK,GAChFE,EAAMjC,EAAW8B,EAAKC,EAAK,IAAM/B,EAAW8B,EAAKC,EAAK,IAAM/B,EAAU8B,EAAKC,EAAK,GAEhFG,EAAOlC,EAAU6B,EAAKI,EAAK1B,EAAWvB,EAAI,GAAIuB,EAAWvB,EAAI,KAC7DmD,EAAOnC,EAAUkC,EAAMN,EAAKI,EAAK1B,EAAWtB,EAAI,GAAIsB,EAAWtB,EAAI,KACzEsB,EAAWtB,GAAY,EAAPmD,EAChB5B,EAAWvB,GAAY,EAAPkD,CAClB,CACA,IAAIzB,GAAEA,EAAEE,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,GAAOxD,KAEzE,IAAK,IAAIe,EAAI,EAAGA,EAAI,GAAIA,IAAK,CAE3B,MAAMoD,EAAUpC,EAAWkB,EAAIC,EAAI,IAAMnB,EAAWkB,EAAIC,EAAI,IAAMnB,EAAWkB,EAAIC,EAAI,IAC/EkB,EAAUrC,EAAWkB,EAAIC,EAAI,IAAMnB,EAAWkB,EAAIC,EAAI,IAAMnB,EAAWkB,EAAIC,EAAI,IAE/EmB,EAAQpB,EAAKE,GAAQF,EAAKI,EAI1BiB,EAAOvC,EAAUyB,EAAIY,EAHblB,EAAKE,GAAQF,EAAKI,EAGUlB,EAAUrB,GAAIuB,EAAWvB,IAC7DwD,EAAMxC,EAAUuC,EAAMf,EAAIY,EAASE,EAAMlC,EAAUpB,GAAIsB,EAAWtB,IAClEyD,EAAa,EAAPF,EAENG,EAAU1C,EAAWS,EAAIE,EAAI,IAAMX,EAAWS,EAAIE,EAAI,IAAMX,EAAWS,EAAIE,EAAI,IAC/EgC,EAAU3C,EAAWS,EAAIE,EAAI,IAAMX,EAAWS,EAAIE,EAAI,IAAMX,EAAWS,EAAIE,EAAI,IAC/EiC,EAAQnC,EAAKG,EAAOH,EAAKK,EAAOF,EAAKE,EACrC+B,EAAQlC,EAAKE,EAAOF,EAAKI,EAAOF,EAAKE,EAC3CS,EAAU,EAALF,EACLG,EAAU,EAALF,EACLD,EAAU,EAALF,EACLG,EAAU,EAALF,EACLD,EAAU,EAALF,EACLG,EAAU,EAALF,IACF2B,EAAG5B,EAAI6B,EAAG5B,GAAOnB,EAAa,EAALgB,EAAa,EAALC,EAAc,EAANuB,EAAe,EAANC,IACrDzB,EAAU,EAALF,EACLG,EAAU,EAALF,EACLD,EAAU,EAALF,EACLG,EAAU,EAALF,EACLD,EAAU,EAALH,EACLI,EAAU,EAALF,EACL,MAAMqC,EAAMhD,EAAUyC,EAAKE,EAASE,GACpCpC,EAAKT,EAAUgD,EAAKR,EAAKE,EAASE,GAClCjC,EAAW,EAANqC,CACP,GAEGF,EAAGrC,EAAIsC,EAAGpC,GAAOX,EAAkB,EAAV/B,KAAKwC,GAAkB,EAAVxC,KAAK0C,GAAa,EAALF,EAAa,EAALE,MAC3DmC,EAAGlC,EAAImC,EAAGlC,GAAOb,EAAkB,EAAV/B,KAAK2C,GAAkB,EAAV3C,KAAK4C,GAAa,EAALD,EAAa,EAALC,MAC3DiC,EAAGhC,EAAIiC,EAAGhC,GAAOf,EAAkB,EAAV/B,KAAK6C,GAAkB,EAAV7C,KAAK8C,GAAa,EAALD,EAAa,EAALC,MAC3D+B,EAAG9B,EAAI+B,EAAG9B,GAAOjB,EAAkB,EAAV/B,KAAK+C,GAAkB,EAAV/C,KAAKgD,GAAa,EAALD,EAAa,EAALC,MAC3D6B,EAAG5B,EAAI6B,EAAG5B,GAAOnB,EAAkB,EAAV/B,KAAKiD,GAAkB,EAAVjD,KAAKkD,GAAa,EAALD,EAAa,EAALC,MAC3D2B,EAAG1B,EAAI2B,EAAG1B,GAAOrB,EAAkB,EAAV/B,KAAKmD,GAAkB,EAAVnD,KAAKoD,GAAa,EAALD,EAAa,EAALC,MAC3DyB,EAAGxB,EAAIyB,EAAGxB,GAAOvB,EAAkB,EAAV/B,KAAKqD,GAAkB,EAAVrD,KAAKsD,GAAa,EAALD,EAAa,EAALC,MAC3DuB,EAAGtB,EAAIuB,EAAGtB,GAAOzB,EAAkB,EAAV/B,KAAKuD,GAAkB,EAAVvD,KAAKwD,GAAa,EAALD,EAAa,EAALC,IAC9DxD,KAAKW,IAAI6B,EAAIE,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EACvE,CACU9B,UAAAA,GACRC,EAAMU,EAAYC,EACpB,CACAV,OAAAA,GACED,EAAM3B,KAAK6B,QACX7B,KAAKW,IAAI,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EACxD,EAkGK,MAAMqE,EAAgCC,GAAa,IAAM,IAAItF,IAKvDuF,EAAgCD,GAAa,IAAM,IAAI1C","x_google_ignoreList":[0]}

package/dist/esm/node_modules/@noble/hashes/esm/sha256.js

@@ -0,0 +1,2 @@
+import{sha256 as s}from"./sha2.js";const o=s;export{o as sha256};
+//# sourceMappingURL=sha256.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.js","sources":["../../../../../../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":"mCAmBO,MAAMA,EAAyBC","x_google_ignoreList":[0]}

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

@@ -0,0 +1,4 @@
+import{crypto as e}from"./crypto.js";
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function t(e){return e instanceof Uint8Array||ArrayBuffer.isView(e)&&"Uint8Array"===e.constructor.name}function n(e){if(!Number.isSafeInteger(e)||e<0)throw new Error("positive integer expected, got "+e)}function r(e,...n){if(!t(e))throw new Error("Uint8Array expected");if(n.length>0&&!n.includes(e.length))throw new Error("Uint8Array expected of length "+n+", got length="+e.length)}function o(e,t=!0){if(e.destroyed)throw new Error("Hash instance has been destroyed");if(t&&e.finished)throw new Error("Hash#digest() has already been called")}function i(e,t){r(e);const n=t.outputLen;if(e.length<n)throw new Error("digestInto() expects output buffer of length at least "+n)}function f(...e){for(let t=0;t<e.length;t++)e[t].fill(0)}function u(e){return new DataView(e.buffer,e.byteOffset,e.byteLength)}function c(e,t){return e<<32-t|e>>>t}function a(e){if("string"!=typeof e)throw new Error("string expected");return new Uint8Array((new TextEncoder).encode(e))}function s(e){return"string"==typeof e&&(e=a(e)),r(e),e}class d{}function g(e){const t=t=>e().update(s(t)).digest(),n=e();return t.outputLen=n.outputLen,t.blockLen=n.blockLen,t.create=()=>e(),t}function h(t=32){if(e&&"function"==typeof e.getRandomValues)return e.getRandomValues(new Uint8Array(t));if(e&&"function"==typeof e.randomBytes)return Uint8Array.from(e.randomBytes(t));throw new Error("crypto.getRandomValues must be defined")}export{d as Hash,r as abytes,o as aexists,n as anumber,i as aoutput,f as clean,g as createHasher,u as createView,t as isBytes,h as randomBytes,c as rotr,s as toBytes,a as utf8ToBytes};
+//# sourceMappingURL=utils.js.map

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/@scure/base/lib/esm/index.js"],"sourcesContent":["/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nfunction isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n/** Asserts something is Uint8Array. */\nfunction abytes(b, ...lengths) {\n    if (!isBytes(b))\n        throw new Error('Uint8Array expected');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);\n}\nfunction isArrayOf(isString, arr) {\n    if (!Array.isArray(arr))\n        return false;\n    if (arr.length === 0)\n        return true;\n    if (isString) {\n        return arr.every((item) => typeof item === 'string');\n    }\n    else {\n        return arr.every((item) => Number.isSafeInteger(item));\n    }\n}\n// no abytes: seems to have 10% slowdown. Why?!\nfunction afn(input) {\n    if (typeof input !== 'function')\n        throw new Error('function expected');\n    return true;\n}\nfunction astr(label, input) {\n    if (typeof input !== 'string')\n        throw new Error(`${label}: string expected`);\n    return true;\n}\nfunction anumber(n) {\n    if (!Number.isSafeInteger(n))\n        throw new Error(`invalid integer: ${n}`);\n}\nfunction aArr(input) {\n    if (!Array.isArray(input))\n        throw new Error('array expected');\n}\nfunction astrArr(label, input) {\n    if (!isArrayOf(true, input))\n        throw new Error(`${label}: array of strings expected`);\n}\nfunction anumArr(label, input) {\n    if (!isArrayOf(false, input))\n        throw new Error(`${label}: array of numbers expected`);\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction chain(...args) {\n    const id = (a) => a;\n    // Wrap call in closure so JIT can inline calls\n    const wrap = (a, b) => (c) => a(b(c));\n    // Construct chain of args[-1].encode(args[-2].encode([...]))\n    const encode = args.map((x) => x.encode).reduceRight(wrap, id);\n    // Construct chain of args[0].decode(args[1].decode(...))\n    const decode = args.map((x) => x.decode).reduce(wrap, id);\n    return { encode, decode };\n}\n/**\n * Encodes integer radix representation to array of strings using alphabet and back.\n * Could also be array of strings.\n * @__NO_SIDE_EFFECTS__\n */\nfunction alphabet(letters) {\n    // mapping 1 to \"b\"\n    const lettersA = typeof letters === 'string' ? letters.split('') : letters;\n    const len = lettersA.length;\n    astrArr('alphabet', lettersA);\n    // mapping \"b\" to 1\n    const indexes = new Map(lettersA.map((l, i) => [l, i]));\n    return {\n        encode: (digits) => {\n            aArr(digits);\n            return digits.map((i) => {\n                if (!Number.isSafeInteger(i) || i < 0 || i >= len)\n                    throw new Error(`alphabet.encode: digit index outside alphabet \"${i}\". Allowed: ${letters}`);\n                return lettersA[i];\n            });\n        },\n        decode: (input) => {\n            aArr(input);\n            return input.map((letter) => {\n                astr('alphabet.decode', letter);\n                const i = indexes.get(letter);\n                if (i === undefined)\n                    throw new Error(`Unknown letter: \"${letter}\". Allowed: ${letters}`);\n                return i;\n            });\n        },\n    };\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction join(separator = '') {\n    astr('join', separator);\n    return {\n        encode: (from) => {\n            astrArr('join.decode', from);\n            return from.join(separator);\n        },\n        decode: (to) => {\n            astr('join.decode', to);\n            return to.split(separator);\n        },\n    };\n}\n/**\n * Pad strings array so it has integer number of bits\n * @__NO_SIDE_EFFECTS__\n */\nfunction padding(bits, chr = '=') {\n    anumber(bits);\n    astr('padding', chr);\n    return {\n        encode(data) {\n            astrArr('padding.encode', data);\n            while ((data.length * bits) % 8)\n                data.push(chr);\n            return data;\n        },\n        decode(input) {\n            astrArr('padding.decode', input);\n            let end = input.length;\n            if ((end * bits) % 8)\n                throw new Error('padding: invalid, string should have whole number of bytes');\n            for (; end > 0 && input[end - 1] === chr; end--) {\n                const last = end - 1;\n                const byte = last * bits;\n                if (byte % 8 === 0)\n                    throw new Error('padding: invalid, string has too much padding');\n            }\n            return input.slice(0, end);\n        },\n    };\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction normalize(fn) {\n    afn(fn);\n    return { encode: (from) => from, decode: (to) => fn(to) };\n}\n/**\n * Slow: O(n^2) time complexity\n */\nfunction convertRadix(data, from, to) {\n    // base 1 is impossible\n    if (from < 2)\n        throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);\n    if (to < 2)\n        throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);\n    aArr(data);\n    if (!data.length)\n        return [];\n    let pos = 0;\n    const res = [];\n    const digits = Array.from(data, (d) => {\n        anumber(d);\n        if (d < 0 || d >= from)\n            throw new Error(`invalid integer: ${d}`);\n        return d;\n    });\n    const dlen = digits.length;\n    while (true) {\n        let carry = 0;\n        let done = true;\n        for (let i = pos; i < dlen; i++) {\n            const digit = digits[i];\n            const fromCarry = from * carry;\n            const digitBase = fromCarry + digit;\n            if (!Number.isSafeInteger(digitBase) ||\n                fromCarry / from !== carry ||\n                digitBase - digit !== fromCarry) {\n                throw new Error('convertRadix: carry overflow');\n            }\n            const div = digitBase / to;\n            carry = digitBase % to;\n            const rounded = Math.floor(div);\n            digits[i] = rounded;\n            if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)\n                throw new Error('convertRadix: carry overflow');\n            if (!done)\n                continue;\n            else if (!rounded)\n                pos = i;\n            else\n                done = false;\n        }\n        res.push(carry);\n        if (done)\n            break;\n    }\n    for (let i = 0; i < data.length - 1 && data[i] === 0; i++)\n        res.push(0);\n    return res.reverse();\n}\nconst gcd = (a, b) => (b === 0 ? a : gcd(b, a % b));\nconst radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));\nconst powers = /* @__PURE__ */ (() => {\n    let res = [];\n    for (let i = 0; i < 40; i++)\n        res.push(2 ** i);\n    return res;\n})();\n/**\n * Implemented with numbers, because BigInt is 5x slower\n */\nfunction convertRadix2(data, from, to, padding) {\n    aArr(data);\n    if (from <= 0 || from > 32)\n        throw new Error(`convertRadix2: wrong from=${from}`);\n    if (to <= 0 || to > 32)\n        throw new Error(`convertRadix2: wrong to=${to}`);\n    if (radix2carry(from, to) > 32) {\n        throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`);\n    }\n    let carry = 0;\n    let pos = 0; // bitwise position in current element\n    const max = powers[from];\n    const mask = powers[to] - 1;\n    const res = [];\n    for (const n of data) {\n        anumber(n);\n        if (n >= max)\n            throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);\n        carry = (carry << from) | n;\n        if (pos + from > 32)\n            throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);\n        pos += from;\n        for (; pos >= to; pos -= to)\n            res.push(((carry >> (pos - to)) & mask) >>> 0);\n        const pow = powers[pos];\n        if (pow === undefined)\n            throw new Error('invalid carry');\n        carry &= pow - 1; // clean carry, otherwise it will cause overflow\n    }\n    carry = (carry << (to - pos)) & mask;\n    if (!padding && pos >= from)\n        throw new Error('Excess padding');\n    if (!padding && carry > 0)\n        throw new Error(`Non-zero padding: ${carry}`);\n    if (padding && pos > 0)\n        res.push(carry >>> 0);\n    return res;\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction radix(num) {\n    anumber(num);\n    const _256 = 2 ** 8;\n    return {\n        encode: (bytes) => {\n            if (!isBytes(bytes))\n                throw new Error('radix.encode input should be Uint8Array');\n            return convertRadix(Array.from(bytes), _256, num);\n        },\n        decode: (digits) => {\n            anumArr('radix.decode', digits);\n            return Uint8Array.from(convertRadix(digits, num, _256));\n        },\n    };\n}\n/**\n * If both bases are power of same number (like `2**8 <-> 2**64`),\n * there is a linear algorithm. For now we have implementation for power-of-two bases only.\n * @__NO_SIDE_EFFECTS__\n */\nfunction radix2(bits, revPadding = false) {\n    anumber(bits);\n    if (bits <= 0 || bits > 32)\n        throw new Error('radix2: bits should be in (0..32]');\n    if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32)\n        throw new Error('radix2: carry overflow');\n    return {\n        encode: (bytes) => {\n            if (!isBytes(bytes))\n                throw new Error('radix2.encode input should be Uint8Array');\n            return convertRadix2(Array.from(bytes), 8, bits, !revPadding);\n        },\n        decode: (digits) => {\n            anumArr('radix2.decode', digits);\n            return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));\n        },\n    };\n}\nfunction unsafeWrapper(fn) {\n    afn(fn);\n    return function (...args) {\n        try {\n            return fn.apply(null, args);\n        }\n        catch (e) { }\n    };\n}\nfunction checksum(len, fn) {\n    anumber(len);\n    afn(fn);\n    return {\n        encode(data) {\n            if (!isBytes(data))\n                throw new Error('checksum.encode: input should be Uint8Array');\n            const sum = fn(data).slice(0, len);\n            const res = new Uint8Array(data.length + len);\n            res.set(data);\n            res.set(sum, data.length);\n            return res;\n        },\n        decode(data) {\n            if (!isBytes(data))\n                throw new Error('checksum.decode: input should be Uint8Array');\n            const payload = data.slice(0, -len);\n            const oldChecksum = data.slice(-len);\n            const newChecksum = fn(payload).slice(0, len);\n            for (let i = 0; i < len; i++)\n                if (newChecksum[i] !== oldChecksum[i])\n                    throw new Error('Invalid checksum');\n            return payload;\n        },\n    };\n}\n// prettier-ignore\nexport const utils = {\n    alphabet, chain, checksum, convertRadix, convertRadix2, radix, radix2, join, padding,\n};\n// RFC 4648 aka RFC 3548\n// ---------------------\n/**\n * base16 encoding from RFC 4648.\n * @example\n * ```js\n * base16.encode(Uint8Array.from([0x12, 0xab]));\n * // => '12AB'\n * ```\n */\nexport const base16 = chain(radix2(4), alphabet('0123456789ABCDEF'), join(''));\n/**\n * base32 encoding from RFC 4648. Has padding.\n * Use `base32nopad` for unpadded version.\n * Also check out `base32hex`, `base32hexnopad`, `base32crockford`.\n * @example\n * ```js\n * base32.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'CKVQ===='\n * base32.decode('CKVQ====');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32 = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), padding(5), join(''));\n/**\n * base32 encoding from RFC 4648. No padding.\n * Use `base32` for padded version.\n * Also check out `base32hex`, `base32hexnopad`, `base32crockford`.\n * @example\n * ```js\n * base32nopad.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'CKVQ'\n * base32nopad.decode('CKVQ');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32nopad = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), join(''));\n/**\n * base32 encoding from RFC 4648. Padded. Compared to ordinary `base32`, slightly different alphabet.\n * Use `base32hexnopad` for unpadded version.\n * @example\n * ```js\n * base32hex.encode(Uint8Array.from([0x12, 0xab]));\n * // => '2ALG===='\n * base32hex.decode('2ALG====');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32hex = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), padding(5), join(''));\n/**\n * base32 encoding from RFC 4648. No padding. Compared to ordinary `base32`, slightly different alphabet.\n * Use `base32hex` for padded version.\n * @example\n * ```js\n * base32hexnopad.encode(Uint8Array.from([0x12, 0xab]));\n * // => '2ALG'\n * base32hexnopad.decode('2ALG');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32hexnopad = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), join(''));\n/**\n * base32 encoding from RFC 4648. Doug Crockford's version.\n * https://www.crockford.com/base32.html\n * @example\n * ```js\n * base32crockford.encode(Uint8Array.from([0x12, 0xab]));\n * // => '2ANG'\n * base32crockford.decode('2ANG');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32crockford = chain(radix2(5), alphabet('0123456789ABCDEFGHJKMNPQRSTVWXYZ'), join(''), normalize((s) => s.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1')));\n// Built-in base64 conversion https://caniuse.com/mdn-javascript_builtins_uint8array_frombase64\n// TODO: temporarily set to false, trying to understand bugs\n// prettier-ignore\nconst hasBase64Builtin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toBase64 === 'function' &&\n    typeof Uint8Array.fromBase64 === 'function')();\n/**\n * base64 from RFC 4648. Padded.\n * Use `base64nopad` for unpadded version.\n * Also check out `base64url`, `base64urlnopad`.\n * Falls back to built-in function, when available.\n * @example\n * ```js\n * base64.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'Eqs='\n * base64.decode('Eqs=');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\n// prettier-ignore\nexport const base64 = hasBase64Builtin ? {\n    encode(b) { abytes(b); return b.toBase64(); },\n    decode(s) {\n        astr('base64', s);\n        return Uint8Array.fromBase64(s, { lastChunkHandling: 'strict' });\n    },\n} : chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), padding(6), join(''));\n/**\n * base64 from RFC 4648. No padding.\n * Use `base64` for padded version.\n * @example\n * ```js\n * base64nopad.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'Eqs'\n * base64nopad.decode('Eqs');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base64nopad = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), join(''));\n/**\n * base64 from RFC 4648, using URL-safe alphabet. Padded.\n * Use `base64urlnopad` for unpadded version.\n * Falls back to built-in function, when available.\n * @example\n * ```js\n * base64url.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'Eqs='\n * base64url.decode('Eqs=');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\n// prettier-ignore\nexport const base64url = hasBase64Builtin ? {\n    encode(b) { abytes(b); return b.toBase64({ alphabet: 'base64url' }); },\n    decode(s) { astr('base64', s); return Uint8Array.fromBase64(s, { alphabet: 'base64url' }); },\n} : chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), padding(6), join(''));\n/**\n * base64 from RFC 4648, using URL-safe alphabet. No padding.\n * Use `base64url` for padded version.\n * @example\n * ```js\n * base64urlnopad.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'Eqs'\n * base64urlnopad.decode('Eqs');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base64urlnopad = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), join(''));\n// base58 code\n// -----------\nconst genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => chain(radix(58), alphabet(abc), join(''));\n/**\n * base58: base64 without ambigous characters +, /, 0, O, I, l.\n * Quadratic (O(n^2)) - so, can't be used on large inputs.\n * @example\n * ```js\n * base58.decode('01abcdef');\n * // => '3UhJW'\n * ```\n */\nexport const base58 = genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');\n/**\n * base58: flickr version. Check out `base58`.\n */\nexport const base58flickr = genBase58('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ');\n/**\n * base58: XRP version. Check out `base58`.\n */\nexport const base58xrp = genBase58('rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz');\n// Data len (index) -> encoded block len\nconst XMR_BLOCK_LEN = [0, 2, 3, 5, 6, 7, 9, 10, 11];\n/**\n * base58: XMR version. Check out `base58`.\n * Done in 8-byte blocks (which equals 11 chars in decoding). Last (non-full) block padded with '1' to size in XMR_BLOCK_LEN.\n * Block encoding significantly reduces quadratic complexity of base58.\n */\nexport const base58xmr = {\n    encode(data) {\n        let res = '';\n        for (let i = 0; i < data.length; i += 8) {\n            const block = data.subarray(i, i + 8);\n            res += base58.encode(block).padStart(XMR_BLOCK_LEN[block.length], '1');\n        }\n        return res;\n    },\n    decode(str) {\n        let res = [];\n        for (let i = 0; i < str.length; i += 11) {\n            const slice = str.slice(i, i + 11);\n            const blockLen = XMR_BLOCK_LEN.indexOf(slice.length);\n            const block = base58.decode(slice);\n            for (let j = 0; j < block.length - blockLen; j++) {\n                if (block[j] !== 0)\n                    throw new Error('base58xmr: wrong padding');\n            }\n            res = res.concat(Array.from(block.slice(block.length - blockLen)));\n        }\n        return Uint8Array.from(res);\n    },\n};\n/**\n * Method, which creates base58check encoder.\n * Requires function, calculating sha256.\n */\nexport const createBase58check = (sha256) => chain(checksum(4, (data) => sha256(sha256(data))), base58);\n/**\n * Use `createBase58check` instead.\n * @deprecated\n */\nexport const base58check = createBase58check;\nconst BECH_ALPHABET = chain(alphabet('qpzry9x8gf2tvdw0s3jn54khce6mua7l'), join(''));\nconst POLYMOD_GENERATORS = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];\nfunction bech32Polymod(pre) {\n    const b = pre >> 25;\n    let chk = (pre & 0x1ffffff) << 5;\n    for (let i = 0; i < POLYMOD_GENERATORS.length; i++) {\n        if (((b >> i) & 1) === 1)\n            chk ^= POLYMOD_GENERATORS[i];\n    }\n    return chk;\n}\nfunction bechChecksum(prefix, words, encodingConst = 1) {\n    const len = prefix.length;\n    let chk = 1;\n    for (let i = 0; i < len; i++) {\n        const c = prefix.charCodeAt(i);\n        if (c < 33 || c > 126)\n            throw new Error(`Invalid prefix (${prefix})`);\n        chk = bech32Polymod(chk) ^ (c >> 5);\n    }\n    chk = bech32Polymod(chk);\n    for (let i = 0; i < len; i++)\n        chk = bech32Polymod(chk) ^ (prefix.charCodeAt(i) & 0x1f);\n    for (let v of words)\n        chk = bech32Polymod(chk) ^ v;\n    for (let i = 0; i < 6; i++)\n        chk = bech32Polymod(chk);\n    chk ^= encodingConst;\n    return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]], 30, 5, false));\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction genBech32(encoding) {\n    const ENCODING_CONST = encoding === 'bech32' ? 1 : 0x2bc830a3;\n    const _words = radix2(5);\n    const fromWords = _words.decode;\n    const toWords = _words.encode;\n    const fromWordsUnsafe = unsafeWrapper(fromWords);\n    function encode(prefix, words, limit = 90) {\n        astr('bech32.encode prefix', prefix);\n        if (isBytes(words))\n            words = Array.from(words);\n        anumArr('bech32.encode', words);\n        const plen = prefix.length;\n        if (plen === 0)\n            throw new TypeError(`Invalid prefix length ${plen}`);\n        const actualLength = plen + 7 + words.length;\n        if (limit !== false && actualLength > limit)\n            throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);\n        const lowered = prefix.toLowerCase();\n        const sum = bechChecksum(lowered, words, ENCODING_CONST);\n        return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;\n    }\n    function decode(str, limit = 90) {\n        astr('bech32.decode input', str);\n        const slen = str.length;\n        if (slen < 8 || (limit !== false && slen > limit))\n            throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`);\n        // don't allow mixed case\n        const lowered = str.toLowerCase();\n        if (str !== lowered && str !== str.toUpperCase())\n            throw new Error(`String must be lowercase or uppercase`);\n        const sepIndex = lowered.lastIndexOf('1');\n        if (sepIndex === 0 || sepIndex === -1)\n            throw new Error(`Letter \"1\" must be present between prefix and data only`);\n        const prefix = lowered.slice(0, sepIndex);\n        const data = lowered.slice(sepIndex + 1);\n        if (data.length < 6)\n            throw new Error('Data must be at least 6 characters long');\n        const words = BECH_ALPHABET.decode(data).slice(0, -6);\n        const sum = bechChecksum(prefix, words, ENCODING_CONST);\n        if (!data.endsWith(sum))\n            throw new Error(`Invalid checksum in ${str}: expected \"${sum}\"`);\n        return { prefix, words };\n    }\n    const decodeUnsafe = unsafeWrapper(decode);\n    function decodeToBytes(str) {\n        const { prefix, words } = decode(str, false);\n        return { prefix, words, bytes: fromWords(words) };\n    }\n    function encodeFromBytes(prefix, bytes) {\n        return encode(prefix, toWords(bytes));\n    }\n    return {\n        encode,\n        decode,\n        encodeFromBytes,\n        decodeToBytes,\n        decodeUnsafe,\n        fromWords,\n        fromWordsUnsafe,\n        toWords,\n    };\n}\n/**\n * bech32 from BIP 173. Operates on words.\n * For high-level, check out scure-btc-signer:\n * https://github.com/paulmillr/scure-btc-signer.\n */\nexport const bech32 = genBech32('bech32');\n/**\n * bech32m from BIP 350. Operates on words.\n * It was to mitigate `bech32` weaknesses.\n * For high-level, check out scure-btc-signer:\n * https://github.com/paulmillr/scure-btc-signer.\n */\nexport const bech32m = genBech32('bech32m');\n/**\n * UTF-8-to-byte decoder. Uses built-in TextDecoder / TextEncoder.\n * @example\n * ```js\n * const b = utf8.decode(\"hey\"); // => new Uint8Array([ 104, 101, 121 ])\n * const str = utf8.encode(b); // \"hey\"\n * ```\n */\nexport const utf8 = {\n    encode: (data) => new TextDecoder().decode(data),\n    decode: (str) => new TextEncoder().encode(str),\n};\n// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\n// prettier-ignore\nconst hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === 'function' &&\n    typeof Uint8Array.fromHex === 'function')();\n// prettier-ignore\nconst hexBuiltin = {\n    encode(data) { abytes(data); return data.toHex(); },\n    decode(s) { astr('hex', s); return Uint8Array.fromHex(s); },\n};\n/**\n * hex string decoder. Uses built-in function, when available.\n * @example\n * ```js\n * const b = hex.decode(\"0102ff\"); // => new Uint8Array([ 1, 2, 255 ])\n * const str = hex.encode(b); // \"0102ff\"\n * ```\n */\nexport const hex = hasHexBuiltin\n    ? hexBuiltin\n    : chain(radix2(4), alphabet('0123456789abcdef'), join(''), normalize((s) => {\n        if (typeof s !== 'string' || s.length % 2 !== 0)\n            throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`);\n        return s.toLowerCase();\n    }));\n// prettier-ignore\nconst CODERS = {\n    utf8, hex, base16, base32, base64, base64url, base58, base58xmr\n};\nconst coderTypeError = 'Invalid encoding type. Available types: utf8, hex, base16, base32, base64, base64url, base58, base58xmr';\n/** @deprecated */\nexport const bytesToString = (type, bytes) => {\n    if (typeof type !== 'string' || !CODERS.hasOwnProperty(type))\n        throw new TypeError(coderTypeError);\n    if (!isBytes(bytes))\n        throw new TypeError('bytesToString() expects Uint8Array');\n    return CODERS[type].encode(bytes);\n};\n/** @deprecated */\nexport const str = bytesToString; // as in python, but for bytes only\n/** @deprecated */\nexport const stringToBytes = (type, str) => {\n    if (!CODERS.hasOwnProperty(type))\n        throw new TypeError(coderTypeError);\n    if (typeof str !== 'string')\n        throw new TypeError('stringToBytes() expects string');\n    return CODERS[type].decode(str);\n};\n/** @deprecated */\nexport const bytes = stringToBytes;\n//# sourceMappingURL=index.js.map"],"names":["isBytes","a","Uint8Array","ArrayBuffer","isView","constructor","name","isArrayOf","isString","arr","Array","isArray","length","every","item","Number","isSafeInteger","astr","label","input","Error","anumber","n","aArr","astrArr","anumArr","gcd","b","radix2carry","from","to","powers","res","i","push","convertRadix2","data","padding","carry","pos","max","mask","pow","undefined","unsafeWrapper","fn","afn","args","apply","e","BECH_ALPHABET","id","wrap","c","encode","map","x","reduceRight","decode","reduce","chain","letters","lettersA","split","len","indexes","Map","l","digits","letter","get","alphabet","separator","join","POLYMOD_GENERATORS","bech32Polymod","pre","chk","bechChecksum","prefix","words","encodingConst","charCodeAt","v","encoding","ENCODING_CONST","_words","bits","revPadding","bytes","radix2","fromWords","toWords","fromWordsUnsafe","limit","plen","TypeError","actualLength","lowered","toLowerCase"],"mappings":";AAYA,SAASA,EAAQC,GACf,OAAOA,aAAWC,YAAAC,YAAAC,OAAAH,IAAA,eAAAA,EAAAI,YAAAC,IACpB,CAQA,SAAAC,EAAAC,EAAAC,GACE,QAAKC,MAAMC,QAAQF,KACD,IAAdA,EAAIG,SACJJ,EACKC,EAAII,OAAOC,GAAsB,iBAANA,IAEtCL,EAAAI,OAAAC,GAAAC,OAAAC,cAAAF,MAEA,CASA,SAASG,EAAKC,EAAeC,GAC3B,GAAqB,iBAAVA,EAAoB,MAAM,IAAEC,MAAA,GAAAF,sBACzC,OAAA,CACA,CAEA,SAASG,EAAQC,GACjB,IAAAP,OAAAC,cAAAM,GAAA,MAAA,IAAAF,MAAA,oBAAAE,IACA,CAEA,SAASC,EAAKJ,GACd,IAAAT,MAAAC,QAAAQ,GAAA,MAAA,IAAAC,MAAA,iBACA,CACA,SAASI,EAAQN,EAAKC,GACpB,IAAAZ,GAAA,EAAAY,GAAA,MAAA,IAAAC,MAAA,GAAAF,+BACF,CACA,SAASO,EAAQP,EAAMC,GACrB,IAAKZ,GAAU,EAAOY,GAAQ,MAAM,IAAIC,MAAM,GAAEF,+BAClD,CAyKA,MAAMQ,EAAMA,CAACzB,EAAW0B,IAAO,IAAAA,EAAA1B,EAAAyB,EAAAC,EAAA1B,EAAA0B,GACzBC,EAAYA,CAAAC,EAAAC,IAChBD,GAAQC,EAAKJ,EAAIG,EAAMC,IACnBC,EAAY,MAChB,IAAIC,EAAM,GACV,IAAK,IAAIC,EAAI,EAAGA,EAAI,GAAIA,IAAKD,EAAIE,KAAK,GAAKD,GAC3C,OAAOD,CACR,EAJiB,GAQlB,SAASG,EAAcC,EAAgBP,EAAcC,EAAKO,GAExD,GADAd,EAAKa,GACDP,GAAQ,GAAKA,EAAO,GAAG,MAAA,IAAAT,MAAA,6BAAAS,KAC3B,GAAIC,GAAM,GAAKA,EAAK,GAAI,MAAM,IAAIV,MAAM,2BAAEU,KAC1C,GAAIF,EAAYC,EAAMC,GAAM,GAC1B,MAAA,IAAAV,MACE,sCAAkCS,QAAAC,eAAAF,EAAAC,EAAAC,MAGtC,IAAIQ,EAAQ,EACRC,EAAM,EACV,MAAMC,EAAMT,EAAOF,GACbY,EAAOV,EAAOD,GAAO,EACrBE,EAAM,GACd,IAAA,MAAAV,KAAAc,EAAA,CAEI,GADFf,EAAAC,GACMA,GAAKkB,EAAK,MAAI,IAAApB,MAAA,oCAAAE,UAAAO,KAElB,GADFS,EAAAA,GAAAT,EAAAP,EACMiB,EAAMV,EAAM,GAAA,MAAA,IAAAT,MAAA,qCAAAmB,UAAAV,KAEhB,IADAU,GAAOV,EACAU,GAAOT,EAAIS,GAACT,EAAAE,EAAAE,MAAAI,GAAAC,EAAAT,EAAAW,KAAA,GACnB,MAAMC,EAACX,EAAAQ,GACP,QAAYI,IAARD,EAAmB,MAAA,IAAAtB,MAAA,iBACvBkB,GAASI,EAAM,CACjB,CAEA,GADAJ,EAASA,GAAUR,EAAKS,EAAQE,GAC3BJ,GAAEE,GAAAV,EAAA,MAAA,IAAAT,MAAA,kBACP,IAAKiB,GAAWC,EAAQ,EAAE,MAAA,IAAAlB,MAAA,qBAAAkB,KAE1B,OADID,GAAWE,EAAM,GAAGP,EAAIE,KAAKI,IAAQ,GAClCN,CACT,CA2CA,SAASY,EAA+CC,GAEtD,OArRF,SAAa1B,GACX,GAAqB,mBAAVA,EAAmB,MAAA,IAAAC,MAAA,oBAEhC,CAiRE0B,CAAID,GACG,YAAaE,GAClB,IACE,OAAGF,EAAAG,MAAA,KAAAD,EACJ,CAAC,MAAOE,GAAG,CACb,CACH,CA2TA,MAAMC,EA1iBN,YAAwBH,GACtB,MAAMI,EAAMlD,GAAWA,EAEjBmD,EAAOA,CAACnD,EAAQ0B,IAAY0B,GAAWpD,EAAE0B,EAAE0B,IAKjD,MAAO,CAAEC,OAHGP,EAAAQ,KAAAC,GAAAA,EAAAF,SAAAG,YAAAL,EAAAD,GAGKO,OADFX,EAAKQ,KAAKC,GAAAA,EAAAE,SAAAC,OAAAP,EAAAD,GAE3B,CAiiB+CS,CA1hB/C,SAASC,GAET,MAAAC,EAAA,iBAAAD,EAAAA,EAAAE,MAAA,IAAAF,EACEG,EAAAF,EAAAlD,OACAY,EAAQ,WAAYsC,GAGpB,MAAMG,EAAU,IAAIC,IAAIJ,EAACP,KAAA,CAAAY,EAAAlC,IAAA,CAAAkC,EAAAlC,MACzB,MAAO,CACLqB,OAASc,IACP7C,EAAK6C,GACEA,EAAOb,KAAKtB,IACjB,IAAClB,OAAAC,cAAAiB,IAAAA,EAAA,GAAAA,GAAA+B,EACC,MAAM,IAAI5C,MACR,kDAAuBa,gBAAA4B,KAE3B,OAACC,EAAA7B,EAAA,KAGPyB,OAAAvC,IACII,EAAKJ,GACEA,EAAMoC,KAAGc,IACpBpD,EAAA,kBAAAoD,GACM,MAAMpC,EAAIgC,EAAQK,IAAID,GACtB,QAAS1B,IAALV,EAAK,MAAA,IAAAb,MAAA,oBAAAiD,gBAAAR,KACT,OAAO5B,CAAC,KAIhB,CA8fEsC,CAAA,oCAzfF,SAAcC,EAAY,IAExB,OADAvD,EAAK,OAAQuD,GACN,CACLlB,OAASzB,IACPL,EAAQ,cAAeK,GAChBA,EAAK4C,KAAKD,IAEnBd,OAAS5B,IACPb,EAAK,cAAea,GACdA,EAAAiC,MAAAS,IAGZ,CA8eEC,CAAK,KAGDC,EAAqB,CAAC,UAAY,UAAC,UAAA,WAAA,WACzC,SAASC,EAAcC,GACrB,MAAMjD,EAAIiD,GAAO,GACjB,IAAAC,GAAA,SAAAD,IAAA,EACA,IAAK,IAAI3C,EAAI,EAAGA,EAAIyC,EAAmB9D,OAAEqB,IACzC,IAAAN,GAAAM,EAAA,KAAA4C,GAAAH,EAAAzC,IAEA,OAAO4C,CACT,CAEA,SAASC,EAAaC,EAAgBC,EAAAC,EAAA,GACpC,MAAGjB,EAAAe,EAAAnE,OACH,IAAAiE,EAAA,EACA,IAAK,IAAI5C,EAAI,EAAGA,EAAE+B,EAAA/B,IAAA,CAChB,MAAMoB,EAAI0B,EAAOG,WAAWjD,GAC5B,GAAIoB,EAAI,IAAMA,EAAI,IAAK,MAAM,IAAIjC,MAAM,mBAAO2D,MACjDF,EAAAF,EAAAE,GAAAxB,GAAA,CACC,CACAwB,EAAMF,EAASE,GACf,IAAK,IAAI5C,EAAI,EAAGA,EAAI+B,EAAK/B,IAAK4C,EAAMF,EAAcE,GAA+B,GAAvBE,EAAOG,WAAWjD,GAC5E,IAAK,IAAIkD,KAAKH,EAAOH,EAAMF,EAAcE,GAAIM,EAC7C,IAAK,IAAIlD,EAAI,EAAEA,EAAA,EAAAA,IAAA4C,EAAAF,EAAAE,GAEf,OADAA,GAAOI,EACA/B,EAAcI,OAAOnB,EAAc,CAAC0C,EAAM9C,EAAI,KAAA,GAAA,GAAA,GACvD,SAsBA,SAAiBqD,GACf,MAAMC,EAA8B,WAAbD,EAAqB,EAAA,UACtCE,EAzYR,SAAAC,EAAAC,GAAA,GAEE,GADAnE,EAAQkE,GACJA,GAAK,GAAAA,EAAA,GAAA,MAAA,IAAAnE,MAAA,qCACT,GAAIQ,EAAY,EAAG2D,GAAQ,IAAC3D,EAAA2D,EAAA,GAAA,GAC1B,MAAM,IAAEnE,MAAA,0BACV,MAAO,CACLkC,OAAImC,IACF,IAAKzF,EAAQyF,GAAC,MAAA,IAAArE,MAAA,4CACf,OAAAe,EAAAzB,MAAAmB,KAAA4D,GAAA,EAAAF,GAAAC,EAAA,EAED9B,OAASU,IACP3C,EAAQ,gBAAE2C,GACLlE,WAAA2B,KAAAM,EAAAiC,EAAAmB,EAAA,EAAAC,KAGX,CA0XiBE,CAAO,GAChBC,EAAYL,EAAO5B,OACnBkC,EAAUN,EAAKhC,OACfuC,EAAkBjD,EAAc+C,GAEvC,SAAArC,EACGyB,EACAC,EACAc,EAAa,IAEb7E,EAAK,uBAAwB8D,GACzB/E,EAAQgF,KAAQA,EAAQtE,MAAMmB,KAAKmD,IACvCvD,EAAQ,gBAAiBuD,GACzB,MAAMe,EAAOhB,EAAOnE,OACpB,GAAa,IAATmF,EAAY,MAAM,IAAIC,UAAK,yBAAAD,KAClC,MAAAE,EAAAF,EAAA,EAAAf,EAAApE,OACG,IAAa,IAATkF,GAASG,EAAAH,EACX,MAAM,IAAIE,UAAU,UAAQC,mBAAAH,KAC9B,MAAMI,EAAUnB,EAAOoB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/@solana/spl-token/lib/esm/constants.js

@@ -0,0 +1,2 @@
+import{PublicKey as n}from"@solana/web3.js";const e=new n("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");new n("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");const o=new n("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");new n("So11111111111111111111111111111111111111112"),new n("9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP");export{o as ASSOCIATED_TOKEN_PROGRAM_ID,e as TOKEN_PROGRAM_ID};
+//# sourceMappingURL=constants.js.map

package/dist/esm/node_modules/@solana/spl-token/lib/esm/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sources":["../../../../../../../node_modules/@solana/spl-token/lib/esm/constants.js"],"sourcesContent":["import { PublicKey } from '@solana/web3.js';\n/** Address of the SPL Token program */\nexport const TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');\n/** Address of the SPL Token 2022 program */\nexport const TOKEN_2022_PROGRAM_ID = new PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb');\n/** Address of the SPL Associated Token Account program */\nexport const ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');\n/** Address of the special mint for wrapped native SOL in spl-token */\nexport const NATIVE_MINT = new PublicKey('So11111111111111111111111111111111111111112');\n/** Address of the special mint for wrapped native SOL in spl-token-2022 */\nexport const NATIVE_MINT_2022 = new PublicKey('9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP');\n/** Check that the token program provided is not `Tokenkeg...`, useful when using extensions */\nexport function programSupportsExtensions(programId) {\n    if (programId.equals(TOKEN_PROGRAM_ID)) {\n        return false;\n    }\n    else {\n        return true;\n    }\n}\n//# sourceMappingURL=constants.js.map"],"names":["TOKEN_PROGRAM_ID","PublicKey","ASSOCIATED_TOKEN_PROGRAM_ID"],"mappings":"kDAGaA,EAAmB,IAAIC,EAAU,+CAGT,IAAIA,EAAU,qDAGtCC,EAA8B,IAAID,EAAU,gDAG9B,IAAIA,EAAU,+CAGT,IAAIA,EAAU","x_google_ignoreList":[0]}

package/dist/esm/node_modules/@solana/spl-token/lib/esm/errors.js

@@ -0,0 +1,2 @@
+class r extends Error{constructor(r){super(r)}}class s extends r{constructor(){super(...arguments),this.name="TokenAccountNotFoundError"}}class e extends r{constructor(){super(...arguments),this.name="TokenInvalidAccountOwnerError"}}class n extends r{constructor(){super(...arguments),this.name="TokenInvalidAccountSizeError"}}class o extends r{constructor(){super(...arguments),this.name="TokenInvalidMintError"}}class t extends r{constructor(){super(...arguments),this.name="TokenOwnerOffCurveError"}}export{s as TokenAccountNotFoundError,r as TokenError,e as TokenInvalidAccountOwnerError,n as TokenInvalidAccountSizeError,o as TokenInvalidMintError,t as TokenOwnerOffCurveError};
+//# sourceMappingURL=errors.js.map

package/dist/esm/node_modules/@solana/spl-token/lib/esm/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sources":["../../../../../../../node_modules/@solana/spl-token/lib/esm/errors.js"],"sourcesContent":["/** Base class for errors */\nexport class TokenError extends Error {\n    constructor(message) {\n        super(message);\n    }\n}\n/** Thrown if an account is not found at the expected address */\nexport class TokenAccountNotFoundError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenAccountNotFoundError';\n    }\n}\n/** Thrown if a program state account is not a valid Account */\nexport class TokenInvalidAccountError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidAccountError';\n    }\n}\n/** Thrown if a program state account does not contain valid data */\nexport class TokenInvalidAccountDataError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidAccountDataError';\n    }\n}\n/** Thrown if a program state account is not owned by the expected token program */\nexport class TokenInvalidAccountOwnerError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidAccountOwnerError';\n    }\n}\n/** Thrown if the byte length of an program state account doesn't match the expected size */\nexport class TokenInvalidAccountSizeError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidAccountSizeError';\n    }\n}\n/** Thrown if the mint of a token account doesn't match the expected mint */\nexport class TokenInvalidMintError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidMintError';\n    }\n}\n/** Thrown if the owner of a token account doesn't match the expected owner */\nexport class TokenInvalidOwnerError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidOwnerError';\n    }\n}\n/** Thrown if the owner of a token account is a PDA (Program Derived Address) */\nexport class TokenOwnerOffCurveError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenOwnerOffCurveError';\n    }\n}\n/** Thrown if an instruction's program is invalid */\nexport class TokenInvalidInstructionProgramError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidInstructionProgramError';\n    }\n}\n/** Thrown if an instruction's keys are invalid */\nexport class TokenInvalidInstructionKeysError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidInstructionKeysError';\n    }\n}\n/** Thrown if an instruction's data is invalid */\nexport class TokenInvalidInstructionDataError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidInstructionDataError';\n    }\n}\n/** Thrown if an instruction's type is invalid */\nexport class TokenInvalidInstructionTypeError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidInstructionTypeError';\n    }\n}\n/** Thrown if the program does not support the desired instruction */\nexport class TokenUnsupportedInstructionError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenUnsupportedInstructionError';\n    }\n}\n/** Thrown if the transfer hook extra accounts contains an invalid account index */\nexport class TokenTransferHookAccountNotFound extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenTransferHookAccountNotFound';\n    }\n}\n/** Thrown if the transfer hook extra accounts contains an invalid seed */\nexport class TokenTransferHookInvalidSeed extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenTransferHookInvalidSeed';\n    }\n}\n/** Thrown if account data required by an extra account meta seed config could not be fetched */\nexport class TokenTransferHookAccountDataNotFound extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenTransferHookAccountDataNotFound';\n    }\n}\n//# sourceMappingURL=errors.js.map"],"names":["TokenError","Error","constructor","message","super","TokenAccountNotFoundError","this","name","TokenInvalidAccountOwnerError","TokenInvalidAccountSizeError","TokenInvalidMintError","TokenOwnerOffCurveError"],"mappings":"AACM,MAAgBA,UAAmBC,MACrCC,WAAAA,CAAYC,GACRC,MAAMD,EACV,EAIE,MAAOE,UAAkCL,EAA/CE,WAAAA,uBACII,KAAAC,KAAO,2BACX,EAaM,MAAOC,UAAsCR,EAAnDE,WAAAA,uBACII,KAAAC,KAAO,+BACX,EAGM,MAAOE,UAAqCT,EAAlDE,WAAAA,uBACII,KAAAC,KAAO,8BACX,EAGM,MAAOG,UAA8BV,EAA3CE,WAAAA,uBACII,KAAAC,KAAO,uBACX,EAQM,MAAOI,UAAgCX,EAA7CE,WAAAA,uBACII,KAAAC,KAAO,yBACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/@solana/spl-token/lib/esm/extensions/accountType.js

@@ -0,0 +1,2 @@
+var i;!function(i){i[i.Uninitialized=0]="Uninitialized",i[i.Mint=1]="Mint",i[i.Account=2]="Account"}(i||(i={}));const n=1;export{n as ACCOUNT_TYPE_SIZE,i as AccountType};
+//# sourceMappingURL=accountType.js.map

package/dist/esm/node_modules/@solana/spl-token/lib/esm/extensions/accountType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accountType.js","sources":["../../../../../../../../node_modules/@solana/spl-token/lib/esm/extensions/accountType.js"],"sourcesContent":["export var AccountType;\n(function (AccountType) {\n    AccountType[AccountType[\"Uninitialized\"] = 0] = \"Uninitialized\";\n    AccountType[AccountType[\"Mint\"] = 1] = \"Mint\";\n    AccountType[AccountType[\"Account\"] = 2] = \"Account\";\n})(AccountType || (AccountType = {}));\nexport const ACCOUNT_TYPE_SIZE = 1;\n//# sourceMappingURL=accountType.js.map"],"names":["AccountType","ACCOUNT_TYPE_SIZE"],"mappings":"AAAA,IAAYA,GAAZ,SAAYA,GACRA,EAAAA,EAAa,cAAA,GAAA,gBACbA,EAAAA,EAAI,KAAA,GAAA,OACJA,EAAAA,EAAO,QAAA,GAAA,SACV,CAJD,CAAYA,IAAAA,EAAW,CAAA,IAKhB,MAAMC,EAAoB","x_google_ignoreList":[0]}

package/dist/esm/node_modules/@solana/spl-token/lib/esm/instructions/associatedTokenAccount.js

@@ -0,0 +1,2 @@
+import"../../../../../buffer/index.js";import{TransactionInstruction as i,SystemProgram as r}from"@solana/web3.js";import{TOKEN_PROGRAM_ID as e,ASSOCIATED_TOKEN_PROGRAM_ID as s}from"../constants.js";import{__exports as t}from"../../../../../../_virtual/index.js";function n(n,o,a,b,p=e,u=s){return function(t,n,o,a,b,p=e,u=s){const f=[{pubkey:t,isSigner:!0,isWritable:!0},{pubkey:n,isSigner:!1,isWritable:!0},{pubkey:o,isSigner:!1,isWritable:!1},{pubkey:a,isSigner:!1,isWritable:!1},{pubkey:r.programId,isSigner:!1,isWritable:!1},{pubkey:p,isSigner:!1,isWritable:!1}];return new i({keys:f,programId:u,data:b})}(n,o,a,b,t.Buffer.from([1]),p,u)}export{n as createAssociatedTokenAccountIdempotentInstruction};
+//# sourceMappingURL=associatedTokenAccount.js.map

package/dist/esm/node_modules/@solana/spl-token/lib/esm/instructions/associatedTokenAccount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"associatedTokenAccount.js","sources":["../../../../../../../../node_modules/@solana/spl-token/lib/esm/instructions/associatedTokenAccount.js"],"sourcesContent":["import { SystemProgram, TransactionInstruction } from '@solana/web3.js';\nimport { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../constants.js';\n/**\n * Construct a CreateAssociatedTokenAccount instruction\n *\n * @param payer                    Payer of the initialization fees\n * @param associatedToken          New associated token account\n * @param owner                    Owner of the new account\n * @param mint                     Token mint account\n * @param programId                SPL Token program account\n * @param associatedTokenProgramId SPL Associated Token program account\n *\n * @return Instruction to add to a transaction\n */\nexport function createAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {\n    return buildAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, Buffer.alloc(0), programId, associatedTokenProgramId);\n}\n/**\n * Construct a CreateAssociatedTokenAccountIdempotent instruction\n *\n * @param payer                    Payer of the initialization fees\n * @param associatedToken          New associated token account\n * @param owner                    Owner of the new account\n * @param mint                     Token mint account\n * @param programId                SPL Token program account\n * @param associatedTokenProgramId SPL Associated Token program account\n *\n * @return Instruction to add to a transaction\n */\nexport function createAssociatedTokenAccountIdempotentInstruction(payer, associatedToken, owner, mint, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {\n    return buildAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, Buffer.from([1]), programId, associatedTokenProgramId);\n}\nfunction buildAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, instructionData, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {\n    const keys = [\n        { pubkey: payer, isSigner: true, isWritable: true },\n        { pubkey: associatedToken, isSigner: false, isWritable: true },\n        { pubkey: owner, isSigner: false, isWritable: false },\n        { pubkey: mint, isSigner: false, isWritable: false },\n        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },\n        { pubkey: programId, isSigner: false, isWritable: false },\n    ];\n    return new TransactionInstruction({\n        keys,\n        programId: associatedTokenProgramId,\n        data: instructionData,\n    });\n}\n/**\n * Construct a RecoverNested instruction\n *\n * @param nestedAssociatedToken             Nested associated token account (must be owned by `ownerAssociatedToken`)\n * @param nestedMint                        Token mint for the nested associated token account\n * @param destinationAssociatedToken        Wallet's associated token account\n * @param ownerAssociatedToken              Owner associated token account address (must be owned by `owner`)\n * @param ownerMint                         Token mint for the owner associated token account\n * @param owner                             Wallet address for the owner associated token account\n * @param programId                         SPL Token program account\n * @param associatedTokenProgramId          SPL Associated Token program account\n *\n * @return Instruction to add to a transaction\n */\nexport function createRecoverNestedInstruction(nestedAssociatedToken, nestedMint, destinationAssociatedToken, ownerAssociatedToken, ownerMint, owner, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {\n    const keys = [\n        { pubkey: nestedAssociatedToken, isSigner: false, isWritable: true },\n        { pubkey: nestedMint, isSigner: false, isWritable: false },\n        { pubkey: destinationAssociatedToken, isSigner: false, isWritable: true },\n        { pubkey: ownerAssociatedToken, isSigner: false, isWritable: true },\n        { pubkey: ownerMint, isSigner: false, isWritable: false },\n        { pubkey: owner, isSigner: true, isWritable: true },\n        { pubkey: programId, isSigner: false, isWritable: false },\n    ];\n    return new TransactionInstruction({\n        keys,\n        programId: associatedTokenProgramId,\n        data: Buffer.from([2]),\n    });\n}\n//# sourceMappingURL=associatedTokenAccount.js.map"],"names":["createAssociatedTokenAccountIdempotentInstruction","payer","associatedToken","owner","mint","programId","TOKEN_PROGRAM_ID","associatedTokenProgramId","ASSOCIATED_TOKEN_PROGRAM_ID","buildAssociatedTokenAccountInstruction","instructionData","keys","pubkey","isSigner","isWritable","Buffer","from"],"mappings":"uQA8DC,SAAAA,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,GAED,OAUQC,SAAsBR,EAAAC,EAAAC,EAAAC,EAAAM,EAAAL,EAAAC,EAAAC,EAAAC,GACxBG,MAAAA,EAAA,CACN,CAAAC,OAAAX,EAAAY,UAAA,EAAAC,YAAA,GACQ,CAAEF,OAAQV,EAAgBW,UAAO,EAAQC,YAAA,4MAbxCL,CACLR,EACAC,EACAC,EACAC,EACAW,SAAAC,KAAA,CAAuB,IACvBX,EAACE","x_google_ignoreList":[0]}

package/dist/esm/node_modules/@solana/spl-token/lib/esm/state/account.js

@@ -0,0 +1,2 @@
+import{struct as t,u32 as i,u8 as e}from"@solana/buffer-layout";import{publicKey as o,u64 as n}from"@solana/buffer-layout-utils";var a;!function(t){t[t.Uninitialized=0]="Uninitialized",t[t.Initialized=1]="Initialized",t[t.Frozen=2]="Frozen"}(a||(a={}));const l=t([o("mint"),o("owner"),n("amount"),i("delegateOption"),o("delegate"),e("state"),i("isNativeOption"),n("isNative"),n("delegatedAmount"),i("closeAuthorityOption"),o("closeAuthority")]),r=l.span;export{r as ACCOUNT_SIZE,l as AccountLayout,a as AccountState};
+//# sourceMappingURL=account.js.map

package/dist/esm/node_modules/@solana/spl-token/lib/esm/state/account.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.js","sources":["../../../../../../../../node_modules/@solana/spl-token/lib/esm/state/account.js"],"sourcesContent":["import { struct, u32, u8 } from '@solana/buffer-layout';\nimport { publicKey, u64 } from '@solana/buffer-layout-utils';\nimport { TOKEN_PROGRAM_ID } from '../constants.js';\nimport { TokenAccountNotFoundError, TokenInvalidAccountError, TokenInvalidAccountOwnerError, TokenInvalidAccountSizeError, } from '../errors.js';\nimport { ACCOUNT_TYPE_SIZE, AccountType } from '../extensions/accountType.js';\nimport { getAccountLen } from '../extensions/extensionType.js';\nimport { MULTISIG_SIZE } from './multisig.js';\n/** Token account state as stored by the program */\nexport var AccountState;\n(function (AccountState) {\n    AccountState[AccountState[\"Uninitialized\"] = 0] = \"Uninitialized\";\n    AccountState[AccountState[\"Initialized\"] = 1] = \"Initialized\";\n    AccountState[AccountState[\"Frozen\"] = 2] = \"Frozen\";\n})(AccountState || (AccountState = {}));\n/** Buffer layout for de/serializing a token account */\nexport const AccountLayout = struct([\n    publicKey('mint'),\n    publicKey('owner'),\n    u64('amount'),\n    u32('delegateOption'),\n    publicKey('delegate'),\n    u8('state'),\n    u32('isNativeOption'),\n    u64('isNative'),\n    u64('delegatedAmount'),\n    u32('closeAuthorityOption'),\n    publicKey('closeAuthority'),\n]);\n/** Byte length of a token account */\nexport const ACCOUNT_SIZE = AccountLayout.span;\n/**\n * Retrieve information about a token account\n *\n * @param connection Connection to use\n * @param address    Token account\n * @param commitment Desired level of commitment for querying the state\n * @param programId  SPL Token program account\n *\n * @return Token account information\n */\nexport async function getAccount(connection, address, commitment, programId = TOKEN_PROGRAM_ID) {\n    const info = await connection.getAccountInfo(address, commitment);\n    return unpackAccount(address, info, programId);\n}\n/**\n * Retrieve information about multiple token accounts in a single RPC call\n *\n * @param connection Connection to use\n * @param addresses  Token accounts\n * @param commitment Desired level of commitment for querying the state\n * @param programId  SPL Token program account\n *\n * @return Token account information\n */\nexport async function getMultipleAccounts(connection, addresses, commitment, programId = TOKEN_PROGRAM_ID) {\n    const infos = await connection.getMultipleAccountsInfo(addresses, commitment);\n    return addresses.map((address, i) => unpackAccount(address, infos[i], programId));\n}\n/** Get the minimum lamport balance for a base token account to be rent exempt\n *\n * @param connection Connection to use\n * @param commitment Desired level of commitment for querying the state\n *\n * @return Amount of lamports required\n */\nexport async function getMinimumBalanceForRentExemptAccount(connection, commitment) {\n    return await getMinimumBalanceForRentExemptAccountWithExtensions(connection, [], commitment);\n}\n/** Get the minimum lamport balance for a rent-exempt token account with extensions\n *\n * @param connection Connection to use\n * @param commitment Desired level of commitment for querying the state\n *\n * @return Amount of lamports required\n */\nexport async function getMinimumBalanceForRentExemptAccountWithExtensions(connection, extensions, commitment) {\n    const accountLen = getAccountLen(extensions);\n    return await connection.getMinimumBalanceForRentExemption(accountLen, commitment);\n}\n/**\n * Unpack a token account\n *\n * @param address   Token account\n * @param info      Token account data\n * @param programId SPL Token program account\n *\n * @return Unpacked token account\n */\nexport function unpackAccount(address, info, programId = TOKEN_PROGRAM_ID) {\n    if (!info)\n        throw new TokenAccountNotFoundError();\n    if (!info.owner.equals(programId))\n        throw new TokenInvalidAccountOwnerError();\n    if (info.data.length < ACCOUNT_SIZE)\n        throw new TokenInvalidAccountSizeError();\n    const rawAccount = AccountLayout.decode(info.data.slice(0, ACCOUNT_SIZE));\n    let tlvData = Buffer.alloc(0);\n    if (info.data.length > ACCOUNT_SIZE) {\n        if (info.data.length === MULTISIG_SIZE)\n            throw new TokenInvalidAccountSizeError();\n        if (info.data[ACCOUNT_SIZE] != AccountType.Account)\n            throw new TokenInvalidAccountError();\n        tlvData = info.data.slice(ACCOUNT_SIZE + ACCOUNT_TYPE_SIZE);\n    }\n    return {\n        address,\n        mint: rawAccount.mint,\n        owner: rawAccount.owner,\n        amount: rawAccount.amount,\n        delegate: rawAccount.delegateOption ? rawAccount.delegate : null,\n        delegatedAmount: rawAccount.delegatedAmount,\n        isInitialized: rawAccount.state !== AccountState.Uninitialized,\n        isFrozen: rawAccount.state === AccountState.Frozen,\n        isNative: !!rawAccount.isNativeOption,\n        rentExemptReserve: rawAccount.isNativeOption ? rawAccount.isNative : null,\n        closeAuthority: rawAccount.closeAuthorityOption ? rawAccount.closeAuthority : null,\n        tlvData,\n    };\n}\n//# sourceMappingURL=account.js.map"],"names":["AccountState","AccountLayout","struct","publicKey","u64","u32","u8"],"mappings":"iIA6CI,IAAAA,YACHA,GACGA,EAAAA,EAAU,cAAA,GAAA,gBAHZA,EAAAA,EAID,YAAA,GAAA,cAiBDA,EAAAA,EAAuD,OAAA,GAAA,QACvD,EAAAA,IAAaA,EAAsB,CAAA,IAE/B,MAASC,EAASC,EACrBC,CAAAA,UACGA,EACAC,SAAAA,YACHC,EAAA,kBACGF,EAAoB,YACtBG,EAAA,SACED,EAAI,kBACJD,EAAI,YACJA,EAAU,mBACdC,EAAA,wBAEAF,EACA","x_google_ignoreList":[0]}

package/dist/esm/node_modules/@solana/spl-token/lib/esm/state/mint.js

@@ -0,0 +1,2 @@
+import"../../../../../buffer/index.js";import{struct as t,u32 as i,u8 as o}from"@solana/buffer-layout";import{publicKey as r,u64 as e,bool as n}from"@solana/buffer-layout-utils";import{PublicKey as a}from"@solana/web3.js";import{TOKEN_PROGRAM_ID as f,ASSOCIATED_TOKEN_PROGRAM_ID as s}from"../constants.js";import{TokenOwnerOffCurveError as u,TokenAccountNotFoundError as l,TokenInvalidAccountOwnerError as m,TokenInvalidAccountSizeError as p,TokenInvalidMintError as c}from"../errors.js";import{AccountType as d,ACCOUNT_TYPE_SIZE as h}from"../extensions/accountType.js";import{ACCOUNT_SIZE as y}from"./account.js";import{MULTISIG_SIZE as w}from"./multisig.js";import{__exports as A}from"../../../../../../_virtual/index.js";const j=t([i("mintAuthorityOption"),r("mintAuthority"),e("supply"),o("decimals"),n("isInitialized"),i("freezeAuthorityOption"),r("freezeAuthority")]),z=j.span;async function g(t,i,o,r=f){return x(i,await t.getAccountInfo(i,o),r)}function x(t,i,o=f){if(!i)throw new l;if(!i.owner.equals(o))throw new m;if(i.data.length<z)throw new p;const r=j.decode(i.data.slice(0,z));let e=A.Buffer.alloc(0);if(i.data.length>z){if(i.data.length<=y)throw new p;if(i.data.length===w)throw new p;if(i.data[y]!=d.Mint)throw new c;e=i.data.slice(y+h)}return{address:t,mintAuthority:r.mintAuthorityOption?r.mintAuthority:null,supply:r.supply,decimals:r.decimals,isInitialized:r.isInitialized,freezeAuthority:r.freezeAuthorityOption?r.freezeAuthority:null,tlvData:e}}function B(t,i,o=!1,r=f,e=s){if(!o&&!a.isOnCurve(i.toBuffer()))throw new u;const[n]=a.findProgramAddressSync([i.toBuffer(),r.toBuffer(),t.toBuffer()],e);return n}export{z as MINT_SIZE,j as MintLayout,B as getAssociatedTokenAddressSync,g as getMint,x as unpackMint};
+//# sourceMappingURL=mint.js.map

package/dist/esm/node_modules/@solana/spl-token/lib/esm/state/mint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mint.js","sources":["../../../../../../../../node_modules/@solana/spl-token/lib/esm/state/mint.js"],"sourcesContent":["import { struct, u32, u8 } from '@solana/buffer-layout';\nimport { bool, publicKey, u64 } from '@solana/buffer-layout-utils';\nimport { PublicKey } from '@solana/web3.js';\nimport { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../constants.js';\nimport { TokenAccountNotFoundError, TokenInvalidAccountOwnerError, TokenInvalidAccountSizeError, TokenInvalidMintError, TokenOwnerOffCurveError, } from '../errors.js';\nimport { ACCOUNT_TYPE_SIZE, AccountType } from '../extensions/accountType.js';\nimport { getMintLen } from '../extensions/extensionType.js';\nimport { ACCOUNT_SIZE } from './account.js';\nimport { MULTISIG_SIZE } from './multisig.js';\n/** Buffer layout for de/serializing a mint */\nexport const MintLayout = struct([\n    u32('mintAuthorityOption'),\n    publicKey('mintAuthority'),\n    u64('supply'),\n    u8('decimals'),\n    bool('isInitialized'),\n    u32('freezeAuthorityOption'),\n    publicKey('freezeAuthority'),\n]);\n/** Byte length of a mint */\nexport const MINT_SIZE = MintLayout.span;\n/**\n * Retrieve information about a mint\n *\n * @param connection Connection to use\n * @param address    Mint account\n * @param commitment Desired level of commitment for querying the state\n * @param programId  SPL Token program account\n *\n * @return Mint information\n */\nexport async function getMint(connection, address, commitment, programId = TOKEN_PROGRAM_ID) {\n    const info = await connection.getAccountInfo(address, commitment);\n    return unpackMint(address, info, programId);\n}\n/**\n * Unpack a mint\n *\n * @param address   Mint account\n * @param info      Mint account data\n * @param programId SPL Token program account\n *\n * @return Unpacked mint\n */\nexport function unpackMint(address, info, programId = TOKEN_PROGRAM_ID) {\n    if (!info)\n        throw new TokenAccountNotFoundError();\n    if (!info.owner.equals(programId))\n        throw new TokenInvalidAccountOwnerError();\n    if (info.data.length < MINT_SIZE)\n        throw new TokenInvalidAccountSizeError();\n    const rawMint = MintLayout.decode(info.data.slice(0, MINT_SIZE));\n    let tlvData = Buffer.alloc(0);\n    if (info.data.length > MINT_SIZE) {\n        if (info.data.length <= ACCOUNT_SIZE)\n            throw new TokenInvalidAccountSizeError();\n        if (info.data.length === MULTISIG_SIZE)\n            throw new TokenInvalidAccountSizeError();\n        if (info.data[ACCOUNT_SIZE] != AccountType.Mint)\n            throw new TokenInvalidMintError();\n        tlvData = info.data.slice(ACCOUNT_SIZE + ACCOUNT_TYPE_SIZE);\n    }\n    return {\n        address,\n        mintAuthority: rawMint.mintAuthorityOption ? rawMint.mintAuthority : null,\n        supply: rawMint.supply,\n        decimals: rawMint.decimals,\n        isInitialized: rawMint.isInitialized,\n        freezeAuthority: rawMint.freezeAuthorityOption ? rawMint.freezeAuthority : null,\n        tlvData,\n    };\n}\n/** Get the minimum lamport balance for a mint to be rent exempt\n *\n * @param connection Connection to use\n * @param commitment Desired level of commitment for querying the state\n *\n * @return Amount of lamports required\n */\nexport async function getMinimumBalanceForRentExemptMint(connection, commitment) {\n    return await getMinimumBalanceForRentExemptMintWithExtensions(connection, [], commitment);\n}\n/** Get the minimum lamport balance for a rent-exempt mint with extensions\n *\n * @param connection Connection to use\n * @param extensions Extension types included in the mint\n * @param commitment Desired level of commitment for querying the state\n *\n * @return Amount of lamports required\n */\nexport async function getMinimumBalanceForRentExemptMintWithExtensions(connection, extensions, commitment) {\n    const mintLen = getMintLen(extensions);\n    return await connection.getMinimumBalanceForRentExemption(mintLen, commitment);\n}\n/**\n * Async version of getAssociatedTokenAddressSync\n * For backwards compatibility\n *\n * @param mint                     Token mint account\n * @param owner                    Owner of the new account\n * @param allowOwnerOffCurve       Allow the owner account to be a PDA (Program Derived Address)\n * @param programId                SPL Token program account\n * @param associatedTokenProgramId SPL Associated Token program account\n *\n * @return Promise containing the address of the associated token account\n */\nexport async function getAssociatedTokenAddress(mint, owner, allowOwnerOffCurve = false, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {\n    if (!allowOwnerOffCurve && !PublicKey.isOnCurve(owner.toBuffer()))\n        throw new TokenOwnerOffCurveError();\n    const [address] = await PublicKey.findProgramAddress([owner.toBuffer(), programId.toBuffer(), mint.toBuffer()], associatedTokenProgramId);\n    return address;\n}\n/**\n * Get the address of the associated token account for a given mint and owner\n *\n * @param mint                     Token mint account\n * @param owner                    Owner of the new account\n * @param allowOwnerOffCurve       Allow the owner account to be a PDA (Program Derived Address)\n * @param programId                SPL Token program account\n * @param associatedTokenProgramId SPL Associated Token program account\n *\n * @return Address of the associated token account\n */\nexport function getAssociatedTokenAddressSync(mint, owner, allowOwnerOffCurve = false, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {\n    if (!allowOwnerOffCurve && !PublicKey.isOnCurve(owner.toBuffer()))\n        throw new TokenOwnerOffCurveError();\n    const [address] = PublicKey.findProgramAddressSync([owner.toBuffer(), programId.toBuffer(), mint.toBuffer()], associatedTokenProgramId);\n    return address;\n}\n//# sourceMappingURL=mint.js.map"],"names":["MintLayout","struct","u32","publicKey","u64","u8","bool","async","getMint","connection","address","commitment","programId","TOKEN_PROGRAM_ID","unpackMint","getAccountInfo","info","TokenAccountNotFoundError","owner","equals","TokenInvalidAccountOwnerError","data","length","MINT_SIZE","TokenInvalidAccountSizeError","rawMint","decode","slice","tlvData","Buffer","alloc","ACCOUNT_SIZE","MULTISIG_SIZE","AccountType","Mint","TokenInvalidMintError","ACCOUNT_TYPE_SIZE","mintAuthority","mintAuthorityOption","supply","decimals","isInitialized","freezeAuthority","freezeAuthorityOption"],"mappings":"otBAmDaA,MAAAA,EAACC,EACVC,CAAAA,EAAI,uBACJC,EAAc,iBACdC,EAAI,UACJC,EAAG,YACHC,EAAU,iBACXJ,EAAA,yBAEHC,EAAA,8BAoBII,eAAkBC,EAAOC,EAAQC,EAAWC,EAAAC,EAAAC,GAGhD,OAAAC,EAAAJ,QAFCD,EAAAM,eAAAL,EAAAC,GAEDC,GAUqBE,SAAAA,EAAIJ,EAAAM,EAAAJ,EAA4BC,GACrD,IAAAG,EAAA,MAAA,IAAAC,EACE,IAAAD,EAAAE,MAAAC,OAAAP,GAAA,MAAA,IAAAQ,EAEE,GAAAJ,EAAMK,KAAOC,OAAGC,EACnB,MAAA,IAAAC,EACG,MAAIC,EAAUzB,EAAS0B,OAAWV,EAACK,KAAAM,MAAA,EAAAJ,IAC/BK,IAAAA,EAASC,EAAAA,OAAKC,MAAU,GAAc,GAAAd,EAAAK,KAAMC,OAAIC,EAAA,CAChD,GAAIP,EAAKK,KAAKC,QAAMS,EAAoB,MAAM,IAAIP,EAClD,GAAIR,EAAKK,KAAKC,SAAAU,EAAmC,MAAE,IAAAR,EACnD,GAAAR,EAAOK,KAAOU,IAAYE,EAAeC,KAChD,MAAA,IAAAC,EAECP,EAAAZ,EAAAK,KAAAM,MAAAI,EAAAK,GAEM,MAAA,CACA1B,UACA2B,cAAUZ,EAAQa,oBAAQb,EAAAY,cAAA,KAC1BE,OAAAd,EAAUc,OAClBC,SAAAf,EAAAe,SACEC,cAAAhB,EAAAgB,cACIC,gBAAAjB,EAAAkB,sBAAAlB,EAAAiB,gBAAA,KACLd","x_google_ignoreList":[0]}

package/dist/esm/node_modules/@solana/spl-token/lib/esm/state/multisig.js

@@ -0,0 +1,2 @@
+import{struct as i,u8 as r}from"@solana/buffer-layout";import{bool as n,publicKey as s}from"@solana/buffer-layout-utils";const e=i([r("m"),r("n"),n("isInitialized"),s("signer1"),s("signer2"),s("signer3"),s("signer4"),s("signer5"),s("signer6"),s("signer7"),s("signer8"),s("signer9"),s("signer10"),s("signer11")]),g=e.span;export{g as MULTISIG_SIZE,e as MultisigLayout};
+//# sourceMappingURL=multisig.js.map

package/dist/esm/node_modules/@solana/spl-token/lib/esm/state/multisig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multisig.js","sources":["../../../../../../../../node_modules/@solana/spl-token/lib/esm/state/multisig.js"],"sourcesContent":["import { struct, u8 } from '@solana/buffer-layout';\nimport { bool, publicKey } from '@solana/buffer-layout-utils';\nimport { TOKEN_PROGRAM_ID } from '../constants.js';\nimport { TokenAccountNotFoundError, TokenInvalidAccountOwnerError, TokenInvalidAccountSizeError } from '../errors.js';\n/** Buffer layout for de/serializing a multisig */\nexport const MultisigLayout = struct([\n    u8('m'),\n    u8('n'),\n    bool('isInitialized'),\n    publicKey('signer1'),\n    publicKey('signer2'),\n    publicKey('signer3'),\n    publicKey('signer4'),\n    publicKey('signer5'),\n    publicKey('signer6'),\n    publicKey('signer7'),\n    publicKey('signer8'),\n    publicKey('signer9'),\n    publicKey('signer10'),\n    publicKey('signer11'),\n]);\n/** Byte length of a multisig */\nexport const MULTISIG_SIZE = MultisigLayout.span;\n/**\n * Retrieve information about a multisig\n *\n * @param connection Connection to use\n * @param address    Multisig account\n * @param commitment Desired level of commitment for querying the state\n * @param programId  SPL Token program account\n *\n * @return Multisig information\n */\nexport async function getMultisig(connection, address, commitment, programId = TOKEN_PROGRAM_ID) {\n    const info = await connection.getAccountInfo(address, commitment);\n    return unpackMultisig(address, info, programId);\n}\n/**\n * Unpack a multisig\n *\n * @param address   Multisig account\n * @param info      Multisig account data\n * @param programId SPL Token program account\n *\n * @return Unpacked multisig\n */\nexport function unpackMultisig(address, info, programId = TOKEN_PROGRAM_ID) {\n    if (!info)\n        throw new TokenAccountNotFoundError();\n    if (!info.owner.equals(programId))\n        throw new TokenInvalidAccountOwnerError();\n    if (info.data.length != MULTISIG_SIZE)\n        throw new TokenInvalidAccountSizeError();\n    const multisig = MultisigLayout.decode(info.data);\n    return { address, ...multisig };\n}\n/** Get the minimum lamport balance for a multisig to be rent exempt\n *\n * @param connection Connection to use\n * @param commitment Desired level of commitment for querying the state\n *\n * @return Amount of lamports required\n */\nexport async function getMinimumBalanceForRentExemptMultisig(connection, commitment) {\n    return await connection.getMinimumBalanceForRentExemption(MULTISIG_SIZE, commitment);\n}\n//# sourceMappingURL=multisig.js.map"],"names":["MultisigLayout","struct","u8","bool","publicKey","MULTISIG_SIZE","span"],"mappings":"+HAkCaA,EAAiBC,EAAoB,CAC9CC,EAAG,KACPA,EAAA,KACEC,EAAA,iBACEC,EAAU,WACbA,EAAA,WACGA,EAAU,WACVA,EAAU,WACVA,EAAU,WACbA,EAAA,WACGA,EAAU,WACZA,EAAA,WACEA,EAAU,WACVA,EAAS,YACTA,EAAU,cAIDC,EAAgBL,EAAeM","x_google_ignoreList":[0]}

package/dist/esm/node_modules/base64-js/index.js

@@ -0,0 +1,2 @@
+import{__exports as r}from"../../_virtual/index3.js";r.byteLength=function(r){var t=h(r),e=t[0],n=t[1];return 3*(e+n)/4-n},r.toByteArray=function(r){var t,o,a=h(r),u=a[0],i=a[1],c=new n(function(r,t,e){return 3*(t+e)/4-e}(0,u,i)),d=0,f=i>0?u-4:u;for(o=0;o<f;o+=4)t=e[r.charCodeAt(o)]<<18|e[r.charCodeAt(o+1)]<<12|e[r.charCodeAt(o+2)]<<6|e[r.charCodeAt(o+3)],c[d++]=t>>16&255,c[d++]=t>>8&255,c[d++]=255&t;2===i&&(t=e[r.charCodeAt(o)]<<2|e[r.charCodeAt(o+1)]>>4,c[d++]=255&t);1===i&&(t=e[r.charCodeAt(o)]<<10|e[r.charCodeAt(o+1)]<<4|e[r.charCodeAt(o+2)]>>2,c[d++]=t>>8&255,c[d++]=255&t);return c},r.fromByteArray=function(r){for(var e,n=r.length,o=n%3,a=[],h=16383,i=0,c=n-o;i<c;i+=h)a.push(u(r,i,i+h>c?c:i+h));1===o?(e=r[n-1],a.push(t[e>>2]+t[e<<4&63]+"==")):2===o&&(e=(r[n-2]<<8)+r[n-1],a.push(t[e>>10]+t[e>>4&63]+t[e<<2&63]+"="));return a.join("")};for(var t=[],e=[],n="undefined"!=typeof Uint8Array?Uint8Array:Array,o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",a=0;a<64;++a)t[a]=o[a],e[o.charCodeAt(a)]=a;function h(r){var t=r.length;if(t%4>0)throw new Error("Invalid string. Length must be a multiple of 4");var e=r.indexOf("=");return-1===e&&(e=t),[e,e===t?0:4-e%4]}function u(r,e,n){for(var o,a,h=[],u=e;u<n;u+=3)o=(r[u]<<16&16711680)+(r[u+1]<<8&65280)+(255&r[u+2]),h.push(t[(a=o)>>18&63]+t[a>>12&63]+t[a>>6&63]+t[63&a]);return h.join("")}e["-".charCodeAt(0)]=62,e["_".charCodeAt(0)]=63;export{r as default};
+//# sourceMappingURL=index.js.map

package/dist/esm/node_modules/base64-js/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../node_modules/base64-js/index.js"],"sourcesContent":["'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n"],"names":["base64Js","byteLength","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","tmp","i","arr","Arr","_byteLength","curByte","len","revLookup","charCodeAt","fromByteArray","uint8","length","extraBytes","parts","maxChunkLength","len2","push","encodeChunk","lookup","join","Uint8Array","Array","code","Error","indexOf","start","end","num","output"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/borsh/lib/esm/buffer.js

@@ -0,0 +1,2 @@
+var t=function(){function t(){this.offset=0,this.buffer_size=256,this.buffer=new ArrayBuffer(this.buffer_size),this.view=new DataView(this.buffer)}return t.prototype.resize_if_necessary=function(t){if(this.buffer_size-this.offset<t){this.buffer_size=Math.max(2*this.buffer_size,this.buffer_size+t);var e=new ArrayBuffer(this.buffer_size);new Uint8Array(e).set(new Uint8Array(this.buffer)),this.buffer=e,this.view=new DataView(e)}},t.prototype.get_used_buffer=function(){return new Uint8Array(this.buffer).slice(0,this.offset)},t.prototype.store_value=function(t,e){var s=e.substring(1),f=parseInt(s)/8;this.resize_if_necessary(f);var i="f"===e[0]?"setFloat".concat(s):"i"===e[0]?"setInt".concat(s):"setUint".concat(s);this.view[i](this.offset,t,!0),this.offset+=f},t.prototype.store_bytes=function(t){this.resize_if_necessary(t.length),new Uint8Array(this.buffer).set(new Uint8Array(t),this.offset),this.offset+=t.length},t}(),e=function(){function t(t){this.offset=0,this.buffer_size=t.length,this.buffer=new ArrayBuffer(t.length),new Uint8Array(this.buffer).set(t),this.view=new DataView(this.buffer)}return t.prototype.assert_enough_buffer=function(t){if(this.offset+t>this.buffer.byteLength)throw new Error("Error in schema, the buffer is smaller than expected")},t.prototype.consume_value=function(t){var e=t.substring(1),s=parseInt(e)/8;this.assert_enough_buffer(s);var f="f"===t[0]?"getFloat".concat(e):"i"===t[0]?"getInt".concat(e):"getUint".concat(e),i=this.view[f](this.offset,!0);return this.offset+=s,i},t.prototype.consume_bytes=function(t){this.assert_enough_buffer(t);var e=this.buffer.slice(this.offset,this.offset+t);return this.offset+=t,e},t}();export{e as DecodeBuffer,t as EncodeBuffer};
+//# sourceMappingURL=buffer.js.map

package/dist/esm/node_modules/borsh/lib/esm/buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.js","sources":["../../../../../../node_modules/borsh/lib/esm/buffer.js"],"sourcesContent":["var EncodeBuffer = /** @class */ (function () {\n    function EncodeBuffer() {\n        this.offset = 0;\n        this.buffer_size = 256;\n        this.buffer = new ArrayBuffer(this.buffer_size);\n        this.view = new DataView(this.buffer);\n    }\n    EncodeBuffer.prototype.resize_if_necessary = function (needed_space) {\n        if (this.buffer_size - this.offset < needed_space) {\n            this.buffer_size = Math.max(this.buffer_size * 2, this.buffer_size + needed_space);\n            var new_buffer = new ArrayBuffer(this.buffer_size);\n            new Uint8Array(new_buffer).set(new Uint8Array(this.buffer));\n            this.buffer = new_buffer;\n            this.view = new DataView(new_buffer);\n        }\n    };\n    EncodeBuffer.prototype.get_used_buffer = function () {\n        return new Uint8Array(this.buffer).slice(0, this.offset);\n    };\n    EncodeBuffer.prototype.store_value = function (value, type) {\n        var bSize = type.substring(1);\n        var size = parseInt(bSize) / 8;\n        this.resize_if_necessary(size);\n        var toCall = type[0] === 'f' ? \"setFloat\".concat(bSize) : type[0] === 'i' ? \"setInt\".concat(bSize) : \"setUint\".concat(bSize);\n        this.view[toCall](this.offset, value, true);\n        this.offset += size;\n    };\n    EncodeBuffer.prototype.store_bytes = function (from) {\n        this.resize_if_necessary(from.length);\n        new Uint8Array(this.buffer).set(new Uint8Array(from), this.offset);\n        this.offset += from.length;\n    };\n    return EncodeBuffer;\n}());\nexport { EncodeBuffer };\nvar DecodeBuffer = /** @class */ (function () {\n    function DecodeBuffer(buf) {\n        this.offset = 0;\n        this.buffer_size = buf.length;\n        this.buffer = new ArrayBuffer(buf.length);\n        new Uint8Array(this.buffer).set(buf);\n        this.view = new DataView(this.buffer);\n    }\n    DecodeBuffer.prototype.assert_enough_buffer = function (size) {\n        if (this.offset + size > this.buffer.byteLength) {\n            throw new Error('Error in schema, the buffer is smaller than expected');\n        }\n    };\n    DecodeBuffer.prototype.consume_value = function (type) {\n        var bSize = type.substring(1);\n        var size = parseInt(bSize) / 8;\n        this.assert_enough_buffer(size);\n        var toCall = type[0] === 'f' ? \"getFloat\".concat(bSize) : type[0] === 'i' ? \"getInt\".concat(bSize) : \"getUint\".concat(bSize);\n        var ret = this.view[toCall](this.offset, true);\n        this.offset += size;\n        return ret;\n    };\n    DecodeBuffer.prototype.consume_bytes = function (size) {\n        this.assert_enough_buffer(size);\n        var ret = this.buffer.slice(this.offset, this.offset + size);\n        this.offset += size;\n        return ret;\n    };\n    return DecodeBuffer;\n}());\nexport { DecodeBuffer };\n"],"names":["EncodeBuffer","this","offset","buffer_size","buffer","ArrayBuffer","view","DataView","prototype","resize_if_necessary","needed_space","Math","max","new_buffer","Uint8Array","set","get_used_buffer","slice","store_value","value","type","bSize","substring","size","parseInt","toCall","concat","store_bytes","from","length","DecodeBuffer","buf","assert_enough_buffer","byteLength","Error","consume_value","ret","consume_bytes"],"mappings":"AAAIA,IAAAA,EAA8B,WAC9B,SAASA,IACLC,KAAKC,OAAS,EACdD,KAAKE,YAAc,IACnBF,KAAKG,OAAS,IAAIC,YAAYJ,KAAKE,aACnCF,KAAKK,KAAO,IAAIC,SAASN,KAAKG,OAClC,CA0BA,OAzBAJ,EAAaQ,UAAUC,oBAAsB,SAAUC,GACnD,GAAIT,KAAKE,YAAcF,KAAKC,OAASQ,EAAc,CAC/CT,KAAKE,YAAcQ,KAAKC,IAAuB,EAAnBX,KAAKE,YAAiBF,KAAKE,YAAcO,GACrE,IAAIG,EAAa,IAAIR,YAAYJ,KAAKE,aACtC,IAAIW,WAAWD,GAAYE,IAAI,IAAID,WAAWb,KAAKG,SACnDH,KAAKG,OAASS,EACdZ,KAAKK,KAAO,IAAIC,SAASM,EAC7B,CACH,EACDb,EAAaQ,UAAUQ,gBAAkB,WACrC,OAAO,IAAIF,WAAWb,KAAKG,QAAQa,MAAM,EAAGhB,KAAKC,OACpD,EACDF,EAAaQ,UAAUU,YAAc,SAAUC,EAAOC,GAClD,IAAIC,EAAQD,EAAKE,UAAU,GACvBC,EAAOC,SAASH,GAAS,EAC7BpB,KAAKQ,oBAAoBc,GACzB,IAAIE,EAAqB,MAAZL,EAAK,GAAa,WAAWM,OAAOL,GAAqB,MAAZD,EAAK,GAAa,SAASM,OAAOL,GAAS,UAAUK,OAAOL,GACtHpB,KAAKK,KAAKmB,GAAQxB,KAAKC,OAAQiB,GAAO,GACtClB,KAAKC,QAAUqB,CAClB,EACDvB,EAAaQ,UAAUmB,YAAc,SAAUC,GAC3C3B,KAAKQ,oBAAoBmB,EAAKC,QAC9B,IAAIf,WAAWb,KAAKG,QAAQW,IAAI,IAAID,WAAWc,GAAO3B,KAAKC,QAC3DD,KAAKC,QAAU0B,EAAKC,MACvB,EACM7B,CACX,CAjCkC,GAmC9B8B,EAA8B,WAC9B,SAASA,EAAaC,GAClB9B,KAAKC,OAAS,EACdD,KAAKE,YAAc4B,EAAIF,OACvB5B,KAAKG,OAAS,IAAIC,YAAY0B,EAAIF,QAClC,IAAIf,WAAWb,KAAKG,QAAQW,IAAIgB,GAChC9B,KAAKK,KAAO,IAAIC,SAASN,KAAKG,OAClC,CAqBA,OApBA0B,EAAatB,UAAUwB,qBAAuB,SAAUT,GACpD,GAAItB,KAAKC,OAASqB,EAAOtB,KAAKG,OAAO6B,WACjC,MAAM,IAAIC,MAAM,uDAEvB,EACDJ,EAAatB,UAAU2B,cAAgB,SAAUf,GAC7C,IAAIC,EAAQD,EAAKE,UAAU,GACvBC,EAAOC,SAASH,GAAS,EAC7BpB,KAAK+B,qBAAqBT,GAC1B,IAAIE,EAAqB,MAAZL,EAAK,GAAa,WAAWM,OAAOL,GAAqB,MAAZD,EAAK,GAAa,SAASM,OAAOL,GAAS,UAAUK,OAAOL,GAClHe,EAAMnC,KAAKK,KAAKmB,GAAQxB,KAAKC,QAAQ,GAEzC,OADAD,KAAKC,QAAUqB,EACRa,CACV,EACDN,EAAatB,UAAU6B,cAAgB,SAAUd,GAC7CtB,KAAK+B,qBAAqBT,GAC1B,IAAIa,EAAMnC,KAAKG,OAAOa,MAAMhB,KAAKC,OAAQD,KAAKC,OAASqB,GAEvD,OADAtB,KAAKC,QAAUqB,EACRa,CACV,EACMN,CACX,CA7BkC","x_google_ignoreList":[0]}

package/dist/esm/node_modules/borsh/lib/esm/deserialize.js

@@ -0,0 +1,2 @@
+import{integers as e}from"./types.js";import{DecodeBuffer as t}from"./buffer.js";var r=function(){function r(e){this.buffer=new t(e)}return r.prototype.decode=function(e){return this.decode_value(e)},r.prototype.decode_value=function(t){if("string"==typeof t){if(e.includes(t))return this.decode_integer(t);if("string"===t)return this.decode_string();if("bool"===t)return this.decode_boolean()}if("object"==typeof t){if("option"in t)return this.decode_option(t);if("enum"in t)return this.decode_enum(t);if("array"in t)return this.decode_array(t);if("set"in t)return this.decode_set(t);if("map"in t)return this.decode_map(t);if("struct"in t)return this.decode_struct(t)}throw new Error("Unsupported type: ".concat(t))},r.prototype.decode_integer=function(e){var t=parseInt(e.substring(1));return t<=32||"f64"==e?this.buffer.consume_value(e):this.decode_bigint(t,e.startsWith("i"))},r.prototype.decode_bigint=function(e,t){void 0===t&&(t=!1);var r=e/8,o=new Uint8Array(this.buffer.consume_bytes(r)),n=o.reduceRight((function(e,t){return e+t.toString(16).padStart(2,"0")}),"");return t&&o[r-1]?BigInt.asIntN(e,BigInt("0x".concat(n))):BigInt("0x".concat(n))},r.prototype.decode_string=function(){for(var e=this.decode_integer("u32"),t=new Uint8Array(this.buffer.consume_bytes(e)),r=[],o=0;o<e;++o){var n=t[o];if(n<128)r.push(n);else if(n<224)r.push((31&n)<<6|63&t[++o]);else if(n<240)r.push((15&n)<<12|(63&t[++o])<<6|63&t[++o]);else{var i=(7&n)<<18|(63&t[++o])<<12|(63&t[++o])<<6|63&t[++o];r.push(i)}}return String.fromCodePoint.apply(String,r)},r.prototype.decode_boolean=function(){return this.buffer.consume_value("u8")>0},r.prototype.decode_option=function(e){var t=this.buffer.consume_value("u8");if(1===t)return this.decode_value(e.option);if(0!==t)throw new Error("Invalid option ".concat(t));return null},r.prototype.decode_enum=function(e){var t,r=this.buffer.consume_value("u8");if(r>e.enum.length)throw new Error("Enum option ".concat(r," is not available"));var o=e.enum[r].struct,n=Object.keys(o)[0];return(t={})[n]=this.decode_value(o[n]),t},r.prototype.decode_array=function(e){for(var t=[],r=e.array.len?e.array.len:this.decode_integer("u32"),o=0;o<r;++o)t.push(this.decode_value(e.array.type));return t},r.prototype.decode_set=function(e){for(var t=this.decode_integer("u32"),r=new Set,o=0;o<t;++o)r.add(this.decode_value(e.set));return r},r.prototype.decode_map=function(e){for(var t=this.decode_integer("u32"),r=new Map,o=0;o<t;++o){var n=this.decode_value(e.map.key),i=this.decode_value(e.map.value);r.set(n,i)}return r},r.prototype.decode_struct=function(e){var t={};for(var r in e.struct)t[r]=this.decode_value(e.struct[r]);return t},r}();export{r as BorshDeserializer};
+//# sourceMappingURL=deserialize.js.map

package/dist/esm/node_modules/borsh/lib/esm/deserialize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deserialize.js","sources":["../../../../../../node_modules/borsh/lib/esm/deserialize.js"],"sourcesContent":["import { integers } from './types.js';\nimport { DecodeBuffer } from './buffer.js';\nvar BorshDeserializer = /** @class */ (function () {\n    function BorshDeserializer(bufferArray) {\n        this.buffer = new DecodeBuffer(bufferArray);\n    }\n    BorshDeserializer.prototype.decode = function (schema) {\n        return this.decode_value(schema);\n    };\n    BorshDeserializer.prototype.decode_value = function (schema) {\n        if (typeof schema === 'string') {\n            if (integers.includes(schema))\n                return this.decode_integer(schema);\n            if (schema === 'string')\n                return this.decode_string();\n            if (schema === 'bool')\n                return this.decode_boolean();\n        }\n        if (typeof schema === 'object') {\n            if ('option' in schema)\n                return this.decode_option(schema);\n            if ('enum' in schema)\n                return this.decode_enum(schema);\n            if ('array' in schema)\n                return this.decode_array(schema);\n            if ('set' in schema)\n                return this.decode_set(schema);\n            if ('map' in schema)\n                return this.decode_map(schema);\n            if ('struct' in schema)\n                return this.decode_struct(schema);\n        }\n        throw new Error(\"Unsupported type: \".concat(schema));\n    };\n    BorshDeserializer.prototype.decode_integer = function (schema) {\n        var size = parseInt(schema.substring(1));\n        if (size <= 32 || schema == 'f64') {\n            return this.buffer.consume_value(schema);\n        }\n        return this.decode_bigint(size, schema.startsWith('i'));\n    };\n    BorshDeserializer.prototype.decode_bigint = function (size, signed) {\n        if (signed === void 0) { signed = false; }\n        var buffer_len = size / 8;\n        var buffer = new Uint8Array(this.buffer.consume_bytes(buffer_len));\n        var bits = buffer.reduceRight(function (r, x) { return r + x.toString(16).padStart(2, '0'); }, '');\n        if (signed && buffer[buffer_len - 1]) {\n            return BigInt.asIntN(size, BigInt(\"0x\".concat(bits)));\n        }\n        return BigInt(\"0x\".concat(bits));\n    };\n    BorshDeserializer.prototype.decode_string = function () {\n        var len = this.decode_integer('u32');\n        var buffer = new Uint8Array(this.buffer.consume_bytes(len));\n        // decode utf-8 string without using TextDecoder\n        // first get all bytes to single byte code points\n        var codePoints = [];\n        for (var i = 0; i < len; ++i) {\n            var byte = buffer[i];\n            if (byte < 0x80) {\n                codePoints.push(byte);\n            }\n            else if (byte < 0xE0) {\n                codePoints.push(((byte & 0x1F) << 6) | (buffer[++i] & 0x3F));\n            }\n            else if (byte < 0xF0) {\n                codePoints.push(((byte & 0x0F) << 12) | ((buffer[++i] & 0x3F) << 6) | (buffer[++i] & 0x3F));\n            }\n            else {\n                var codePoint = ((byte & 0x07) << 18) | ((buffer[++i] & 0x3F) << 12) | ((buffer[++i] & 0x3F) << 6) | (buffer[++i] & 0x3F);\n                codePoints.push(codePoint);\n            }\n        }\n        // then decode code points to utf-8\n        return String.fromCodePoint.apply(String, codePoints);\n    };\n    BorshDeserializer.prototype.decode_boolean = function () {\n        return this.buffer.consume_value('u8') > 0;\n    };\n    BorshDeserializer.prototype.decode_option = function (schema) {\n        var option = this.buffer.consume_value('u8');\n        if (option === 1) {\n            return this.decode_value(schema.option);\n        }\n        if (option !== 0) {\n            throw new Error(\"Invalid option \".concat(option));\n        }\n        return null;\n    };\n    BorshDeserializer.prototype.decode_enum = function (schema) {\n        var _a;\n        var valueIndex = this.buffer.consume_value('u8');\n        if (valueIndex > schema[\"enum\"].length) {\n            throw new Error(\"Enum option \".concat(valueIndex, \" is not available\"));\n        }\n        var struct = schema[\"enum\"][valueIndex].struct;\n        var key = Object.keys(struct)[0];\n        return _a = {}, _a[key] = this.decode_value(struct[key]), _a;\n    };\n    BorshDeserializer.prototype.decode_array = function (schema) {\n        var result = [];\n        var len = schema.array.len ? schema.array.len : this.decode_integer('u32');\n        for (var i = 0; i < len; ++i) {\n            result.push(this.decode_value(schema.array.type));\n        }\n        return result;\n    };\n    BorshDeserializer.prototype.decode_set = function (schema) {\n        var len = this.decode_integer('u32');\n        var result = new Set();\n        for (var i = 0; i < len; ++i) {\n            result.add(this.decode_value(schema.set));\n        }\n        return result;\n    };\n    BorshDeserializer.prototype.decode_map = function (schema) {\n        var len = this.decode_integer('u32');\n        var result = new Map();\n        for (var i = 0; i < len; ++i) {\n            var key = this.decode_value(schema.map.key);\n            var value = this.decode_value(schema.map.value);\n            result.set(key, value);\n        }\n        return result;\n    };\n    BorshDeserializer.prototype.decode_struct = function (schema) {\n        var result = {};\n        for (var key in schema.struct) {\n            result[key] = this.decode_value(schema.struct[key]);\n        }\n        return result;\n    };\n    return BorshDeserializer;\n}());\nexport { BorshDeserializer };\n"],"names":["BorshDeserializer","bufferArray","this","buffer","DecodeBuffer","prototype","decode","schema","decode_value","integers","includes","decode_integer","decode_string","decode_boolean","decode_option","decode_enum","decode_array","decode_set","decode_map","decode_struct","Error","concat","size","parseInt","substring","consume_value","decode_bigint","startsWith","signed","buffer_len","Uint8Array","consume_bytes","bits","reduceRight","r","x","toString","padStart","BigInt","asIntN","len","codePoints","i","byte","push","codePoint","String","fromCodePoint","apply","option","_a","valueIndex","length","struct","key","Object","keys","result","array","type","Set","add","set","Map","map","value"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/borsh/lib/esm/index.js

@@ -0,0 +1,2 @@
+import{BorshSerializer as e}from"./serialize.js";import{BorshDeserializer as o}from"./deserialize.js";import{validate_schema as r}from"./utils.js";function i(o,i,n){return void 0===n&&(n=!0),n&&r(o),new e(n).encode(i,o)}function n(e,i,n){return void 0===n&&(n=!0),n&&r(e),new o(i).decode(e)}export{n as deserialize,i as serialize};
+//# sourceMappingURL=index.js.map

package/dist/esm/node_modules/borsh/lib/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../node_modules/borsh/lib/esm/index.js"],"sourcesContent":["import { BorshSerializer } from './serialize.js';\nimport { BorshDeserializer } from './deserialize.js';\nimport * as utils from './utils.js';\nexport function serialize(schema, value, validate) {\n    if (validate === void 0) { validate = true; }\n    if (validate)\n        utils.validate_schema(schema);\n    var serializer = new BorshSerializer(validate);\n    return serializer.encode(value, schema);\n}\nexport function deserialize(schema, buffer, validate) {\n    if (validate === void 0) { validate = true; }\n    if (validate)\n        utils.validate_schema(schema);\n    var deserializer = new BorshDeserializer(buffer);\n    return deserializer.decode(schema);\n}\n"],"names":["serialize","schema","value","validate","utils","BorshSerializer","encode","deserialize","buffer","BorshDeserializer","decode"],"mappings":"mJAGO,SAASA,EAAUC,EAAQC,EAAOC,GAKrC,YAJiB,IAAbA,IAAuBA,GAAW,GAClCA,GACAC,EAAsBH,GACT,IAAII,EAAgBF,GACnBG,OAAOJ,EAAOD,EACpC,CACO,SAASM,EAAYN,EAAQO,EAAQL,GAKxC,YAJiB,IAAbA,IAAuBA,GAAW,GAClCA,GACAC,EAAsBH,GACP,IAAIQ,EAAkBD,GACrBE,OAAOT,EAC/B","x_google_ignoreList":[0]}

package/dist/esm/node_modules/borsh/lib/esm/serialize.js

@@ -0,0 +1,2 @@
+import{integers as e}from"./types.js";import{EncodeBuffer as t}from"./buffer.js";import{expect_type as n,expect_bigint as o,expect_enum as r,isArrayLike as i,expect_same_size as s}from"./utils.js";var c=function(){function c(e){this.encoded=new t,this.fieldPath=["value"],this.checkTypes=e}return c.prototype.encode=function(e,t){return this.encode_value(e,t),this.encoded.get_used_buffer()},c.prototype.encode_value=function(t,n){if("string"==typeof n){if(e.includes(n))return this.encode_integer(t,n);if("string"===n)return this.encode_string(t);if("bool"===n)return this.encode_boolean(t)}if("object"==typeof n){if("option"in n)return this.encode_option(t,n);if("enum"in n)return this.encode_enum(t,n);if("array"in n)return this.encode_array(t,n);if("set"in n)return this.encode_set(t,n);if("map"in n)return this.encode_map(t,n);if("struct"in n)return this.encode_struct(t,n)}},c.prototype.encode_integer=function(e,t){var r=parseInt(t.substring(1));r<=32||"f64"==t?(this.checkTypes&&n(e,"number",this.fieldPath),this.encoded.store_value(e,t)):(this.checkTypes&&o(e,this.fieldPath),this.encode_bigint(BigInt(e),r))},c.prototype.encode_bigint=function(e,t){for(var n=t/8,o=new Uint8Array(n),r=0;r<n;r++)o[r]=Number(e&BigInt(255)),e>>=BigInt(8);this.encoded.store_bytes(new Uint8Array(o))},c.prototype.encode_string=function(e){this.checkTypes&&n(e,"string",this.fieldPath);for(var t=e,o=[],r=0;r<t.length;r++){var i=t.charCodeAt(r);i<128?o.push(i):i<2048?o.push(192|i>>6,128|63&i):i<55296||i>=57344?o.push(224|i>>12,128|i>>6&63,128|63&i):(r++,i=65536+((1023&i)<<10|1023&t.charCodeAt(r)),o.push(240|i>>18,128|i>>12&63,128|i>>6&63,128|63&i))}this.encoded.store_value(o.length,"u32"),this.encoded.store_bytes(new Uint8Array(o))},c.prototype.encode_boolean=function(e){this.checkTypes&&n(e,"boolean",this.fieldPath),this.encoded.store_value(e?1:0,"u8")},c.prototype.encode_option=function(e,t){null==e?this.encoded.store_value(0,"u8"):(this.encoded.store_value(1,"u8"),this.encode_value(e,t.option))},c.prototype.encode_enum=function(e,t){this.checkTypes&&r(e,this.fieldPath);for(var n=Object.keys(e)[0],o=0;o<t.enum.length;o++){var i=t.enum[o];if(n===Object.keys(i.struct)[0])return this.encoded.store_value(o,"u8"),this.encode_struct(e,i)}throw new Error("Enum key (".concat(n,") not found in enum schema: ").concat(JSON.stringify(t)," at ").concat(this.fieldPath.join(".")))},c.prototype.encode_array=function(e,t){if(i(e))return this.encode_arraylike(e,t);if(e instanceof ArrayBuffer)return this.encode_buffer(e,t);throw new Error("Expected Array-like not ".concat(typeof e,"(").concat(e,") at ").concat(this.fieldPath.join(".")))},c.prototype.encode_arraylike=function(e,t){t.array.len?s(e.length,t.array.len,this.fieldPath):this.encoded.store_value(e.length,"u32");for(var n=0;n<e.length;n++)this.encode_value(e[n],t.array.type)},c.prototype.encode_buffer=function(e,t){t.array.len?s(e.byteLength,t.array.len,this.fieldPath):this.encoded.store_value(e.byteLength,"u32"),this.encoded.store_bytes(new Uint8Array(e))},c.prototype.encode_set=function(e,t){this.checkTypes&&n(e,"object",this.fieldPath);var o=e instanceof Set?Array.from(e.values()):Object.values(e);this.encoded.store_value(o.length,"u32");for(var r=0,i=o;r<i.length;r++){var s=i[r];this.encode_value(s,t.set)}},c.prototype.encode_map=function(e,t){this.checkTypes&&n(e,"object",this.fieldPath);var o=e instanceof Map,r=o?Array.from(e.keys()):Object.keys(e);this.encoded.store_value(r.length,"u32");for(var i=0,s=r;i<s.length;i++){var c=s[i];this.encode_value(c,t.map.key),this.encode_value(o?e.get(c):e[c],t.map.value)}},c.prototype.encode_struct=function(e,t){this.checkTypes&&n(e,"object",this.fieldPath);for(var o=0,r=Object.keys(t.struct);o<r.length;o++){var i=r[o];this.fieldPath.push(i),this.encode_value(e[i],t.struct[i]),this.fieldPath.pop()}},c}();export{c as BorshSerializer};
+//# sourceMappingURL=serialize.js.map