@nostrwatch/utils 0.2.0

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.1/node_modules/@noble/hashes/esm/_sha2.esm.js

@@ -0,0 +1,2 @@
+import t from"./_assert.esm.js";import{Hash as s,createView as e,toBytes as i}from"./utils.esm.js";class SHA2 extends s{constructor(t,s,i,n){super(),this.blockLen=t,this.outputLen=s,this.padOffset=i,this.isLE=n,this.finished=!1,this.length=0,this.pos=0,this.destroyed=!1,this.buffer=new Uint8Array(t),this.view=e(this.buffer)}update(s){t.exists(this);const{view:n,buffer:o,blockLen:h}=this,r=(s=i(s)).length;for(let t=0;t<r;){const i=Math.min(h-this.pos,r-t);if(i!==h)o.set(s.subarray(t,t+i),this.pos),this.pos+=i,t+=i,this.pos===h&&(this.process(n,0),this.pos=0);else{const i=e(s);for(;h<=r-t;t+=h)this.process(i,t)}}return this.length+=s.length,this.roundClean(),this}digestInto(s){t.exists(this),t.output(s,this),this.finished=!0;const{buffer:i,view:n,blockLen:o,isLE:h}=this;let{pos:r}=this;i[r++]=128,this.buffer.subarray(r).fill(0),this.padOffset>o-r&&(this.process(n,0),r=0);for(let t=r;t<o;t++)i[t]=0;!function setBigUint64(t,s,e,i){if("function"==typeof t.setBigUint64)return t.setBigUint64(s,e,i);const n=BigInt(32),o=BigInt(4294967295),h=Number(e>>n&o),r=Number(e&o),f=i?4:0,u=i?0:4;t.setUint32(s+f,h,i),t.setUint32(s+u,r,i)}(n,o-8,BigInt(8*this.length),h),this.process(n,0);const f=e(s),u=this.outputLen;if(u%4)throw new Error("_sha2: outputLen should be aligned to 32bit");const c=u/4,p=this.get();if(c>p.length)throw new Error("_sha2: outputLen bigger than state");for(let t=0;t<c;t++)f.setUint32(4*t,p[t],h)}digest(){const{buffer:t,outputLen:s}=this;this.digestInto(t);const e=t.slice(0,s);return this.destroy(),e}_cloneInto(t){t||(t=new this.constructor),t.set(...this.get());const{blockLen:s,buffer:e,length:i,finished:n,destroyed:o,pos:h}=this;return t.length=i,t.pos=h,t.finished=n,t.destroyed=o,i%s&&t.buffer.set(e),t}}export{SHA2};
+//# sourceMappingURL=_sha2.esm.js.map

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.1/node_modules/@noble/hashes/esm/_sha2.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_sha2.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.1/node_modules/@noble/hashes/esm/_sha2.js"],"sourcesContent":["import assert from './_assert.js';\nimport { Hash, createView, toBytes } from './utils.js';\n// Polyfill for Safari 14\nfunction 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// Base SHA2 class (RFC 6234)\nexport class SHA2 extends Hash {\n    constructor(blockLen, outputLen, padOffset, isLE) {\n        super();\n        this.blockLen = blockLen;\n        this.outputLen = outputLen;\n        this.padOffset = padOffset;\n        this.isLE = isLE;\n        this.finished = false;\n        this.length = 0;\n        this.pos = 0;\n        this.destroyed = false;\n        this.buffer = new Uint8Array(blockLen);\n        this.view = createView(this.buffer);\n    }\n    update(data) {\n        assert.exists(this);\n        const { view, buffer, blockLen } = this;\n        data = toBytes(data);\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            // 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        assert.exists(this);\n        assert.output(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        this.buffer.subarray(pos).fill(0);\n        // we have less than padOffset left in buffer, so we cannot put length in 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.length = length;\n        to.pos = pos;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        if (length % blockLen)\n            to.buffer.set(buffer);\n        return to;\n    }\n}\n//# sourceMappingURL=_sha2.js.map"],"names":["SHA2","Hash","constructor","blockLen","outputLen","padOffset","isLE","super","this","finished","length","pos","destroyed","buffer","Uint8Array","view","createView","update","data","assert","exists","len","toBytes","take","Math","min","set","subarray","process","dataView","roundClean","digestInto","out","output","fill","i","setBigUint64","byteOffset","value","_32n","BigInt","_u32_max","wh","Number","wl","h","l","setUint32","oview","Error","outLen","state","get","digest","res","slice","destroy","_cloneInto","to"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.1/node_modules/@noble/hashes/esm/sha256.amd.js

@@ -0,0 +1,2 @@
+define(["exports","./_sha2.amd","./utils.amd"],(function(t,s,r){"use strict";const Maj=(t,s,r)=>t&s^t&r^s&r,i=new Uint32Array([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]),h=new Uint32Array([1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225]),o=new Uint32Array(64);class SHA256 extends s.SHA2{constructor(){super(64,32,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:s,C:r,D:i,E:h,F:o,G:e,H:n}=this;return[t,s,r,i,h,o,e,n]}set(t,s,r,i,h,o,e,n){this.A=0|t,this.B=0|s,this.C=0|r,this.D=0|i,this.E=0|h,this.F=0|o,this.G=0|e,this.H=0|n}process(t,s){for(let r=0;r<16;r++,s+=4)o[r]=t.getUint32(s,!1);for(let t=16;t<64;t++){const s=o[t-15],i=o[t-2],h=r.rotr(s,7)^r.rotr(s,18)^s>>>3,e=r.rotr(i,17)^r.rotr(i,19)^i>>>10;o[t]=e+o[t-7]+h+o[t-16]|0}let{A:h,B:e,C:n,D:c,E:A,F:u,G:a,H:l}=this;for(let t=0;t<64;t++){const s=l+(r.rotr(A,6)^r.rotr(A,11)^r.rotr(A,25))+((H=A)&u^~H&a)+i[t]+o[t]|0,f=(r.rotr(h,2)^r.rotr(h,13)^r.rotr(h,22))+Maj(h,e,n)|0;l=a,a=u,u=A,A=c+s|0,c=n,n=e,e=h,h=s+f|0}var H;h=h+this.A|0,e=e+this.B|0,n=n+this.C|0,c=c+this.D|0,A=A+this.E|0,u=u+this.F|0,a=a+this.G|0,l=l+this.H|0,this.set(h,e,n,c,A,u,a,l)}roundClean(){o.fill(0)}destroy(){this.set(0,0,0,0,0,0,0,0),this.buffer.fill(0)}}class SHA224 extends SHA256{constructor(){super(),this.A=-1056596264,this.B=914150663,this.C=812702999,this.D=-150054599,this.E=-4191439,this.F=1750603025,this.G=1694076839,this.H=-1090891868,this.outputLen=28}}const e=r.wrapConstructor((()=>new SHA256));r.wrapConstructor((()=>new SHA224)),t.sha256=e}));
+//# sourceMappingURL=sha256.amd.js.map

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.1/node_modules/@noble/hashes/esm/sha256.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.amd.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.1/node_modules/@noble/hashes/esm/sha256.js"],"sourcesContent":["import { SHA2 } from './_sha2.js';\nimport { rotr, wrapConstructor } from './utils.js';\n// Choice: a ? b : c\nconst Chi = (a, b, c) => (a & b) ^ (~a & c);\n// Majority function, true if any two inpust is true\nconst Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);\n// Round constants:\n// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)\n// prettier-ignore\nconst SHA256_K = new Uint32Array([\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// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n// prettier-ignore\nconst IV = new Uint32Array([\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n]);\n// Temporary buffer, not used to store anything between runs\n// Named this way because it matches specification.\nconst SHA256_W = new Uint32Array(64);\nclass SHA256 extends SHA2 {\n    constructor() {\n        super(64, 32, 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 = IV[0] | 0;\n        this.B = IV[1] | 0;\n        this.C = IV[2] | 0;\n        this.D = IV[3] | 0;\n        this.E = IV[4] | 0;\n        this.F = IV[5] | 0;\n        this.G = IV[6] | 0;\n        this.H = 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        SHA256_W.fill(0);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n        this.buffer.fill(0);\n    }\n}\n// Constants from https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf\nclass SHA224 extends SHA256 {\n    constructor() {\n        super();\n        this.A = 0xc1059ed8 | 0;\n        this.B = 0x367cd507 | 0;\n        this.C = 0x3070dd17 | 0;\n        this.D = 0xf70e5939 | 0;\n        this.E = 0xffc00b31 | 0;\n        this.F = 0x68581511 | 0;\n        this.G = 0x64f98fa7 | 0;\n        this.H = 0xbefa4fa4 | 0;\n        this.outputLen = 28;\n    }\n}\n/**\n * SHA2-256 hash function\n * @param message - data that would be hashed\n */\nexport const sha256 = wrapConstructor(() => new SHA256());\nexport const sha224 = wrapConstructor(() => new SHA224());\n//# sourceMappingURL=sha256.js.map"],"names":["Maj","a","b","c","SHA256_K","Uint32Array","IV","SHA256_W","SHA256","SHA2","constructor","super","this","A","B","C","D","E","F","G","H","get","set","process","view","offset","i","getUint32","W15","W2","s0","rotr","s1","T1","T2","roundClean","fill","destroy","buffer","SHA224","outputLen","sha256","wrapConstructor"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.1/node_modules/@noble/hashes/esm/sha256.esm.js

@@ -0,0 +1,2 @@
+import{SHA2 as t}from"./_sha2.esm.js";import{wrapConstructor as s,rotr as i}from"./utils.esm.js";const Maj=(t,s,i)=>t&s^t&i^s&i,h=new Uint32Array([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]),e=new Uint32Array([1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225]),r=new Uint32Array(64);class SHA256 extends t{constructor(){super(64,32,8,!1),this.A=0|e[0],this.B=0|e[1],this.C=0|e[2],this.D=0|e[3],this.E=0|e[4],this.F=0|e[5],this.G=0|e[6],this.H=0|e[7]}get(){const{A:t,B:s,C:i,D:h,E:e,F:r,G:n,H:o}=this;return[t,s,i,h,e,r,n,o]}set(t,s,i,h,e,r,n,o){this.A=0|t,this.B=0|s,this.C=0|i,this.D=0|h,this.E=0|e,this.F=0|r,this.G=0|n,this.H=0|o}process(t,s){for(let i=0;i<16;i++,s+=4)r[i]=t.getUint32(s,!1);for(let t=16;t<64;t++){const s=r[t-15],h=r[t-2],e=i(s,7)^i(s,18)^s>>>3,n=i(h,17)^i(h,19)^h>>>10;r[t]=n+r[t-7]+e+r[t-16]|0}let{A:e,B:n,C:o,D:A,E:c,F:l,G:H,H:u}=this;for(let t=0;t<64;t++){const s=u+(i(c,6)^i(c,11)^i(c,25))+((f=c)&l^~f&H)+h[t]+r[t]|0,a=(i(e,2)^i(e,13)^i(e,22))+Maj(e,n,o)|0;u=H,H=l,l=c,c=A+s|0,A=o,o=n,n=e,e=s+a|0}var f;e=e+this.A|0,n=n+this.B|0,o=o+this.C|0,A=A+this.D|0,c=c+this.E|0,l=l+this.F|0,H=H+this.G|0,u=u+this.H|0,this.set(e,n,o,A,c,l,H,u)}roundClean(){r.fill(0)}destroy(){this.set(0,0,0,0,0,0,0,0),this.buffer.fill(0)}}class SHA224 extends SHA256{constructor(){super(),this.A=-1056596264,this.B=914150663,this.C=812702999,this.D=-150054599,this.E=-4191439,this.F=1750603025,this.G=1694076839,this.H=-1090891868,this.outputLen=28}}const n=s((()=>new SHA256));s((()=>new SHA224));export{n as sha256};
+//# sourceMappingURL=sha256.esm.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.1/node_modules/@noble/hashes/esm/sha256.js"],"sourcesContent":["import { SHA2 } from './_sha2.js';\nimport { rotr, wrapConstructor } from './utils.js';\n// Choice: a ? b : c\nconst Chi = (a, b, c) => (a & b) ^ (~a & c);\n// Majority function, true if any two inpust is true\nconst Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);\n// Round constants:\n// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)\n// prettier-ignore\nconst SHA256_K = new Uint32Array([\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// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n// prettier-ignore\nconst IV = new Uint32Array([\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n]);\n// Temporary buffer, not used to store anything between runs\n// Named this way because it matches specification.\nconst SHA256_W = new Uint32Array(64);\nclass SHA256 extends SHA2 {\n    constructor() {\n        super(64, 32, 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 = IV[0] | 0;\n        this.B = IV[1] | 0;\n        this.C = IV[2] | 0;\n        this.D = IV[3] | 0;\n        this.E = IV[4] | 0;\n        this.F = IV[5] | 0;\n        this.G = IV[6] | 0;\n        this.H = 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        SHA256_W.fill(0);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n        this.buffer.fill(0);\n    }\n}\n// Constants from https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf\nclass SHA224 extends SHA256 {\n    constructor() {\n        super();\n        this.A = 0xc1059ed8 | 0;\n        this.B = 0x367cd507 | 0;\n        this.C = 0x3070dd17 | 0;\n        this.D = 0xf70e5939 | 0;\n        this.E = 0xffc00b31 | 0;\n        this.F = 0x68581511 | 0;\n        this.G = 0x64f98fa7 | 0;\n        this.H = 0xbefa4fa4 | 0;\n        this.outputLen = 28;\n    }\n}\n/**\n * SHA2-256 hash function\n * @param message - data that would be hashed\n */\nexport const sha256 = wrapConstructor(() => new SHA256());\nexport const sha224 = wrapConstructor(() => new SHA224());\n//# sourceMappingURL=sha256.js.map"],"names":["Maj","a","b","c","SHA256_K","Uint32Array","IV","SHA256_W","SHA256","SHA2","constructor","super","this","A","B","C","D","E","F","G","H","get","set","process","view","offset","i","getUint32","W15","W2","s0","rotr","s1","T1","T2","roundClean","fill","destroy","buffer","SHA224","outputLen","sha256","wrapConstructor"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.1/node_modules/@noble/hashes/esm/utils.amd.js

@@ -0,0 +1,3 @@
+define(["exports"],(function(t){"use strict";
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */const u8a=t=>t instanceof Uint8Array,e=68===new Uint8Array(new Uint32Array([287454020]).buffer)[0];if(!e)throw new Error("Non little-endian hardware is not supported");const r=Array.from({length:256},((t,e)=>e.toString(16).padStart(2,"0")));function utf8ToBytes(t){if("string"!=typeof t)throw new Error("utf8ToBytes expected string, got "+typeof t);return new Uint8Array((new TextEncoder).encode(t))}function toBytes(t){if("string"==typeof t&&(t=utf8ToBytes(t)),!u8a(t))throw new Error("expected Uint8Array, got "+typeof t);return t}t.Hash=class Hash{clone(){return this._cloneInto()}},t.bytesToHex=function bytesToHex(t){if(!u8a(t))throw new Error("Uint8Array expected");let e="";for(let n=0;n<t.length;n++)e+=r[t[n]];return e},t.createView=t=>new DataView(t.buffer,t.byteOffset,t.byteLength),t.isLE=e,t.rotr=(t,e)=>t<<32-e|t>>>e,t.toBytes=toBytes,t.utf8ToBytes=utf8ToBytes,t.wrapConstructor=function wrapConstructor(t){const hashC=e=>t().update(toBytes(e)).digest(),e=t();return hashC.outputLen=e.outputLen,hashC.blockLen=e.blockLen,hashC.create=()=>t(),hashC}}));
+//# sourceMappingURL=utils.amd.js.map

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.1/node_modules/@noble/hashes/esm/utils.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.amd.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.1/node_modules/@noble/hashes/esm/utils.js"],"sourcesContent":["/*! 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, we can just drop the import.\nimport { crypto } from '@noble/hashes/crypto';\nconst u8a = (a) => a instanceof Uint8Array;\n// Cast array to different type\nexport const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexport const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n// Cast array to view\nexport const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n// The rotate right (circular right shift) operation for uint32\nexport const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);\n// big-endian hardware is rare. Just in case someone still decides to run hashes:\n// early-throw an error because we don't support BE yet.\nexport const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;\nif (!isLE)\n    throw new Error('Non little-endian hardware is not supported');\nconst hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    if (!u8a(bytes))\n        throw new Error('Uint8Array expected');\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/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    const len = hex.length;\n    if (len % 2)\n        throw new Error('padded hex string expected, got unpadded hex of length ' + len);\n    const array = new Uint8Array(len / 2);\n    for (let i = 0; i < array.length; i++) {\n        const j = i * 2;\n        const hexByte = hex.slice(j, j + 2);\n        const byte = Number.parseInt(hexByte, 16);\n        if (Number.isNaN(byte) || byte < 0)\n            throw new Error('Invalid byte sequence');\n        array[i] = byte;\n    }\n    return array;\n}\n// There is no setImmediate in browser and setTimeout is slow.\n// call of async fn will return Promise, which will be fullfiled only on\n// next scheduler queue processing step and this is exactly what we need.\nexport const nextTick = async () => { };\n// Returns control to thread each 'tick' ms to avoid blocking\nexport async function asyncLoop(iters, tick, cb) {\n    let ts = Date.now();\n    for (let i = 0; i < iters; i++) {\n        cb(i);\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < tick)\n            continue;\n        await nextTick();\n        ts += diff;\n    }\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    if (!u8a(data))\n        throw new Error(`expected Uint8Array, got ${typeof data}`);\n    return data;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));\n    let pad = 0; // walk through each item, ensure they have proper type\n    arrays.forEach((a) => {\n        if (!u8a(a))\n            throw new Error('Uint8Array expected');\n        r.set(a, pad);\n        pad += a.length;\n    });\n    return r;\n}\n// For runtime check if class implements interface\nexport class Hash {\n    // Safe version that clones internal state\n    clone() {\n        return this._cloneInto();\n    }\n}\n// Check if object doens't have custom constructor (like Uint8Array/Array)\nconst isPlainObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]' && obj.constructor === Object;\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && (typeof opts !== 'object' || !isPlainObject(opts)))\n        throw new Error('Options should be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\nexport function wrapConstructor(hashCons) {\n    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();\n    const tmp = hashCons();\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = () => hashCons();\n    return hashC;\n}\nexport function wrapConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport function wrapXOFConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\n/**\n * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.\n */\nexport function randomBytes(bytesLength = 32) {\n    if (crypto && typeof crypto.getRandomValues === 'function') {\n        return crypto.getRandomValues(new Uint8Array(bytesLength));\n    }\n    throw new Error('crypto.getRandomValues must be defined');\n}\n//# sourceMappingURL=utils.js.map"],"names":["u8a","a","Uint8Array","isLE","Uint32Array","buffer","Error","hexes","Array","from","length","v","i","toString","padStart","utf8ToBytes","str","TextEncoder","encode","toBytes","data","Hash","clone","this","_cloneInto","bytesToHex","bytes","hex","arr","DataView","byteOffset","byteLength","word","shift","wrapConstructor","hashCons","hashC","msg","update","digest","tmp","outputLen","blockLen","create"],"mappings":";sEAQA,MAAMA,IAAOC,GAAMA,aAAaC,WAUnBC,EAAmE,KAA5D,IAAID,WAAW,IAAIE,YAAY,CAAC,YAAaC,QAAQ,GACzE,IAAKF,EACD,MAAM,IAAIG,MAAM,+CACpB,MAAMC,EAAQC,MAAMC,KAAK,CAAEC,OAAQ,MAAO,CAACC,EAAGC,IAAMA,EAAEC,SAAS,IAAIC,SAAS,EAAG,OAsDxE,SAASC,YAAYC,GACxB,GAAmB,iBAARA,EACP,MAAM,IAAIV,MAAM,2CAA2CU,GAC/D,OAAO,IAAId,YAAW,IAAIe,aAAcC,OAAOF,GACnD,CAMO,SAASG,QAAQC,GAGpB,GAFoB,iBAATA,IACPA,EAAOL,YAAYK,KAClBpB,IAAIoB,GACL,MAAM,IAAId,MAAM,mCAAmCc,GACvD,OAAOA,CACX,QAgBO,MAAMC,KAET,KAAAC,GACI,OAAOC,KAAKC,YACpB,gBAtFO,SAASC,WAAWC,GACvB,IAAK1B,IAAI0B,GACL,MAAM,IAAIpB,MAAM,uBAEpB,IAAIqB,EAAM,GACV,IAAK,IAAIf,EAAI,EAAGA,EAAIc,EAAMhB,OAAQE,IAC9Be,GAAOpB,EAAMmB,EAAMd,IAEvB,OAAOe,CACX,eArB2BC,GAAQ,IAAIC,SAASD,EAAIvB,OAAQuB,EAAIE,WAAYF,EAAIG,4BAE5D,CAACC,EAAMC,IAAWD,GAAS,GAAKC,EAAWD,IAASC,gEA0GjE,SAASC,gBAAgBC,GAC5B,MAAMC,MAASC,GAAQF,IAAWG,OAAOnB,QAAQkB,IAAME,SACjDC,EAAML,IAIZ,OAHAC,MAAMK,UAAYD,EAAIC,UACtBL,MAAMM,SAAWF,EAAIE,SACrBN,MAAMO,OAAS,IAAMR,IACdC,KACX","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.1/node_modules/@noble/hashes/esm/utils.esm.js

@@ -0,0 +1,3 @@
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const u8a=t=>t instanceof Uint8Array,createView=t=>new DataView(t.buffer,t.byteOffset,t.byteLength),rotr=(t,e)=>t<<32-e|t>>>e,t=68===new Uint8Array(new Uint32Array([287454020]).buffer)[0];if(!t)throw new Error("Non little-endian hardware is not supported");const e=Array.from({length:256},((t,e)=>e.toString(16).padStart(2,"0")));function bytesToHex(t){if(!u8a(t))throw new Error("Uint8Array expected");let r="";for(let n=0;n<t.length;n++)r+=e[t[n]];return r}function utf8ToBytes(t){if("string"!=typeof t)throw new Error("utf8ToBytes expected string, got "+typeof t);return new Uint8Array((new TextEncoder).encode(t))}function toBytes(t){if("string"==typeof t&&(t=utf8ToBytes(t)),!u8a(t))throw new Error("expected Uint8Array, got "+typeof t);return t}class Hash{clone(){return this._cloneInto()}}function wrapConstructor(t){const hashC=e=>t().update(toBytes(e)).digest(),e=t();return hashC.outputLen=e.outputLen,hashC.blockLen=e.blockLen,hashC.create=()=>t(),hashC}export{Hash,bytesToHex,createView,t as isLE,rotr,toBytes,utf8ToBytes,wrapConstructor};
+//# sourceMappingURL=utils.esm.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.1/node_modules/@noble/hashes/esm/utils.js"],"sourcesContent":["/*! 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, we can just drop the import.\nimport { crypto } from '@noble/hashes/crypto';\nconst u8a = (a) => a instanceof Uint8Array;\n// Cast array to different type\nexport const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexport const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n// Cast array to view\nexport const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n// The rotate right (circular right shift) operation for uint32\nexport const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);\n// big-endian hardware is rare. Just in case someone still decides to run hashes:\n// early-throw an error because we don't support BE yet.\nexport const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;\nif (!isLE)\n    throw new Error('Non little-endian hardware is not supported');\nconst hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    if (!u8a(bytes))\n        throw new Error('Uint8Array expected');\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/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    const len = hex.length;\n    if (len % 2)\n        throw new Error('padded hex string expected, got unpadded hex of length ' + len);\n    const array = new Uint8Array(len / 2);\n    for (let i = 0; i < array.length; i++) {\n        const j = i * 2;\n        const hexByte = hex.slice(j, j + 2);\n        const byte = Number.parseInt(hexByte, 16);\n        if (Number.isNaN(byte) || byte < 0)\n            throw new Error('Invalid byte sequence');\n        array[i] = byte;\n    }\n    return array;\n}\n// There is no setImmediate in browser and setTimeout is slow.\n// call of async fn will return Promise, which will be fullfiled only on\n// next scheduler queue processing step and this is exactly what we need.\nexport const nextTick = async () => { };\n// Returns control to thread each 'tick' ms to avoid blocking\nexport async function asyncLoop(iters, tick, cb) {\n    let ts = Date.now();\n    for (let i = 0; i < iters; i++) {\n        cb(i);\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < tick)\n            continue;\n        await nextTick();\n        ts += diff;\n    }\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    if (!u8a(data))\n        throw new Error(`expected Uint8Array, got ${typeof data}`);\n    return data;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));\n    let pad = 0; // walk through each item, ensure they have proper type\n    arrays.forEach((a) => {\n        if (!u8a(a))\n            throw new Error('Uint8Array expected');\n        r.set(a, pad);\n        pad += a.length;\n    });\n    return r;\n}\n// For runtime check if class implements interface\nexport class Hash {\n    // Safe version that clones internal state\n    clone() {\n        return this._cloneInto();\n    }\n}\n// Check if object doens't have custom constructor (like Uint8Array/Array)\nconst isPlainObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]' && obj.constructor === Object;\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && (typeof opts !== 'object' || !isPlainObject(opts)))\n        throw new Error('Options should be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\nexport function wrapConstructor(hashCons) {\n    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();\n    const tmp = hashCons();\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = () => hashCons();\n    return hashC;\n}\nexport function wrapConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport function wrapXOFConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\n/**\n * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.\n */\nexport function randomBytes(bytesLength = 32) {\n    if (crypto && typeof crypto.getRandomValues === 'function') {\n        return crypto.getRandomValues(new Uint8Array(bytesLength));\n    }\n    throw new Error('crypto.getRandomValues must be defined');\n}\n//# sourceMappingURL=utils.js.map"],"names":["u8a","a","Uint8Array","createView","arr","DataView","buffer","byteOffset","byteLength","rotr","word","shift","isLE","Uint32Array","Error","hexes","Array","from","length","v","i","toString","padStart","bytesToHex","bytes","hex","utf8ToBytes","str","TextEncoder","encode","toBytes","data","Hash","clone","this","_cloneInto","wrapConstructor","hashCons","hashC","msg","update","digest","tmp","outputLen","blockLen","create"],"mappings":";AAQA,MAAMA,IAAOC,GAAMA,aAAaC,WAKnBC,WAAcC,GAAQ,IAAIC,SAASD,EAAIE,OAAQF,EAAIG,WAAYH,EAAII,YAEnEC,KAAO,CAACC,EAAMC,IAAWD,GAAS,GAAKC,EAAWD,IAASC,EAG3DC,EAAmE,KAA5D,IAAIV,WAAW,IAAIW,YAAY,CAAC,YAAaP,QAAQ,GACzE,IAAKM,EACD,MAAM,IAAIE,MAAM,+CACpB,MAAMC,EAAQC,MAAMC,KAAK,CAAEC,OAAQ,MAAO,CAACC,EAAGC,IAAMA,EAAEC,SAAS,IAAIC,SAAS,EAAG,OAIxE,SAASC,WAAWC,GACvB,IAAKxB,IAAIwB,GACL,MAAM,IAAIV,MAAM,uBAEpB,IAAIW,EAAM,GACV,IAAK,IAAIL,EAAI,EAAGA,EAAII,EAAMN,OAAQE,IAC9BK,GAAOV,EAAMS,EAAMJ,IAEvB,OAAOK,CACX,CAyCO,SAASC,YAAYC,GACxB,GAAmB,iBAARA,EACP,MAAM,IAAIb,MAAM,2CAA2Ca,GAC/D,OAAO,IAAIzB,YAAW,IAAI0B,aAAcC,OAAOF,GACnD,CAMO,SAASG,QAAQC,GAGpB,GAFoB,iBAATA,IACPA,EAAOL,YAAYK,KAClB/B,IAAI+B,GACL,MAAM,IAAIjB,MAAM,mCAAmCiB,GACvD,OAAOA,CACX,CAgBO,MAAMC,KAET,KAAAC,GACI,OAAOC,KAAKC,YACpB,EAUO,SAASC,gBAAgBC,GAC5B,MAAMC,MAASC,GAAQF,IAAWG,OAAOV,QAAQS,IAAME,SACjDC,EAAML,IAIZ,OAHAC,MAAMK,UAAYD,EAAIC,UACtBL,MAAMM,SAAWF,EAAIE,SACrBN,MAAMO,OAAS,IAAMR,IACdC,KACX","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/_assert.amd.js

@@ -0,0 +1,2 @@
+define(["exports"],(function(e){"use strict";function number(e){if(!Number.isSafeInteger(e)||e<0)throw new Error(`Wrong positive integer: ${e}`)}function bytes(e,...t){if(!(e instanceof Uint8Array))throw new Error("Expected Uint8Array");if(t.length>0&&!t.includes(e.length))throw new Error(`Expected Uint8Array of length ${t}, not of length=${e.length}`)}e.bytes=bytes,e.exists=function exists(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")},e.hash=function hash(e){if("function"!=typeof e||"function"!=typeof e.create)throw new Error("Hash should be wrapped by utils.wrapConstructor");number(e.outputLen),number(e.blockLen)},e.number=number,e.output=function output(e,t){bytes(e);const n=t.outputLen;if(e.length<n)throw new Error(`digestInto() expects output buffer of length at least ${n}`)}}));
+//# sourceMappingURL=_assert.amd.js.map

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/_assert.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_assert.amd.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/_assert.js"],"sourcesContent":["function number(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error(`Wrong positive integer: ${n}`);\n}\nfunction bool(b) {\n    if (typeof b !== 'boolean')\n        throw new Error(`Expected boolean, not ${b}`);\n}\nfunction bytes(b, ...lengths) {\n    if (!(b instanceof Uint8Array))\n        throw new Error('Expected Uint8Array');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);\n}\nfunction hash(hash) {\n    if (typeof hash !== 'function' || typeof hash.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.wrapConstructor');\n    number(hash.outputLen);\n    number(hash.blockLen);\n}\nfunction exists(instance, checkFinished = true) {\n    if (instance.destroyed)\n        throw new Error('Hash instance has been destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('Hash#digest() has already been called');\n}\nfunction output(out, instance) {\n    bytes(out);\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error(`digestInto() expects output buffer of length at least ${min}`);\n    }\n}\nexport { number, bool, bytes, hash, exists, output };\nconst assert = { number, bool, bytes, hash, exists, output };\nexport default assert;\n//# sourceMappingURL=_assert.js.map"],"names":["number","n","Number","isSafeInteger","Error","bytes","b","lengths","Uint8Array","length","includes","exists","instance","checkFinished","destroyed","finished","hash","create","outputLen","blockLen","output","out","min"],"mappings":"6CAAA,SAASA,OAAOC,GACZ,IAAKC,OAAOC,cAAcF,IAAMA,EAAI,EAChC,MAAM,IAAIG,MAAM,2BAA2BH,IACnD,CAKA,SAASI,MAAMC,KAAMC,GACjB,KAAMD,aAAaE,YACf,MAAM,IAAIJ,MAAM,uBACpB,GAAIG,EAAQE,OAAS,IAAMF,EAAQG,SAASJ,EAAEG,QAC1C,MAAM,IAAIL,MAAM,iCAAiCG,oBAA0BD,EAAEG,SACrF,wBAOA,SAASE,OAAOC,EAAUC,GAAgB,GACtC,GAAID,EAASE,UACT,MAAM,IAAIV,MAAM,oCACpB,GAAIS,GAAiBD,EAASG,SAC1B,MAAM,IAAIX,MAAM,wCACxB,SAXA,SAASY,KAAKA,GACV,GAAoB,mBAATA,GAA8C,mBAAhBA,EAAKC,OAC1C,MAAM,IAAIb,MAAM,mDACpBJ,OAAOgB,EAAKE,WACZlB,OAAOgB,EAAKG,SAChB,2BAOA,SAASC,OAAOC,EAAKT,GACjBP,MAAMgB,GACN,MAAMC,EAAMV,EAASM,UACrB,GAAIG,EAAIZ,OAASa,EACb,MAAM,IAAIlB,MAAM,yDAAyDkB,IAEjF","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/_assert.esm.js

@@ -0,0 +1,2 @@
+function number(e){if(!Number.isSafeInteger(e)||e<0)throw new Error(`Wrong positive integer: ${e}`)}function bytes(e,...t){if(!(e instanceof Uint8Array))throw new Error("Expected Uint8Array");if(t.length>0&&!t.includes(e.length))throw new Error(`Expected Uint8Array of length ${t}, not of length=${e.length}`)}function hash(e){if("function"!=typeof e||"function"!=typeof e.create)throw new Error("Hash should be wrapped by utils.wrapConstructor");number(e.outputLen),number(e.blockLen)}function exists(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 output(e,t){bytes(e);const n=t.outputLen;if(e.length<n)throw new Error(`digestInto() expects output buffer of length at least ${n}`)}export{bytes,exists,hash,number,output};
+//# sourceMappingURL=_assert.esm.js.map

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/_assert.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_assert.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/_assert.js"],"sourcesContent":["function number(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error(`Wrong positive integer: ${n}`);\n}\nfunction bool(b) {\n    if (typeof b !== 'boolean')\n        throw new Error(`Expected boolean, not ${b}`);\n}\nfunction bytes(b, ...lengths) {\n    if (!(b instanceof Uint8Array))\n        throw new Error('Expected Uint8Array');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);\n}\nfunction hash(hash) {\n    if (typeof hash !== 'function' || typeof hash.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.wrapConstructor');\n    number(hash.outputLen);\n    number(hash.blockLen);\n}\nfunction exists(instance, checkFinished = true) {\n    if (instance.destroyed)\n        throw new Error('Hash instance has been destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('Hash#digest() has already been called');\n}\nfunction output(out, instance) {\n    bytes(out);\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error(`digestInto() expects output buffer of length at least ${min}`);\n    }\n}\nexport { number, bool, bytes, hash, exists, output };\nconst assert = { number, bool, bytes, hash, exists, output };\nexport default assert;\n//# sourceMappingURL=_assert.js.map"],"names":["number","n","Number","isSafeInteger","Error","bytes","b","lengths","Uint8Array","length","includes","hash","create","outputLen","blockLen","exists","instance","checkFinished","destroyed","finished","output","out","min"],"mappings":"AAAA,SAASA,OAAOC,GACZ,IAAKC,OAAOC,cAAcF,IAAMA,EAAI,EAChC,MAAM,IAAIG,MAAM,2BAA2BH,IACnD,CAKA,SAASI,MAAMC,KAAMC,GACjB,KAAMD,aAAaE,YACf,MAAM,IAAIJ,MAAM,uBACpB,GAAIG,EAAQE,OAAS,IAAMF,EAAQG,SAASJ,EAAEG,QAC1C,MAAM,IAAIL,MAAM,iCAAiCG,oBAA0BD,EAAEG,SACrF,CACA,SAASE,KAAKA,GACV,GAAoB,mBAATA,GAA8C,mBAAhBA,EAAKC,OAC1C,MAAM,IAAIR,MAAM,mDACpBJ,OAAOW,EAAKE,WACZb,OAAOW,EAAKG,SAChB,CACA,SAASC,OAAOC,EAAUC,GAAgB,GACtC,GAAID,EAASE,UACT,MAAM,IAAId,MAAM,oCACpB,GAAIa,GAAiBD,EAASG,SAC1B,MAAM,IAAIf,MAAM,wCACxB,CACA,SAASgB,OAAOC,EAAKL,GACjBX,MAAMgB,GACN,MAAMC,EAAMN,EAASH,UACrB,GAAIQ,EAAIZ,OAASa,EACb,MAAM,IAAIlB,MAAM,yDAAyDkB,IAEjF","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/_sha2.amd.js

@@ -0,0 +1,2 @@
+define(["exports","./_assert.amd","./utils.amd"],(function(t,s,e){"use strict";class SHA2 extends e.Hash{constructor(t,s,i,n){super(),this.blockLen=t,this.outputLen=s,this.padOffset=i,this.isLE=n,this.finished=!1,this.length=0,this.pos=0,this.destroyed=!1,this.buffer=new Uint8Array(t),this.view=e.createView(this.buffer)}update(t){s.exists(this);const{view:i,buffer:n,blockLen:o}=this,h=(t=e.toBytes(t)).length;for(let s=0;s<h;){const r=Math.min(o-this.pos,h-s);if(r!==o)n.set(t.subarray(s,s+r),this.pos),this.pos+=r,s+=r,this.pos===o&&(this.process(i,0),this.pos=0);else{const i=e.createView(t);for(;o<=h-s;s+=o)this.process(i,s)}}return this.length+=t.length,this.roundClean(),this}digestInto(t){s.exists(this),s.output(t,this),this.finished=!0;const{buffer:i,view:n,blockLen:o,isLE:h}=this;let{pos:r}=this;i[r++]=128,this.buffer.subarray(r).fill(0),this.padOffset>o-r&&(this.process(n,0),r=0);for(let t=r;t<o;t++)i[t]=0;!function setBigUint64(t,s,e,i){if("function"==typeof t.setBigUint64)return t.setBigUint64(s,e,i);const n=BigInt(32),o=BigInt(4294967295),h=Number(e>>n&o),r=Number(e&o),u=i?4:0,f=i?0:4;t.setUint32(s+u,h,i),t.setUint32(s+f,r,i)}(n,o-8,BigInt(8*this.length),h),this.process(n,0);const u=e.createView(t),f=this.outputLen;if(f%4)throw new Error("_sha2: outputLen should be aligned to 32bit");const c=f/4,l=this.get();if(c>l.length)throw new Error("_sha2: outputLen bigger than state");for(let t=0;t<c;t++)u.setUint32(4*t,l[t],h)}digest(){const{buffer:t,outputLen:s}=this;this.digestInto(t);const e=t.slice(0,s);return this.destroy(),e}_cloneInto(t){t||(t=new this.constructor),t.set(...this.get());const{blockLen:s,buffer:e,length:i,finished:n,destroyed:o,pos:h}=this;return t.length=i,t.pos=h,t.finished=n,t.destroyed=o,i%s&&t.buffer.set(e),t}}t.SHA2=SHA2}));
+//# sourceMappingURL=_sha2.amd.js.map

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/_sha2.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_sha2.amd.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/_sha2.js"],"sourcesContent":["import { exists, output } from './_assert.js';\nimport { Hash, createView, toBytes } from './utils.js';\n// Polyfill for Safari 14\nfunction 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// Base SHA2 class (RFC 6234)\nexport class SHA2 extends Hash {\n    constructor(blockLen, outputLen, padOffset, isLE) {\n        super();\n        this.blockLen = blockLen;\n        this.outputLen = outputLen;\n        this.padOffset = padOffset;\n        this.isLE = isLE;\n        this.finished = false;\n        this.length = 0;\n        this.pos = 0;\n        this.destroyed = false;\n        this.buffer = new Uint8Array(blockLen);\n        this.view = createView(this.buffer);\n    }\n    update(data) {\n        exists(this);\n        const { view, buffer, blockLen } = this;\n        data = toBytes(data);\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            // 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        exists(this);\n        output(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        this.buffer.subarray(pos).fill(0);\n        // we have less than padOffset left in buffer, so we cannot put length in 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.length = length;\n        to.pos = pos;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        if (length % blockLen)\n            to.buffer.set(buffer);\n        return to;\n    }\n}\n//# sourceMappingURL=_sha2.js.map"],"names":["SHA2","Hash","constructor","blockLen","outputLen","padOffset","isLE","super","this","finished","length","pos","destroyed","buffer","Uint8Array","view","createView","update","data","exists","len","toBytes","take","Math","min","set","subarray","process","dataView","roundClean","digestInto","out","output","fill","i","setBigUint64","byteOffset","value","_32n","BigInt","_u32_max","wh","Number","wl","h","l","setUint32","oview","Error","outLen","state","get","digest","res","slice","destroy","_cloneInto","to"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/_sha2.esm.js

@@ -0,0 +1,2 @@
+import{exists as t,output as s}from"./_assert.esm.js";import{Hash as e,createView as i,toBytes as n}from"./utils.esm.js";class SHA2 extends e{constructor(t,s,e,n){super(),this.blockLen=t,this.outputLen=s,this.padOffset=e,this.isLE=n,this.finished=!1,this.length=0,this.pos=0,this.destroyed=!1,this.buffer=new Uint8Array(t),this.view=i(this.buffer)}update(s){t(this);const{view:e,buffer:o,blockLen:h}=this,r=(s=n(s)).length;for(let t=0;t<r;){const n=Math.min(h-this.pos,r-t);if(n!==h)o.set(s.subarray(t,t+n),this.pos),this.pos+=n,t+=n,this.pos===h&&(this.process(e,0),this.pos=0);else{const e=i(s);for(;h<=r-t;t+=h)this.process(e,t)}}return this.length+=s.length,this.roundClean(),this}digestInto(e){t(this),s(e,this),this.finished=!0;const{buffer:n,view:o,blockLen:h,isLE:r}=this;let{pos:f}=this;n[f++]=128,this.buffer.subarray(f).fill(0),this.padOffset>h-f&&(this.process(o,0),f=0);for(let t=f;t<h;t++)n[t]=0;!function setBigUint64(t,s,e,i){if("function"==typeof t.setBigUint64)return t.setBigUint64(s,e,i);const n=BigInt(32),o=BigInt(4294967295),h=Number(e>>n&o),r=Number(e&o),f=i?4:0,u=i?0:4;t.setUint32(s+f,h,i),t.setUint32(s+u,r,i)}(o,h-8,BigInt(8*this.length),r),this.process(o,0);const u=i(e),c=this.outputLen;if(c%4)throw new Error("_sha2: outputLen should be aligned to 32bit");const l=c/4,p=this.get();if(l>p.length)throw new Error("_sha2: outputLen bigger than state");for(let t=0;t<l;t++)u.setUint32(4*t,p[t],r)}digest(){const{buffer:t,outputLen:s}=this;this.digestInto(t);const e=t.slice(0,s);return this.destroy(),e}_cloneInto(t){t||(t=new this.constructor),t.set(...this.get());const{blockLen:s,buffer:e,length:i,finished:n,destroyed:o,pos:h}=this;return t.length=i,t.pos=h,t.finished=n,t.destroyed=o,i%s&&t.buffer.set(e),t}}export{SHA2};
+//# sourceMappingURL=_sha2.esm.js.map

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/_sha2.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_sha2.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/_sha2.js"],"sourcesContent":["import { exists, output } from './_assert.js';\nimport { Hash, createView, toBytes } from './utils.js';\n// Polyfill for Safari 14\nfunction 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// Base SHA2 class (RFC 6234)\nexport class SHA2 extends Hash {\n    constructor(blockLen, outputLen, padOffset, isLE) {\n        super();\n        this.blockLen = blockLen;\n        this.outputLen = outputLen;\n        this.padOffset = padOffset;\n        this.isLE = isLE;\n        this.finished = false;\n        this.length = 0;\n        this.pos = 0;\n        this.destroyed = false;\n        this.buffer = new Uint8Array(blockLen);\n        this.view = createView(this.buffer);\n    }\n    update(data) {\n        exists(this);\n        const { view, buffer, blockLen } = this;\n        data = toBytes(data);\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            // 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        exists(this);\n        output(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        this.buffer.subarray(pos).fill(0);\n        // we have less than padOffset left in buffer, so we cannot put length in 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.length = length;\n        to.pos = pos;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        if (length % blockLen)\n            to.buffer.set(buffer);\n        return to;\n    }\n}\n//# sourceMappingURL=_sha2.js.map"],"names":["SHA2","Hash","constructor","blockLen","outputLen","padOffset","isLE","super","this","finished","length","pos","destroyed","buffer","Uint8Array","view","createView","update","data","exists","len","toBytes","take","Math","min","set","subarray","process","dataView","roundClean","digestInto","out","output","fill","i","setBigUint64","byteOffset","value","_32n","BigInt","_u32_max","wh","Number","wl","h","l","setUint32","oview","Error","outLen","state","get","digest","res","slice","destroy","_cloneInto","to"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/crypto.amd.js

@@ -0,0 +1,2 @@
+define(["exports"],(function(o){"use strict";const t="object"==typeof globalThis&&"crypto"in globalThis?globalThis.crypto:void 0;o.crypto=t}));
+//# sourceMappingURL=crypto.amd.js.map

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/crypto.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.amd.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.2/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":"6CAAY,MAACA,EAA+B,iBAAfC,YAA2B,WAAYA,WAAaA,WAAWD,YAASE","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/crypto.esm.js

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

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/crypto.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.2/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":"AAAY,MAACA,EAA+B,iBAAfC,YAA2B,WAAYA,WAAaA,WAAWD,YAASE","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/hmac.amd.js

@@ -0,0 +1,2 @@
+define(["exports","./_assert.amd","./utils.amd"],(function(t,s,e){"use strict";class HMAC extends e.Hash{constructor(t,i){super(),this.finished=!1,this.destroyed=!1,s.hash(t);const h=e.toBytes(i);if(this.iHash=t.create(),"function"!=typeof this.iHash.update)throw new Error("Expected instance of class which extends utils.Hash");this.blockLen=this.iHash.blockLen,this.outputLen=this.iHash.outputLen;const o=this.blockLen,n=new Uint8Array(o);n.set(h.length>o?t.create().update(h).digest():h);for(let t=0;t<n.length;t++)n[t]^=54;this.iHash.update(n),this.oHash=t.create();for(let t=0;t<n.length;t++)n[t]^=106;this.oHash.update(n),n.fill(0)}update(t){return s.exists(this),this.iHash.update(t),this}digestInto(t){s.exists(this),s.bytes(t,this.outputLen),this.finished=!0,this.iHash.digestInto(t),this.oHash.update(t),this.oHash.digestInto(t),this.destroy()}digest(){const t=new Uint8Array(this.oHash.outputLen);return this.digestInto(t),t}_cloneInto(t){t||(t=Object.create(Object.getPrototypeOf(this),{}));const{oHash:s,iHash:e,finished:i,destroyed:h,blockLen:o,outputLen:n}=this;return t.finished=i,t.destroyed=h,t.blockLen=o,t.outputLen=n,t.oHash=s._cloneInto(t.oHash),t.iHash=e._cloneInto(t.iHash),t}destroy(){this.destroyed=!0,this.oHash.destroy(),this.iHash.destroy()}}const hmac=(t,s,e)=>new HMAC(t,s).update(e).digest();hmac.create=(t,s)=>new HMAC(t,s),t.HMAC=HMAC,t.hmac=hmac}));
+//# sourceMappingURL=hmac.amd.js.map

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/hmac.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmac.amd.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/hmac.js"],"sourcesContent":["import { hash as assertHash, bytes as assertBytes, exists as assertExists } from './_assert.js';\nimport { Hash, toBytes } from './utils.js';\n// HMAC (RFC 2104)\nexport class HMAC extends Hash {\n    constructor(hash, _key) {\n        super();\n        this.finished = false;\n        this.destroyed = false;\n        assertHash(hash);\n        const key = toBytes(_key);\n        this.iHash = hash.create();\n        if (typeof this.iHash.update !== 'function')\n            throw new Error('Expected instance of class which extends utils.Hash');\n        this.blockLen = this.iHash.blockLen;\n        this.outputLen = this.iHash.outputLen;\n        const blockLen = this.blockLen;\n        const pad = new Uint8Array(blockLen);\n        // blockLen can be bigger than outputLen\n        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36;\n        this.iHash.update(pad);\n        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone\n        this.oHash = hash.create();\n        // Undo internal XOR && apply outer XOR\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36 ^ 0x5c;\n        this.oHash.update(pad);\n        pad.fill(0);\n    }\n    update(buf) {\n        assertExists(this);\n        this.iHash.update(buf);\n        return this;\n    }\n    digestInto(out) {\n        assertExists(this);\n        assertBytes(out, this.outputLen);\n        this.finished = true;\n        this.iHash.digestInto(out);\n        this.oHash.update(out);\n        this.oHash.digestInto(out);\n        this.destroy();\n    }\n    digest() {\n        const out = new Uint8Array(this.oHash.outputLen);\n        this.digestInto(out);\n        return out;\n    }\n    _cloneInto(to) {\n        // Create new instance without calling constructor since key already in state and we don't know it.\n        to || (to = Object.create(Object.getPrototypeOf(this), {}));\n        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;\n        to = to;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        to.blockLen = blockLen;\n        to.outputLen = outputLen;\n        to.oHash = oHash._cloneInto(to.oHash);\n        to.iHash = iHash._cloneInto(to.iHash);\n        return to;\n    }\n    destroy() {\n        this.destroyed = true;\n        this.oHash.destroy();\n        this.iHash.destroy();\n    }\n}\n/**\n * HMAC: RFC2104 message authentication code.\n * @param hash - function that would be used e.g. sha256\n * @param key - message key\n * @param message - message data\n */\nexport const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();\nhmac.create = (hash, key) => new HMAC(hash, key);\n//# sourceMappingURL=hmac.js.map"],"names":["HMAC","Hash","constructor","hash","_key","super","this","finished","destroyed","assertHash","key","toBytes","iHash","create","update","Error","blockLen","outputLen","pad","Uint8Array","set","length","digest","i","oHash","fill","buf","assertExists","digestInto","out","assertBytes","destroy","_cloneInto","to","Object","getPrototypeOf","hmac","message"],"mappings":"+EAGO,MAAMA,aAAaC,EAAAA,KACtB,WAAAC,CAAYC,EAAMC,GACdC,QACAC,KAAKC,UAAW,EAChBD,KAAKE,WAAY,EACjBC,EAAAA,KAAWN,GACX,MAAMO,EAAMC,EAAOA,QAACP,GAEpB,GADAE,KAAKM,MAAQT,EAAKU,SACe,mBAAtBP,KAAKM,MAAME,OAClB,MAAM,IAAIC,MAAM,uDACpBT,KAAKU,SAAWV,KAAKM,MAAMI,SAC3BV,KAAKW,UAAYX,KAAKM,MAAMK,UAC5B,MAAMD,EAAWV,KAAKU,SAChBE,EAAM,IAAIC,WAAWH,GAE3BE,EAAIE,IAAIV,EAAIW,OAASL,EAAWb,EAAKU,SAASC,OAAOJ,GAAKY,SAAWZ,GACrE,IAAK,IAAIa,EAAI,EAAGA,EAAIL,EAAIG,OAAQE,IAC5BL,EAAIK,IAAM,GACdjB,KAAKM,MAAME,OAAOI,GAElBZ,KAAKkB,MAAQrB,EAAKU,SAElB,IAAK,IAAIU,EAAI,EAAGA,EAAIL,EAAIG,OAAQE,IAC5BL,EAAIK,IAAM,IACdjB,KAAKkB,MAAMV,OAAOI,GAClBA,EAAIO,KAAK,EACjB,CACI,MAAAX,CAAOY,GAGH,OAFAC,EAAAA,OAAarB,MACbA,KAAKM,MAAME,OAAOY,GACXpB,IACf,CACI,UAAAsB,CAAWC,GACPF,EAAAA,OAAarB,MACbwB,QAAYD,EAAKvB,KAAKW,WACtBX,KAAKC,UAAW,EAChBD,KAAKM,MAAMgB,WAAWC,GACtBvB,KAAKkB,MAAMV,OAAOe,GAClBvB,KAAKkB,MAAMI,WAAWC,GACtBvB,KAAKyB,SACb,CACI,MAAAT,GACI,MAAMO,EAAM,IAAIV,WAAWb,KAAKkB,MAAMP,WAEtC,OADAX,KAAKsB,WAAWC,GACTA,CACf,CACI,UAAAG,CAAWC,GAEPA,IAAOA,EAAKC,OAAOrB,OAAOqB,OAAOC,eAAe7B,MAAO,CAAA,IACvD,MAAMkB,MAAEA,EAAKZ,MAAEA,EAAKL,SAAEA,EAAQC,UAAEA,EAASQ,SAAEA,EAAQC,UAAEA,GAAcX,KAQnE,OANA2B,EAAG1B,SAAWA,EACd0B,EAAGzB,UAAYA,EACfyB,EAAGjB,SAAWA,EACdiB,EAAGhB,UAAYA,EACfgB,EAAGT,MAAQA,EAAMQ,WAAWC,EAAGT,OAC/BS,EAAGrB,MAAQA,EAAMoB,WAAWC,EAAGrB,OACxBqB,CACf,CACI,OAAAF,GACIzB,KAAKE,WAAY,EACjBF,KAAKkB,MAAMO,UACXzB,KAAKM,MAAMmB,SACnB,EAQa,MAAAK,KAAO,CAACjC,EAAMO,EAAK2B,IAAY,IAAIrC,KAAKG,EAAMO,GAAKI,OAAOuB,GAASf,SAChFc,KAAKvB,OAAS,CAACV,EAAMO,IAAQ,IAAIV,KAAKG,EAAMO","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/hmac.esm.js

@@ -0,0 +1,2 @@
+import{hash as t,exists as s,bytes as e}from"./_assert.esm.js";import{Hash as i,toBytes as h}from"./utils.esm.js";class HMAC extends i{constructor(s,e){super(),this.finished=!1,this.destroyed=!1,t(s);const i=h(e);if(this.iHash=s.create(),"function"!=typeof this.iHash.update)throw new Error("Expected instance of class which extends utils.Hash");this.blockLen=this.iHash.blockLen,this.outputLen=this.iHash.outputLen;const o=this.blockLen,n=new Uint8Array(o);n.set(i.length>o?s.create().update(i).digest():i);for(let t=0;t<n.length;t++)n[t]^=54;this.iHash.update(n),this.oHash=s.create();for(let t=0;t<n.length;t++)n[t]^=106;this.oHash.update(n),n.fill(0)}update(t){return s(this),this.iHash.update(t),this}digestInto(t){s(this),e(t,this.outputLen),this.finished=!0,this.iHash.digestInto(t),this.oHash.update(t),this.oHash.digestInto(t),this.destroy()}digest(){const t=new Uint8Array(this.oHash.outputLen);return this.digestInto(t),t}_cloneInto(t){t||(t=Object.create(Object.getPrototypeOf(this),{}));const{oHash:s,iHash:e,finished:i,destroyed:h,blockLen:o,outputLen:n}=this;return t.finished=i,t.destroyed=h,t.blockLen=o,t.outputLen=n,t.oHash=s._cloneInto(t.oHash),t.iHash=e._cloneInto(t.iHash),t}destroy(){this.destroyed=!0,this.oHash.destroy(),this.iHash.destroy()}}const hmac=(t,s,e)=>new HMAC(t,s).update(e).digest();hmac.create=(t,s)=>new HMAC(t,s);export{HMAC,hmac};
+//# sourceMappingURL=hmac.esm.js.map

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/hmac.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmac.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/hmac.js"],"sourcesContent":["import { hash as assertHash, bytes as assertBytes, exists as assertExists } from './_assert.js';\nimport { Hash, toBytes } from './utils.js';\n// HMAC (RFC 2104)\nexport class HMAC extends Hash {\n    constructor(hash, _key) {\n        super();\n        this.finished = false;\n        this.destroyed = false;\n        assertHash(hash);\n        const key = toBytes(_key);\n        this.iHash = hash.create();\n        if (typeof this.iHash.update !== 'function')\n            throw new Error('Expected instance of class which extends utils.Hash');\n        this.blockLen = this.iHash.blockLen;\n        this.outputLen = this.iHash.outputLen;\n        const blockLen = this.blockLen;\n        const pad = new Uint8Array(blockLen);\n        // blockLen can be bigger than outputLen\n        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36;\n        this.iHash.update(pad);\n        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone\n        this.oHash = hash.create();\n        // Undo internal XOR && apply outer XOR\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36 ^ 0x5c;\n        this.oHash.update(pad);\n        pad.fill(0);\n    }\n    update(buf) {\n        assertExists(this);\n        this.iHash.update(buf);\n        return this;\n    }\n    digestInto(out) {\n        assertExists(this);\n        assertBytes(out, this.outputLen);\n        this.finished = true;\n        this.iHash.digestInto(out);\n        this.oHash.update(out);\n        this.oHash.digestInto(out);\n        this.destroy();\n    }\n    digest() {\n        const out = new Uint8Array(this.oHash.outputLen);\n        this.digestInto(out);\n        return out;\n    }\n    _cloneInto(to) {\n        // Create new instance without calling constructor since key already in state and we don't know it.\n        to || (to = Object.create(Object.getPrototypeOf(this), {}));\n        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;\n        to = to;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        to.blockLen = blockLen;\n        to.outputLen = outputLen;\n        to.oHash = oHash._cloneInto(to.oHash);\n        to.iHash = iHash._cloneInto(to.iHash);\n        return to;\n    }\n    destroy() {\n        this.destroyed = true;\n        this.oHash.destroy();\n        this.iHash.destroy();\n    }\n}\n/**\n * HMAC: RFC2104 message authentication code.\n * @param hash - function that would be used e.g. sha256\n * @param key - message key\n * @param message - message data\n */\nexport const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();\nhmac.create = (hash, key) => new HMAC(hash, key);\n//# sourceMappingURL=hmac.js.map"],"names":["HMAC","Hash","constructor","hash","_key","super","this","finished","destroyed","assertHash","key","toBytes","iHash","create","update","Error","blockLen","outputLen","pad","Uint8Array","set","length","digest","i","oHash","fill","buf","assertExists","digestInto","out","assertBytes","destroy","_cloneInto","to","Object","getPrototypeOf","hmac","message"],"mappings":"kHAGO,MAAMA,aAAaC,EACtB,WAAAC,CAAYC,EAAMC,GACdC,QACAC,KAAKC,UAAW,EAChBD,KAAKE,WAAY,EACjBC,EAAWN,GACX,MAAMO,EAAMC,EAAQP,GAEpB,GADAE,KAAKM,MAAQT,EAAKU,SACe,mBAAtBP,KAAKM,MAAME,OAClB,MAAM,IAAIC,MAAM,uDACpBT,KAAKU,SAAWV,KAAKM,MAAMI,SAC3BV,KAAKW,UAAYX,KAAKM,MAAMK,UAC5B,MAAMD,EAAWV,KAAKU,SAChBE,EAAM,IAAIC,WAAWH,GAE3BE,EAAIE,IAAIV,EAAIW,OAASL,EAAWb,EAAKU,SAASC,OAAOJ,GAAKY,SAAWZ,GACrE,IAAK,IAAIa,EAAI,EAAGA,EAAIL,EAAIG,OAAQE,IAC5BL,EAAIK,IAAM,GACdjB,KAAKM,MAAME,OAAOI,GAElBZ,KAAKkB,MAAQrB,EAAKU,SAElB,IAAK,IAAIU,EAAI,EAAGA,EAAIL,EAAIG,OAAQE,IAC5BL,EAAIK,IAAM,IACdjB,KAAKkB,MAAMV,OAAOI,GAClBA,EAAIO,KAAK,EACjB,CACI,MAAAX,CAAOY,GAGH,OAFAC,EAAarB,MACbA,KAAKM,MAAME,OAAOY,GACXpB,IACf,CACI,UAAAsB,CAAWC,GACPF,EAAarB,MACbwB,EAAYD,EAAKvB,KAAKW,WACtBX,KAAKC,UAAW,EAChBD,KAAKM,MAAMgB,WAAWC,GACtBvB,KAAKkB,MAAMV,OAAOe,GAClBvB,KAAKkB,MAAMI,WAAWC,GACtBvB,KAAKyB,SACb,CACI,MAAAT,GACI,MAAMO,EAAM,IAAIV,WAAWb,KAAKkB,MAAMP,WAEtC,OADAX,KAAKsB,WAAWC,GACTA,CACf,CACI,UAAAG,CAAWC,GAEPA,IAAOA,EAAKC,OAAOrB,OAAOqB,OAAOC,eAAe7B,MAAO,CAAA,IACvD,MAAMkB,MAAEA,EAAKZ,MAAEA,EAAKL,SAAEA,EAAQC,UAAEA,EAASQ,SAAEA,EAAQC,UAAEA,GAAcX,KAQnE,OANA2B,EAAG1B,SAAWA,EACd0B,EAAGzB,UAAYA,EACfyB,EAAGjB,SAAWA,EACdiB,EAAGhB,UAAYA,EACfgB,EAAGT,MAAQA,EAAMQ,WAAWC,EAAGT,OAC/BS,EAAGrB,MAAQA,EAAMoB,WAAWC,EAAGrB,OACxBqB,CACf,CACI,OAAAF,GACIzB,KAAKE,WAAY,EACjBF,KAAKkB,MAAMO,UACXzB,KAAKM,MAAMmB,SACnB,EAQY,MAACK,KAAO,CAACjC,EAAMO,EAAK2B,IAAY,IAAIrC,KAAKG,EAAMO,GAAKI,OAAOuB,GAASf,SAChFc,KAAKvB,OAAS,CAACV,EAAMO,IAAQ,IAAIV,KAAKG,EAAMO","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/sha256.amd.js

@@ -0,0 +1,2 @@
+define(["exports","./_sha2.amd","./utils.amd"],(function(t,s,r){"use strict";const Maj=(t,s,r)=>t&s^t&r^s&r,i=new Uint32Array([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]),h=new Uint32Array([1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225]),o=new Uint32Array(64);class SHA256 extends s.SHA2{constructor(){super(64,32,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:s,C:r,D:i,E:h,F:o,G:e,H:n}=this;return[t,s,r,i,h,o,e,n]}set(t,s,r,i,h,o,e,n){this.A=0|t,this.B=0|s,this.C=0|r,this.D=0|i,this.E=0|h,this.F=0|o,this.G=0|e,this.H=0|n}process(t,s){for(let r=0;r<16;r++,s+=4)o[r]=t.getUint32(s,!1);for(let t=16;t<64;t++){const s=o[t-15],i=o[t-2],h=r.rotr(s,7)^r.rotr(s,18)^s>>>3,e=r.rotr(i,17)^r.rotr(i,19)^i>>>10;o[t]=e+o[t-7]+h+o[t-16]|0}let{A:h,B:e,C:n,D:c,E:a,F:l,G:A,H:f}=this;for(let t=0;t<64;t++){const s=f+(r.rotr(a,6)^r.rotr(a,11)^r.rotr(a,25))+((u=a)&l^~u&A)+i[t]+o[t]|0,H=(r.rotr(h,2)^r.rotr(h,13)^r.rotr(h,22))+Maj(h,e,n)|0;f=A,A=l,l=a,a=c+s|0,c=n,n=e,e=h,h=s+H|0}var u;h=h+this.A|0,e=e+this.B|0,n=n+this.C|0,c=c+this.D|0,a=a+this.E|0,l=l+this.F|0,A=A+this.G|0,f=f+this.H|0,this.set(h,e,n,c,a,l,A,f)}roundClean(){o.fill(0)}destroy(){this.set(0,0,0,0,0,0,0,0),this.buffer.fill(0)}}const e=r.wrapConstructor((()=>new SHA256));t.sha256=e}));
+//# sourceMappingURL=sha256.amd.js.map

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/sha256.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.amd.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/sha256.js"],"sourcesContent":["import { SHA2 } from './_sha2.js';\nimport { rotr, wrapConstructor } from './utils.js';\n// SHA2-256 need to try 2^128 hashes to execute birthday attack.\n// BTC network is doing 2^67 hashes/sec as per early 2023.\n// Choice: a ? b : c\nconst Chi = (a, b, c) => (a & b) ^ (~a & c);\n// Majority function, true if any two inpust is true\nconst Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);\n// Round constants:\n// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)\n// prettier-ignore\nconst SHA256_K = /* @__PURE__ */ new Uint32Array([\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// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n// prettier-ignore\nconst IV = /* @__PURE__ */ new Uint32Array([\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n]);\n// Temporary buffer, not used to store anything between runs\n// Named this way because it matches specification.\nconst SHA256_W = /* @__PURE__ */ new Uint32Array(64);\nclass SHA256 extends SHA2 {\n    constructor() {\n        super(64, 32, 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 = IV[0] | 0;\n        this.B = IV[1] | 0;\n        this.C = IV[2] | 0;\n        this.D = IV[3] | 0;\n        this.E = IV[4] | 0;\n        this.F = IV[5] | 0;\n        this.G = IV[6] | 0;\n        this.H = 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        SHA256_W.fill(0);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n        this.buffer.fill(0);\n    }\n}\n// Constants from https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf\nclass SHA224 extends SHA256 {\n    constructor() {\n        super();\n        this.A = 0xc1059ed8 | 0;\n        this.B = 0x367cd507 | 0;\n        this.C = 0x3070dd17 | 0;\n        this.D = 0xf70e5939 | 0;\n        this.E = 0xffc00b31 | 0;\n        this.F = 0x68581511 | 0;\n        this.G = 0x64f98fa7 | 0;\n        this.H = 0xbefa4fa4 | 0;\n        this.outputLen = 28;\n    }\n}\n/**\n * SHA2-256 hash function\n * @param message - data that would be hashed\n */\nexport const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());\nexport const sha224 = /* @__PURE__ */ wrapConstructor(() => new SHA224());\n//# sourceMappingURL=sha256.js.map"],"names":["Maj","a","b","c","SHA256_K","Uint32Array","IV","SHA256_W","SHA256","SHA2","constructor","super","this","A","B","C","D","E","F","G","H","get","set","process","view","offset","i","getUint32","W15","W2","s0","rotr","s1","T1","T2","roundClean","fill","destroy","buffer","sha256","wrapConstructor"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/sha256.esm.js

@@ -0,0 +1,2 @@
+import{SHA2 as t}from"./_sha2.esm.js";import{wrapConstructor as s,rotr as i}from"./utils.esm.js";const Maj=(t,s,i)=>t&s^t&i^s&i,h=new Uint32Array([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]),e=new Uint32Array([1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225]),r=new Uint32Array(64);class SHA256 extends t{constructor(){super(64,32,8,!1),this.A=0|e[0],this.B=0|e[1],this.C=0|e[2],this.D=0|e[3],this.E=0|e[4],this.F=0|e[5],this.G=0|e[6],this.H=0|e[7]}get(){const{A:t,B:s,C:i,D:h,E:e,F:r,G:n,H:o}=this;return[t,s,i,h,e,r,n,o]}set(t,s,i,h,e,r,n,o){this.A=0|t,this.B=0|s,this.C=0|i,this.D=0|h,this.E=0|e,this.F=0|r,this.G=0|n,this.H=0|o}process(t,s){for(let i=0;i<16;i++,s+=4)r[i]=t.getUint32(s,!1);for(let t=16;t<64;t++){const s=r[t-15],h=r[t-2],e=i(s,7)^i(s,18)^s>>>3,n=i(h,17)^i(h,19)^h>>>10;r[t]=n+r[t-7]+e+r[t-16]|0}let{A:e,B:n,C:o,D:l,E:A,F:c,G:f,H:a}=this;for(let t=0;t<64;t++){const s=a+(i(A,6)^i(A,11)^i(A,25))+((H=A)&c^~H&f)+h[t]+r[t]|0,m=(i(e,2)^i(e,13)^i(e,22))+Maj(e,n,o)|0;a=f,f=c,c=A,A=l+s|0,l=o,o=n,n=e,e=s+m|0}var H;e=e+this.A|0,n=n+this.B|0,o=o+this.C|0,l=l+this.D|0,A=A+this.E|0,c=c+this.F|0,f=f+this.G|0,a=a+this.H|0,this.set(e,n,o,l,A,c,f,a)}roundClean(){r.fill(0)}destroy(){this.set(0,0,0,0,0,0,0,0),this.buffer.fill(0)}}const n=s((()=>new SHA256));export{n as sha256};
+//# sourceMappingURL=sha256.esm.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/sha256.js"],"sourcesContent":["import { SHA2 } from './_sha2.js';\nimport { rotr, wrapConstructor } from './utils.js';\n// SHA2-256 need to try 2^128 hashes to execute birthday attack.\n// BTC network is doing 2^67 hashes/sec as per early 2023.\n// Choice: a ? b : c\nconst Chi = (a, b, c) => (a & b) ^ (~a & c);\n// Majority function, true if any two inpust is true\nconst Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);\n// Round constants:\n// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)\n// prettier-ignore\nconst SHA256_K = /* @__PURE__ */ new Uint32Array([\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// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n// prettier-ignore\nconst IV = /* @__PURE__ */ new Uint32Array([\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n]);\n// Temporary buffer, not used to store anything between runs\n// Named this way because it matches specification.\nconst SHA256_W = /* @__PURE__ */ new Uint32Array(64);\nclass SHA256 extends SHA2 {\n    constructor() {\n        super(64, 32, 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 = IV[0] | 0;\n        this.B = IV[1] | 0;\n        this.C = IV[2] | 0;\n        this.D = IV[3] | 0;\n        this.E = IV[4] | 0;\n        this.F = IV[5] | 0;\n        this.G = IV[6] | 0;\n        this.H = 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        SHA256_W.fill(0);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n        this.buffer.fill(0);\n    }\n}\n// Constants from https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf\nclass SHA224 extends SHA256 {\n    constructor() {\n        super();\n        this.A = 0xc1059ed8 | 0;\n        this.B = 0x367cd507 | 0;\n        this.C = 0x3070dd17 | 0;\n        this.D = 0xf70e5939 | 0;\n        this.E = 0xffc00b31 | 0;\n        this.F = 0x68581511 | 0;\n        this.G = 0x64f98fa7 | 0;\n        this.H = 0xbefa4fa4 | 0;\n        this.outputLen = 28;\n    }\n}\n/**\n * SHA2-256 hash function\n * @param message - data that would be hashed\n */\nexport const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());\nexport const sha224 = /* @__PURE__ */ wrapConstructor(() => new SHA224());\n//# sourceMappingURL=sha256.js.map"],"names":["Maj","a","b","c","SHA256_K","Uint32Array","IV","SHA256_W","SHA256","SHA2","constructor","super","this","A","B","C","D","E","F","G","H","get","set","process","view","offset","i","getUint32","W15","W2","s0","rotr","s1","T1","T2","roundClean","fill","destroy","buffer","sha256","wrapConstructor"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/utils.amd.js

@@ -0,0 +1,3 @@
+define(["exports","./crypto.amd"],(function(t,e){"use strict";
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */const u8a=t=>t instanceof Uint8Array,r=68===new Uint8Array(new Uint32Array([287454020]).buffer)[0];if(!r)throw new Error("Non little-endian hardware is not supported");function utf8ToBytes(t){if("string"!=typeof t)throw new Error("utf8ToBytes expected string, got "+typeof t);return new Uint8Array((new TextEncoder).encode(t))}function toBytes(t){if("string"==typeof t&&(t=utf8ToBytes(t)),!u8a(t))throw new Error("expected Uint8Array, got "+typeof t);return t}t.Hash=class Hash{clone(){return this._cloneInto()}},t.concatBytes=function concatBytes(...t){const e=new Uint8Array(t.reduce(((t,e)=>t+e.length),0));let r=0;return t.forEach((t=>{if(!u8a(t))throw new Error("Uint8Array expected");e.set(t,r),r+=t.length})),e},t.createView=t=>new DataView(t.buffer,t.byteOffset,t.byteLength),t.isLE=r,t.randomBytes=function randomBytes(t=32){if(e.crypto&&"function"==typeof e.crypto.getRandomValues)return e.crypto.getRandomValues(new Uint8Array(t));throw new Error("crypto.getRandomValues must be defined")},t.rotr=(t,e)=>t<<32-e|t>>>e,t.toBytes=toBytes,t.utf8ToBytes=utf8ToBytes,t.wrapConstructor=function wrapConstructor(t){const hashC=e=>t().update(toBytes(e)).digest(),e=t();return hashC.outputLen=e.outputLen,hashC.blockLen=e.blockLen,hashC.create=()=>t(),hashC}}));
+//# sourceMappingURL=utils.amd.js.map

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/utils.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.amd.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/utils.js"],"sourcesContent":["/*! 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, we can just drop the import.\nimport { crypto } from '@noble/hashes/crypto';\nconst u8a = (a) => a instanceof Uint8Array;\n// Cast array to different type\nexport const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexport const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n// Cast array to view\nexport const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n// The rotate right (circular right shift) operation for uint32\nexport const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);\n// big-endian hardware is rare. Just in case someone still decides to run hashes:\n// early-throw an error because we don't support BE yet.\nexport const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;\nif (!isLE)\n    throw new Error('Non little-endian hardware is not supported');\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    if (!u8a(bytes))\n        throw new Error('Uint8Array expected');\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/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    const len = hex.length;\n    if (len % 2)\n        throw new Error('padded hex string expected, got unpadded hex of length ' + len);\n    const array = new Uint8Array(len / 2);\n    for (let i = 0; i < array.length; i++) {\n        const j = i * 2;\n        const hexByte = hex.slice(j, j + 2);\n        const byte = Number.parseInt(hexByte, 16);\n        if (Number.isNaN(byte) || byte < 0)\n            throw new Error('Invalid byte sequence');\n        array[i] = byte;\n    }\n    return array;\n}\n// There is no setImmediate in browser and setTimeout is slow.\n// call of async fn will return Promise, which will be fullfiled only on\n// next scheduler queue processing step and this is exactly what we need.\nexport const nextTick = async () => { };\n// Returns control to thread each 'tick' ms to avoid blocking\nexport async function asyncLoop(iters, tick, cb) {\n    let ts = Date.now();\n    for (let i = 0; i < iters; i++) {\n        cb(i);\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < tick)\n            continue;\n        await nextTick();\n        ts += diff;\n    }\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    if (!u8a(data))\n        throw new Error(`expected Uint8Array, got ${typeof data}`);\n    return data;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));\n    let pad = 0; // walk through each item, ensure they have proper type\n    arrays.forEach((a) => {\n        if (!u8a(a))\n            throw new Error('Uint8Array expected');\n        r.set(a, pad);\n        pad += a.length;\n    });\n    return r;\n}\n// For runtime check if class implements interface\nexport class Hash {\n    // Safe version that clones internal state\n    clone() {\n        return this._cloneInto();\n    }\n}\nconst toStr = {}.toString;\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && toStr.call(opts) !== '[object Object]')\n        throw new Error('Options should be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\nexport function wrapConstructor(hashCons) {\n    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();\n    const tmp = hashCons();\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = () => hashCons();\n    return hashC;\n}\nexport function wrapConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport function wrapXOFConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\n/**\n * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.\n */\nexport function randomBytes(bytesLength = 32) {\n    if (crypto && typeof crypto.getRandomValues === 'function') {\n        return crypto.getRandomValues(new Uint8Array(bytesLength));\n    }\n    throw new Error('crypto.getRandomValues must be defined');\n}\n//# sourceMappingURL=utils.js.map"],"names":["u8a","a","Uint8Array","isLE","Uint32Array","buffer","Error","utf8ToBytes","str","TextEncoder","encode","toBytes","data","Hash","clone","this","_cloneInto","concatBytes","arrays","r","reduce","sum","length","pad","forEach","set","arr","DataView","byteOffset","byteLength","randomBytes","bytesLength","crypto","getRandomValues","word","shift","wrapConstructor","hashCons","hashC","msg","update","digest","tmp","outputLen","blockLen","create"],"mappings":";sEAQA,MAAMA,IAAOC,GAAMA,aAAaC,WAUnBC,EAAmE,KAA5D,IAAID,WAAW,IAAIE,YAAY,CAAC,YAAaC,QAAQ,GACzE,IAAKF,EACD,MAAM,IAAIG,MAAM,+CAuDb,SAASC,YAAYC,GACxB,GAAmB,iBAARA,EACP,MAAM,IAAIF,MAAM,2CAA2CE,GAC/D,OAAO,IAAIN,YAAW,IAAIO,aAAcC,OAAOF,GACnD,CAMO,SAASG,QAAQC,GAGpB,GAFoB,iBAATA,IACPA,EAAOL,YAAYK,KAClBZ,IAAIY,GACL,MAAM,IAAIN,MAAM,mCAAmCM,GACvD,OAAOA,CACX,QAgBO,MAAMC,KAET,KAAAC,GACI,OAAOC,KAAKC,YACpB,iBAhBO,SAASC,eAAeC,GAC3B,MAAMC,EAAI,IAAIjB,WAAWgB,EAAOE,QAAO,CAACC,EAAKpB,IAAMoB,EAAMpB,EAAEqB,QAAQ,IACnE,IAAIC,EAAM,EAOV,OANAL,EAAOM,SAASvB,IACZ,IAAKD,IAAIC,GACL,MAAM,IAAIK,MAAM,uBACpBa,EAAEM,IAAIxB,EAAGsB,GACTA,GAAOtB,EAAEqB,MAAM,IAEZH,CACX,eA5F2BO,GAAQ,IAAIC,SAASD,EAAIrB,OAAQqB,EAAIE,WAAYF,EAAIG,mCAsIzE,SAASC,YAAYC,EAAc,IACtC,GAAIC,UAA4C,mBAA3BA,SAAOC,gBACxB,OAAOD,EAAMA,OAACC,gBAAgB,IAAI/B,WAAW6B,IAEjD,MAAM,IAAIzB,MAAM,yCACpB,SAzIoB,CAAC4B,EAAMC,IAAWD,GAAS,GAAKC,EAAWD,IAASC,gEAyGjE,SAASC,gBAAgBC,GAC5B,MAAMC,MAASC,GAAQF,IAAWG,OAAO7B,QAAQ4B,IAAME,SACjDC,EAAML,IAIZ,OAHAC,MAAMK,UAAYD,EAAIC,UACtBL,MAAMM,SAAWF,EAAIE,SACrBN,MAAMO,OAAS,IAAMR,IACdC,KACX","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/utils.esm.js

@@ -0,0 +1,4 @@
+import{crypto as t}from"./crypto.esm.js";
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const u8a=t=>t instanceof Uint8Array,createView=t=>new DataView(t.buffer,t.byteOffset,t.byteLength),rotr=(t,e)=>t<<32-e|t>>>e,e=68===new Uint8Array(new Uint32Array([287454020]).buffer)[0];if(!e)throw new Error("Non little-endian hardware is not supported");function utf8ToBytes(t){if("string"!=typeof t)throw new Error("utf8ToBytes expected string, got "+typeof t);return new Uint8Array((new TextEncoder).encode(t))}function toBytes(t){if("string"==typeof t&&(t=utf8ToBytes(t)),!u8a(t))throw new Error("expected Uint8Array, got "+typeof t);return t}function concatBytes(...t){const e=new Uint8Array(t.reduce(((t,e)=>t+e.length),0));let r=0;return t.forEach((t=>{if(!u8a(t))throw new Error("Uint8Array expected");e.set(t,r),r+=t.length})),e}class Hash{clone(){return this._cloneInto()}}function wrapConstructor(t){const hashC=e=>t().update(toBytes(e)).digest(),e=t();return hashC.outputLen=e.outputLen,hashC.blockLen=e.blockLen,hashC.create=()=>t(),hashC}function randomBytes(e=32){if(t&&"function"==typeof t.getRandomValues)return t.getRandomValues(new Uint8Array(e));throw new Error("crypto.getRandomValues must be defined")}export{Hash,concatBytes,createView,e as isLE,randomBytes,rotr,toBytes,utf8ToBytes,wrapConstructor};
+//# sourceMappingURL=utils.esm.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/utils.js"],"sourcesContent":["/*! 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, we can just drop the import.\nimport { crypto } from '@noble/hashes/crypto';\nconst u8a = (a) => a instanceof Uint8Array;\n// Cast array to different type\nexport const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexport const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n// Cast array to view\nexport const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n// The rotate right (circular right shift) operation for uint32\nexport const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);\n// big-endian hardware is rare. Just in case someone still decides to run hashes:\n// early-throw an error because we don't support BE yet.\nexport const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;\nif (!isLE)\n    throw new Error('Non little-endian hardware is not supported');\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    if (!u8a(bytes))\n        throw new Error('Uint8Array expected');\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/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    const len = hex.length;\n    if (len % 2)\n        throw new Error('padded hex string expected, got unpadded hex of length ' + len);\n    const array = new Uint8Array(len / 2);\n    for (let i = 0; i < array.length; i++) {\n        const j = i * 2;\n        const hexByte = hex.slice(j, j + 2);\n        const byte = Number.parseInt(hexByte, 16);\n        if (Number.isNaN(byte) || byte < 0)\n            throw new Error('Invalid byte sequence');\n        array[i] = byte;\n    }\n    return array;\n}\n// There is no setImmediate in browser and setTimeout is slow.\n// call of async fn will return Promise, which will be fullfiled only on\n// next scheduler queue processing step and this is exactly what we need.\nexport const nextTick = async () => { };\n// Returns control to thread each 'tick' ms to avoid blocking\nexport async function asyncLoop(iters, tick, cb) {\n    let ts = Date.now();\n    for (let i = 0; i < iters; i++) {\n        cb(i);\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < tick)\n            continue;\n        await nextTick();\n        ts += diff;\n    }\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    if (!u8a(data))\n        throw new Error(`expected Uint8Array, got ${typeof data}`);\n    return data;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));\n    let pad = 0; // walk through each item, ensure they have proper type\n    arrays.forEach((a) => {\n        if (!u8a(a))\n            throw new Error('Uint8Array expected');\n        r.set(a, pad);\n        pad += a.length;\n    });\n    return r;\n}\n// For runtime check if class implements interface\nexport class Hash {\n    // Safe version that clones internal state\n    clone() {\n        return this._cloneInto();\n    }\n}\nconst toStr = {}.toString;\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && toStr.call(opts) !== '[object Object]')\n        throw new Error('Options should be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\nexport function wrapConstructor(hashCons) {\n    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();\n    const tmp = hashCons();\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = () => hashCons();\n    return hashC;\n}\nexport function wrapConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport function wrapXOFConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\n/**\n * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.\n */\nexport function randomBytes(bytesLength = 32) {\n    if (crypto && typeof crypto.getRandomValues === 'function') {\n        return crypto.getRandomValues(new Uint8Array(bytesLength));\n    }\n    throw new Error('crypto.getRandomValues must be defined');\n}\n//# sourceMappingURL=utils.js.map"],"names":["u8a","a","Uint8Array","createView","arr","DataView","buffer","byteOffset","byteLength","rotr","word","shift","isLE","Uint32Array","Error","utf8ToBytes","str","TextEncoder","encode","toBytes","data","concatBytes","arrays","r","reduce","sum","length","pad","forEach","set","Hash","clone","this","_cloneInto","wrapConstructor","hashCons","hashC","msg","update","digest","tmp","outputLen","blockLen","create","randomBytes","bytesLength","crypto","getRandomValues"],"mappings":";;AAQA,MAAMA,IAAOC,GAAMA,aAAaC,WAKnBC,WAAcC,GAAQ,IAAIC,SAASD,EAAIE,OAAQF,EAAIG,WAAYH,EAAII,YAEnEC,KAAO,CAACC,EAAMC,IAAWD,GAAS,GAAKC,EAAWD,IAASC,EAG3DC,EAAmE,KAA5D,IAAIV,WAAW,IAAIW,YAAY,CAAC,YAAaP,QAAQ,GACzE,IAAKM,EACD,MAAM,IAAIE,MAAM,+CAuDb,SAASC,YAAYC,GACxB,GAAmB,iBAARA,EACP,MAAM,IAAIF,MAAM,2CAA2CE,GAC/D,OAAO,IAAId,YAAW,IAAIe,aAAcC,OAAOF,GACnD,CAMO,SAASG,QAAQC,GAGpB,GAFoB,iBAATA,IACPA,EAAOL,YAAYK,KAClBpB,IAAIoB,GACL,MAAM,IAAIN,MAAM,mCAAmCM,GACvD,OAAOA,CACX,CAIO,SAASC,eAAeC,GAC3B,MAAMC,EAAI,IAAIrB,WAAWoB,EAAOE,QAAO,CAACC,EAAKxB,IAAMwB,EAAMxB,EAAEyB,QAAQ,IACnE,IAAIC,EAAM,EAOV,OANAL,EAAOM,SAAS3B,IACZ,IAAKD,IAAIC,GACL,MAAM,IAAIa,MAAM,uBACpBS,EAAEM,IAAI5B,EAAG0B,GACTA,GAAO1B,EAAEyB,MAAM,IAEZH,CACX,CAEO,MAAMO,KAET,KAAAC,GACI,OAAOC,KAAKC,YACpB,EASO,SAASC,gBAAgBC,GAC5B,MAAMC,MAASC,GAAQF,IAAWG,OAAOnB,QAAQkB,IAAME,SACjDC,EAAML,IAIZ,OAHAC,MAAMK,UAAYD,EAAIC,UACtBL,MAAMM,SAAWF,EAAIE,SACrBN,MAAMO,OAAS,IAAMR,IACdC,KACX,CAoBO,SAASQ,YAAYC,EAAc,IACtC,GAAIC,GAA4C,mBAA3BA,EAAOC,gBACxB,OAAOD,EAAOC,gBAAgB,IAAI7C,WAAW2C,IAEjD,MAAM,IAAI/B,MAAM,yCACpB","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.amd.js

@@ -0,0 +1,2 @@
+define(["exports"],(function(t){"use strict";function isBytes(t){return t instanceof Uint8Array||null!=t&&"object"==typeof t&&"Uint8Array"===t.constructor.name}t.bytes=function bytes(t,...e){if(!isBytes(t))throw new Error("Uint8Array expected");if(e.length>0&&!e.includes(t.length))throw new Error(`Uint8Array expected of length ${e}, not of length=${t.length}`)},t.isBytes=isBytes}));
+//# sourceMappingURL=_assert.amd.js.map

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_assert.amd.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js"],"sourcesContent":["function number(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error(`positive integer expected, not ${n}`);\n}\nfunction bool(b) {\n    if (typeof b !== 'boolean')\n        throw new Error(`boolean expected, not ${b}`);\n}\n// copied from utils\nexport function isBytes(a) {\n    return (a instanceof Uint8Array ||\n        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));\n}\nfunction bytes(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}, not of length=${b.length}`);\n}\nfunction hash(h) {\n    if (typeof h !== 'function' || typeof h.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.wrapConstructor');\n    number(h.outputLen);\n    number(h.blockLen);\n}\nfunction exists(instance, checkFinished = true) {\n    if (instance.destroyed)\n        throw new Error('Hash instance has been destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('Hash#digest() has already been called');\n}\nfunction output(out, instance) {\n    bytes(out);\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error(`digestInto() expects output buffer of length at least ${min}`);\n    }\n}\nexport { number, bool, bytes, hash, exists, output };\nconst assert = { number, bool, bytes, hash, exists, output };\nexport default assert;\n//# sourceMappingURL=_assert.js.map"],"names":["isBytes","a","Uint8Array","constructor","name","bytes","b","lengths","Error","length","includes"],"mappings":"6CASO,SAASA,QAAQC,GACpB,OAAQA,aAAaC,YACX,MAALD,GAA0B,iBAANA,GAAyC,eAAvBA,EAAEE,YAAYC,IAC7D,SACA,SAASC,MAAMC,KAAMC,GACjB,IAAKP,QAAQM,GACT,MAAM,IAAIE,MAAM,uBACpB,GAAID,EAAQE,OAAS,IAAMF,EAAQG,SAASJ,EAAEG,QAC1C,MAAM,IAAID,MAAM,iCAAiCD,oBAA0BD,EAAEG,SACrF","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.esm.js

@@ -0,0 +1,2 @@
+function isBytes(t){return t instanceof Uint8Array||null!=t&&"object"==typeof t&&"Uint8Array"===t.constructor.name}function bytes(t,...e){if(!isBytes(t))throw new Error("Uint8Array expected");if(e.length>0&&!e.includes(t.length))throw new Error(`Uint8Array expected of length ${e}, not of length=${t.length}`)}export{bytes,isBytes};
+//# sourceMappingURL=_assert.esm.js.map

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_assert.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js"],"sourcesContent":["function number(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error(`positive integer expected, not ${n}`);\n}\nfunction bool(b) {\n    if (typeof b !== 'boolean')\n        throw new Error(`boolean expected, not ${b}`);\n}\n// copied from utils\nexport function isBytes(a) {\n    return (a instanceof Uint8Array ||\n        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));\n}\nfunction bytes(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}, not of length=${b.length}`);\n}\nfunction hash(h) {\n    if (typeof h !== 'function' || typeof h.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.wrapConstructor');\n    number(h.outputLen);\n    number(h.blockLen);\n}\nfunction exists(instance, checkFinished = true) {\n    if (instance.destroyed)\n        throw new Error('Hash instance has been destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('Hash#digest() has already been called');\n}\nfunction output(out, instance) {\n    bytes(out);\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error(`digestInto() expects output buffer of length at least ${min}`);\n    }\n}\nexport { number, bool, bytes, hash, exists, output };\nconst assert = { number, bool, bytes, hash, exists, output };\nexport default assert;\n//# sourceMappingURL=_assert.js.map"],"names":["isBytes","a","Uint8Array","constructor","name","bytes","b","lengths","Error","length","includes"],"mappings":"AASO,SAASA,QAAQC,GACpB,OAAQA,aAAaC,YACX,MAALD,GAA0B,iBAANA,GAAyC,eAAvBA,EAAEE,YAAYC,IAC7D,CACA,SAASC,MAAMC,KAAMC,GACjB,IAAKP,QAAQM,GACT,MAAM,IAAIE,MAAM,uBACpB,GAAID,EAAQE,OAAS,IAAMF,EAAQG,SAASJ,EAAEG,QAC1C,MAAM,IAAID,MAAM,iCAAiCD,oBAA0BD,EAAEG,SACrF","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.5.0/node_modules/@noble/hashes/esm/utils.amd.js

@@ -0,0 +1,3 @@
+define(["exports","./_assert.amd"],(function(e,t){"use strict";
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */new Uint8Array(new Uint32Array([287454020]).buffer)[0];const r=Array.from({length:256},((e,t)=>t.toString(16).padStart(2,"0")));const n=48,o=57,i=65,s=70,a=97,c=102;function asciiToBase16(e){return e>=n&&e<=o?e-n:e>=i&&e<=s?e-(i-10):e>=a&&e<=c?e-(a-10):void 0}e.bytesToHex=function bytesToHex(e){t.bytes(e);let n="";for(let t=0;t<e.length;t++)n+=r[e[t]];return n},e.hexToBytes=function hexToBytes(e){if("string"!=typeof e)throw new Error("hex string expected, got "+typeof e);const t=e.length,r=t/2;if(t%2)throw new Error("padded hex string expected, got unpadded hex of length "+t);const n=new Uint8Array(r);for(let t=0,o=0;t<r;t++,o+=2){const r=asciiToBase16(e.charCodeAt(o)),i=asciiToBase16(e.charCodeAt(o+1));if(void 0===r||void 0===i){const t=e[o]+e[o+1];throw new Error('hex string expected, got non-hex character "'+t+'" at index '+o)}n[t]=16*r+i}return n}}));
+//# sourceMappingURL=utils.amd.js.map

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.5.0/node_modules/@noble/hashes/esm/utils.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.amd.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js"],"sourcesContent":["/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.\n// node.js versions earlier than v19 don't declare it in global scope.\n// For node.js, package.json#exports field mapping rewrites import\n// from `crypto` to `cryptoNode`, which imports native module.\n// Makes the utils un-importable in browsers without a bundler.\n// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.\nimport { crypto } from '@noble/hashes/crypto';\nimport { bytes as abytes } from './_assert.js';\n// export { isBytes } from './_assert.js';\n// We can't reuse isBytes from _assert, because somehow this causes huge perf issues\nexport function isBytes(a) {\n    return (a instanceof Uint8Array ||\n        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));\n}\n// Cast array to different type\nexport const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexport const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n// Cast array to view\nexport const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n// The rotate right (circular right shift) operation for uint32\nexport const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);\n// The rotate left (circular left shift) operation for uint32\nexport const rotl = (word, shift) => (word << shift) | ((word >>> (32 - shift)) >>> 0);\nexport const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;\n// The byte swap operation for uint32\nexport const byteSwap = (word) => ((word << 24) & 0xff000000) |\n    ((word << 8) & 0xff0000) |\n    ((word >>> 8) & 0xff00) |\n    ((word >>> 24) & 0xff);\n// Conditionally byte swap if on a big-endian platform\nexport const byteSwapIfBE = isLE ? (n) => n : (n) => byteSwap(n);\n// In place byte swap for Uint32Array\nexport function byteSwap32(arr) {\n    for (let i = 0; i < arr.length; i++) {\n        arr[i] = byteSwap(arr[i]);\n    }\n}\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    abytes(bytes);\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };\nfunction asciiToBase16(char) {\n    if (char >= asciis._0 && char <= asciis._9)\n        return char - asciis._0;\n    if (char >= asciis._A && char <= asciis._F)\n        return char - (asciis._A - 10);\n    if (char >= asciis._a && char <= asciis._f)\n        return char - (asciis._a - 10);\n    return;\n}\n/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new Error('padded hex string expected, got unpadded hex of length ' + hl);\n    const array = new Uint8Array(al);\n    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n        const n1 = asciiToBase16(hex.charCodeAt(hi));\n        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n        if (n1 === undefined || n2 === undefined) {\n            const char = hex[hi] + hex[hi + 1];\n            throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n        }\n        array[ai] = n1 * 16 + n2;\n    }\n    return array;\n}\n// There is no setImmediate in browser and setTimeout is slow.\n// call of async fn will return Promise, which will be fullfiled only on\n// next scheduler queue processing step and this is exactly what we need.\nexport const nextTick = async () => { };\n// Returns control to thread each 'tick' ms to avoid blocking\nexport async function asyncLoop(iters, tick, cb) {\n    let ts = Date.now();\n    for (let i = 0; i < iters; i++) {\n        cb(i);\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < tick)\n            continue;\n        await nextTick();\n        ts += diff;\n    }\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    abytes(data);\n    return data;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        abytes(a);\n        sum += a.length;\n    }\n    const res = new Uint8Array(sum);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        res.set(a, pad);\n        pad += a.length;\n    }\n    return res;\n}\n// For runtime check if class implements interface\nexport class Hash {\n    // Safe version that clones internal state\n    clone() {\n        return this._cloneInto();\n    }\n}\nconst toStr = {}.toString;\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && toStr.call(opts) !== '[object Object]')\n        throw new Error('Options should be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\nexport function wrapConstructor(hashCons) {\n    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();\n    const tmp = hashCons();\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = () => hashCons();\n    return hashC;\n}\nexport function wrapConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport function wrapXOFConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\n/**\n * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.\n */\nexport function randomBytes(bytesLength = 32) {\n    if (crypto && typeof crypto.getRandomValues === 'function') {\n        return crypto.getRandomValues(new Uint8Array(bytesLength));\n    }\n    // Legacy Node.js compatibility\n    if (crypto && typeof crypto.randomBytes === 'function') {\n        return crypto.randomBytes(bytesLength);\n    }\n    throw new Error('crypto.getRandomValues must be defined');\n}\n//# sourceMappingURL=utils.js.map"],"names":["Uint8Array","Uint32Array","buffer","hexes","Array","from","length","_","i","toString","padStart","asciis","asciiToBase16","char","bytesToHex","bytes","abytes","hex","hexToBytes","Error","hl","al","array","ai","hi","n1","charCodeAt","n2","undefined"],"mappings":";sEAwBoB,IAAIA,WAAW,IAAIC,YAAY,CAAC,YAAaC,QAAQ,GAezE,MAAMC,EAAwBC,MAAMC,KAAK,CAAEC,OAAQ,MAAO,CAACC,EAAGC,IAAMA,EAAEC,SAAS,IAAIC,SAAS,EAAG,OAc/F,MAAMC,EAAe,GAAfA,EAAuB,GAAvBA,EAA+B,GAA/BA,EAAuC,GAAvCA,EAA+C,GAA/CA,EAAuD,IAC7D,SAASC,cAAcC,GACnB,OAAIA,GAAQF,GAAaE,GAAQF,EACtBE,EAAOF,EACdE,GAAQF,GAAaE,GAAQF,EACtBE,GAAQF,EAAY,IAC3BE,GAAQF,GAAaE,GAAQF,EACtBE,GAAQF,EAAY,SAD/B,CAGJ,cAnBO,SAASG,WAAWC,GACvBC,EAAAA,MAAOD,GAEP,IAAIE,EAAM,GACV,IAAK,IAAIT,EAAI,EAAGA,EAAIO,EAAMT,OAAQE,IAC9BS,GAAOd,EAAMY,EAAMP,IAEvB,OAAOS,CACX,eAeO,SAASC,WAAWD,GACvB,GAAmB,iBAARA,EACP,MAAM,IAAIE,MAAM,mCAAqCF,GACzD,MAAMG,EAAKH,EAAIX,OACTe,EAAKD,EAAK,EAChB,GAAIA,EAAK,EACL,MAAM,IAAID,MAAM,0DAA4DC,GAChF,MAAME,EAAQ,IAAItB,WAAWqB,GAC7B,IAAK,IAAIE,EAAK,EAAGC,EAAK,EAAGD,EAAKF,EAAIE,IAAMC,GAAM,EAAG,CAC7C,MAAMC,EAAKb,cAAcK,EAAIS,WAAWF,IAClCG,EAAKf,cAAcK,EAAIS,WAAWF,EAAK,IAC7C,QAAWI,IAAPH,QAA2BG,IAAPD,EAAkB,CACtC,MAAMd,EAAOI,EAAIO,GAAMP,EAAIO,EAAK,GAChC,MAAM,IAAIL,MAAM,+CAAiDN,EAAO,cAAgBW,EACpG,CACQF,EAAMC,GAAW,GAALE,EAAUE,CAC9B,CACI,OAAOL,CACX","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_hashes@1.5.0/node_modules/@noble/hashes/esm/utils.esm.js

@@ -0,0 +1,4 @@
+import{bytes as e}from"./_assert.esm.js";
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+new Uint8Array(new Uint32Array([287454020]).buffer)[0];const t=Array.from({length:256},((e,t)=>t.toString(16).padStart(2,"0")));function bytesToHex(r){e(r);let o="";for(let e=0;e<r.length;e++)o+=t[r[e]];return o}const r=48,o=57,n=65,i=70,s=97,a=102;function asciiToBase16(e){return e>=r&&e<=o?e-r:e>=n&&e<=i?e-(n-10):e>=s&&e<=a?e-(s-10):void 0}function hexToBytes(e){if("string"!=typeof e)throw new Error("hex string expected, got "+typeof e);const t=e.length,r=t/2;if(t%2)throw new Error("padded hex string expected, got unpadded hex of length "+t);const o=new Uint8Array(r);for(let t=0,n=0;t<r;t++,n+=2){const r=asciiToBase16(e.charCodeAt(n)),i=asciiToBase16(e.charCodeAt(n+1));if(void 0===r||void 0===i){const t=e[n]+e[n+1];throw new Error('hex string expected, got non-hex character "'+t+'" at index '+n)}o[t]=16*r+i}return o}export{bytesToHex,hexToBytes};
+//# sourceMappingURL=utils.esm.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js"],"sourcesContent":["/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.\n// node.js versions earlier than v19 don't declare it in global scope.\n// For node.js, package.json#exports field mapping rewrites import\n// from `crypto` to `cryptoNode`, which imports native module.\n// Makes the utils un-importable in browsers without a bundler.\n// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.\nimport { crypto } from '@noble/hashes/crypto';\nimport { bytes as abytes } from './_assert.js';\n// export { isBytes } from './_assert.js';\n// We can't reuse isBytes from _assert, because somehow this causes huge perf issues\nexport function isBytes(a) {\n    return (a instanceof Uint8Array ||\n        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));\n}\n// Cast array to different type\nexport const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexport const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n// Cast array to view\nexport const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n// The rotate right (circular right shift) operation for uint32\nexport const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);\n// The rotate left (circular left shift) operation for uint32\nexport const rotl = (word, shift) => (word << shift) | ((word >>> (32 - shift)) >>> 0);\nexport const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;\n// The byte swap operation for uint32\nexport const byteSwap = (word) => ((word << 24) & 0xff000000) |\n    ((word << 8) & 0xff0000) |\n    ((word >>> 8) & 0xff00) |\n    ((word >>> 24) & 0xff);\n// Conditionally byte swap if on a big-endian platform\nexport const byteSwapIfBE = isLE ? (n) => n : (n) => byteSwap(n);\n// In place byte swap for Uint32Array\nexport function byteSwap32(arr) {\n    for (let i = 0; i < arr.length; i++) {\n        arr[i] = byteSwap(arr[i]);\n    }\n}\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    abytes(bytes);\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };\nfunction asciiToBase16(char) {\n    if (char >= asciis._0 && char <= asciis._9)\n        return char - asciis._0;\n    if (char >= asciis._A && char <= asciis._F)\n        return char - (asciis._A - 10);\n    if (char >= asciis._a && char <= asciis._f)\n        return char - (asciis._a - 10);\n    return;\n}\n/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new Error('padded hex string expected, got unpadded hex of length ' + hl);\n    const array = new Uint8Array(al);\n    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n        const n1 = asciiToBase16(hex.charCodeAt(hi));\n        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n        if (n1 === undefined || n2 === undefined) {\n            const char = hex[hi] + hex[hi + 1];\n            throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n        }\n        array[ai] = n1 * 16 + n2;\n    }\n    return array;\n}\n// There is no setImmediate in browser and setTimeout is slow.\n// call of async fn will return Promise, which will be fullfiled only on\n// next scheduler queue processing step and this is exactly what we need.\nexport const nextTick = async () => { };\n// Returns control to thread each 'tick' ms to avoid blocking\nexport async function asyncLoop(iters, tick, cb) {\n    let ts = Date.now();\n    for (let i = 0; i < iters; i++) {\n        cb(i);\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < tick)\n            continue;\n        await nextTick();\n        ts += diff;\n    }\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    abytes(data);\n    return data;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        abytes(a);\n        sum += a.length;\n    }\n    const res = new Uint8Array(sum);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        res.set(a, pad);\n        pad += a.length;\n    }\n    return res;\n}\n// For runtime check if class implements interface\nexport class Hash {\n    // Safe version that clones internal state\n    clone() {\n        return this._cloneInto();\n    }\n}\nconst toStr = {}.toString;\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && toStr.call(opts) !== '[object Object]')\n        throw new Error('Options should be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\nexport function wrapConstructor(hashCons) {\n    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();\n    const tmp = hashCons();\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = () => hashCons();\n    return hashC;\n}\nexport function wrapConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport function wrapXOFConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\n/**\n * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.\n */\nexport function randomBytes(bytesLength = 32) {\n    if (crypto && typeof crypto.getRandomValues === 'function') {\n        return crypto.getRandomValues(new Uint8Array(bytesLength));\n    }\n    // Legacy Node.js compatibility\n    if (crypto && typeof crypto.randomBytes === 'function') {\n        return crypto.randomBytes(bytesLength);\n    }\n    throw new Error('crypto.getRandomValues must be defined');\n}\n//# sourceMappingURL=utils.js.map"],"names":["Uint8Array","Uint32Array","buffer","hexes","Array","from","length","_","i","toString","padStart","bytesToHex","bytes","abytes","hex","asciis","asciiToBase16","char","hexToBytes","Error","hl","al","array","ai","hi","n1","charCodeAt","n2","undefined"],"mappings":";;AAwBoB,IAAIA,WAAW,IAAIC,YAAY,CAAC,YAAaC,QAAQ,GAezE,MAAMC,EAAwBC,MAAMC,KAAK,CAAEC,OAAQ,MAAO,CAACC,EAAGC,IAAMA,EAAEC,SAAS,IAAIC,SAAS,EAAG,OAIxF,SAASC,WAAWC,GACvBC,EAAOD,GAEP,IAAIE,EAAM,GACV,IAAK,IAAIN,EAAI,EAAGA,EAAII,EAAMN,OAAQE,IAC9BM,GAAOX,EAAMS,EAAMJ,IAEvB,OAAOM,CACX,CAEA,MAAMC,EAAe,GAAfA,EAAuB,GAAvBA,EAA+B,GAA/BA,EAAuC,GAAvCA,EAA+C,GAA/CA,EAAuD,IAC7D,SAASC,cAAcC,GACnB,OAAIA,GAAQF,GAAaE,GAAQF,EACtBE,EAAOF,EACdE,GAAQF,GAAaE,GAAQF,EACtBE,GAAQF,EAAY,IAC3BE,GAAQF,GAAaE,GAAQF,EACtBE,GAAQF,EAAY,SAD/B,CAGJ,CAIO,SAASG,WAAWJ,GACvB,GAAmB,iBAARA,EACP,MAAM,IAAIK,MAAM,mCAAqCL,GACzD,MAAMM,EAAKN,EAAIR,OACTe,EAAKD,EAAK,EAChB,GAAIA,EAAK,EACL,MAAM,IAAID,MAAM,0DAA4DC,GAChF,MAAME,EAAQ,IAAItB,WAAWqB,GAC7B,IAAK,IAAIE,EAAK,EAAGC,EAAK,EAAGD,EAAKF,EAAIE,IAAMC,GAAM,EAAG,CAC7C,MAAMC,EAAKT,cAAcF,EAAIY,WAAWF,IAClCG,EAAKX,cAAcF,EAAIY,WAAWF,EAAK,IAC7C,QAAWI,IAAPH,QAA2BG,IAAPD,EAAkB,CACtC,MAAMV,EAAOH,EAAIU,GAAMV,EAAIU,EAAK,GAChC,MAAM,IAAIL,MAAM,+CAAiDF,EAAO,cAAgBO,EACpG,CACQF,EAAMC,GAAW,GAALE,EAAUE,CAC9B,CACI,OAAOL,CACX","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@scure_base@1.1.1/node_modules/@scure/base/lib/esm/index.amd.js

@@ -0,0 +1,3 @@
+define(["exports"],(function(r){"use strict";
+/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */function assertNumber(r){if(!Number.isSafeInteger(r))throw new Error(`Wrong integer: ${r}`)}function chain(...r){const wrap=(r,e)=>o=>r(e(o));return{encode:Array.from(r).reverse().reduce(((r,e)=>r?wrap(r,e.encode):e.encode),void 0),decode:r.reduce(((r,e)=>r?wrap(r,e.decode):e.decode),void 0)}}function alphabet(r){return{encode:e=>{if(!Array.isArray(e)||e.length&&"number"!=typeof e[0])throw new Error("alphabet.encode input should be an array of numbers");return e.map((e=>{if(assertNumber(e),e<0||e>=r.length)throw new Error(`Digit index outside alphabet: ${e} (alphabet: ${r.length})`);return r[e]}))},decode:e=>{if(!Array.isArray(e)||e.length&&"string"!=typeof e[0])throw new Error("alphabet.decode input should be array of strings");return e.map((e=>{if("string"!=typeof e)throw new Error(`alphabet.decode: not string element=${e}`);const o=r.indexOf(e);if(-1===o)throw new Error(`Unknown letter: "${e}". Allowed: ${r}`);return o}))}}}function join(r=""){if("string"!=typeof r)throw new Error("join separator should be string");return{encode:e=>{if(!Array.isArray(e)||e.length&&"string"!=typeof e[0])throw new Error("join.encode input should be array of strings");for(let r of e)if("string"!=typeof r)throw new Error(`join.encode: non-string input=${r}`);return e.join(r)},decode:e=>{if("string"!=typeof e)throw new Error("join.decode input should be string");return e.split(r)}}}function padding(r,e="="){if(assertNumber(r),"string"!=typeof e)throw new Error("padding chr should be string");return{encode(o){if(!Array.isArray(o)||o.length&&"string"!=typeof o[0])throw new Error("padding.encode input should be array of strings");for(let r of o)if("string"!=typeof r)throw new Error(`padding.encode: non-string input=${r}`);for(;o.length*r%8;)o.push(e);return o},decode(o){if(!Array.isArray(o)||o.length&&"string"!=typeof o[0])throw new Error("padding.encode input should be array of strings");for(let r of o)if("string"!=typeof r)throw new Error(`padding.decode: non-string input=${r}`);let n=o.length;if(n*r%8)throw new Error("Invalid padding: string should have whole number of bytes");for(;n>0&&o[n-1]===e;n--)if(!((n-1)*r%8))throw new Error("Invalid padding: string has too much padding");return o.slice(0,n)}}}function normalize(r){if("function"!=typeof r)throw new Error("normalize fn should be function");return{encode:r=>r,decode:e=>r(e)}}function convertRadix(r,e,o){if(e<2)throw new Error(`convertRadix: wrong from=${e}, base cannot be less than 2`);if(o<2)throw new Error(`convertRadix: wrong to=${o}, base cannot be less than 2`);if(!Array.isArray(r))throw new Error("convertRadix: data should be array");if(!r.length)return[];let n=0;const t=[],i=Array.from(r);for(i.forEach((r=>{if(assertNumber(r),r<0||r>=e)throw new Error(`Wrong integer: ${r}`)}));;){let r=0,a=!0;for(let t=n;t<i.length;t++){const d=i[t],s=e*r+d;if(!Number.isSafeInteger(s)||e*r/e!==r||s-d!=e*r)throw new Error("convertRadix: carry overflow");if(r=s%o,i[t]=Math.floor(s/o),!Number.isSafeInteger(i[t])||i[t]*o+r!==s)throw new Error("convertRadix: carry overflow");a&&(i[t]?a=!1:n=t)}if(t.push(r),a)break}for(let e=0;e<r.length-1&&0===r[e];e++)t.push(0);return t.reverse()}const gcd=(r,e)=>e?gcd(e,r%e):r,radix2carry=(r,e)=>r+(e-gcd(r,e));function convertRadix2(r,e,o,n){if(!Array.isArray(r))throw new Error("convertRadix2: data should be array");if(e<=0||e>32)throw new Error(`convertRadix2: wrong from=${e}`);if(o<=0||o>32)throw new Error(`convertRadix2: wrong to=${o}`);if(radix2carry(e,o)>32)throw new Error(`convertRadix2: carry overflow from=${e} to=${o} carryBits=${radix2carry(e,o)}`);let t=0,i=0;const a=2**o-1,d=[];for(const n of r){if(assertNumber(n),n>=2**e)throw new Error(`convertRadix2: invalid data word=${n} from=${e}`);if(t=t<<e|n,i+e>32)throw new Error(`convertRadix2: carry overflow pos=${i} from=${e}`);for(i+=e;i>=o;i-=o)d.push((t>>i-o&a)>>>0);t&=2**i-1}if(t=t<<o-i&a,!n&&i>=e)throw new Error("Excess padding");if(!n&&t)throw new Error(`Non-zero padding: ${t}`);return n&&i>0&&d.push(t>>>0),d}function radix2(r,e=!1){if(assertNumber(r),r<=0||r>32)throw new Error("radix2: bits should be in (0..32]");if(radix2carry(8,r)>32||radix2carry(r,8)>32)throw new Error("radix2: carry overflow");return{encode:o=>{if(!(o instanceof Uint8Array))throw new Error("radix2.encode input should be Uint8Array");return convertRadix2(Array.from(o),8,r,!e)},decode:o=>{if(!Array.isArray(o)||o.length&&"number"!=typeof o[0])throw new Error("radix2.decode input should be array of strings");return Uint8Array.from(convertRadix2(o,r,8,e))}}}function unsafeWrapper(r){if("function"!=typeof r)throw new Error("unsafeWrapper fn should be function");return function(...e){try{return r.apply(null,e)}catch(r){}}}const e=chain(radix2(4),alphabet("0123456789ABCDEF"),join("")),o=chain(radix2(5),alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"),padding(5),join(""));chain(radix2(5),alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"),padding(5),join("")),chain(radix2(5),alphabet("0123456789ABCDEFGHJKMNPQRSTVWXYZ"),join(""),normalize((r=>r.toUpperCase().replace(/O/g,"0").replace(/[IL]/g,"1"))));const n=chain(radix2(6),alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"),padding(6),join("")),t=chain(radix2(6),alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"),padding(6),join("")),genBase58=r=>chain(function radix(r){return assertNumber(r),{encode:e=>{if(!(e instanceof Uint8Array))throw new Error("radix.encode input should be Uint8Array");return convertRadix(Array.from(e),256,r)},decode:e=>{if(!Array.isArray(e)||e.length&&"number"!=typeof e[0])throw new Error("radix.decode input should be array of strings");return Uint8Array.from(convertRadix(e,r,256))}}}(58),alphabet(r),join("")),i=genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");genBase58("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"),genBase58("rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz");const a=[0,2,3,5,6,7,9,10,11],d={encode(r){let e="";for(let o=0;o<r.length;o+=8){const n=r.subarray(o,o+8);e+=i.encode(n).padStart(a[n.length],"1")}return e},decode(r){let e=[];for(let o=0;o<r.length;o+=11){const n=r.slice(o,o+11),t=a.indexOf(n.length),d=i.decode(n);for(let r=0;r<d.length-t;r++)if(0!==d[r])throw new Error("base58xmr: wrong padding");e=e.concat(Array.from(d.slice(d.length-t)))}return Uint8Array.from(e)}},s=chain(alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"),join("")),c=[996825010,642813549,513874426,1027748829,705979059];function bech32Polymod(r){const e=r>>25;let o=(33554431&r)<<5;for(let r=0;r<c.length;r++)1==(e>>r&1)&&(o^=c[r]);return o}function bechChecksum(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=bech32Polymod(t)^o>>5}t=bech32Polymod(t);for(let e=0;e<n;e++)t=bech32Polymod(t)^31&r.charCodeAt(e);for(let r of e)t=bech32Polymod(t)^r;for(let r=0;r<6;r++)t=bech32Polymod(t);return t^=o,s.encode(convertRadix2([t%2**30],30,5,!1))}function genBech32(r){const e="bech32"===r?1:734539939,o=radix2(5),n=o.decode,t=o.encode,i=unsafeWrapper(n);function decode(r,o=90){if("string"!=typeof r)throw new Error("bech32.decode input should be string, not "+typeof r);if(r.length<8||!1!==o&&r.length>o)throw new TypeError(`Wrong string length: ${r.length} (${r}). Expected (8..${o})`);const n=r.toLowerCase();if(r!==n&&r!==r.toUpperCase())throw new Error("String must be lowercase or uppercase");const t=(r=n).lastIndexOf("1");if(0===t||-1===t)throw new Error('Letter "1" must be present between prefix and data only');const i=r.slice(0,t),a=r.slice(t+1);if(a.length<6)throw new Error("Data must be at least 6 characters long");const d=s.decode(a).slice(0,-6),c=bechChecksum(i,d,e);if(!a.endsWith(c))throw new Error(`Invalid checksum in ${r}: expected "${c}"`);return{prefix:i,words:d}}return{encode:function encode(r,o,n=90){if("string"!=typeof r)throw new Error("bech32.encode prefix should be string, not "+typeof r);if(!Array.isArray(o)||o.length&&"number"!=typeof o[0])throw new Error("bech32.encode words should be array of numbers, not "+typeof o);const t=r.length+7+o.length;if(!1!==n&&t>n)throw new TypeError(`Length ${t} exceeds limit ${n}`);return`${r=r.toLowerCase()}1${s.encode(o)}${bechChecksum(r,o,e)}`},decode:decode,decodeToBytes:function decodeToBytes(r){const{prefix:e,words:o}=decode(r,!1);return{prefix:e,words:o,bytes:n(o)}},decodeUnsafe:unsafeWrapper(decode),fromWords:n,fromWordsUnsafe:i,toWords:t}}const f=genBech32("bech32");genBech32("bech32m");const h={encode:r=>(new TextDecoder).decode(r),decode:r=>(new TextEncoder).encode(r)},u=chain(radix2(4),alphabet("0123456789abcdef"),join(""),normalize((r=>{if("string"!=typeof r||r.length%2)throw new TypeError(`hex.decode: expected string, got ${typeof r} with length ${r.length}`);return r.toLowerCase()}))),l={utf8:h,hex:u,base16:e,base32:o,base64:n,base64url:t,base58:i,base58xmr:d};Object.keys(l).join(", "),r.assertNumber=assertNumber,r.base16=e,r.base32=o,r.base58=i,r.base58xmr=d,r.base64=n,r.base64url=t,r.bech32=f,r.hex=u,r.utf8=h}));
+//# sourceMappingURL=index.amd.js.map