@nostrwatch/route66 0.0.1

package/dist/server/models/index.cjs.js

@@ -0,0 +1,2 @@
+"use strict";var e=require("./_.cjs.js"),r=require("./Event.cjs.js"),s=require("./Nip66CheckEvent.cjs.js"),t=require("./DeltaEvent.cjs.js"),o=require("./RelayCheckAggregate.cjs.js"),i=require("./Geocoded.cjs.js"),c=require("./Monitor.cjs.js"),j=require("./Nip11.cjs.js"),a=require("./PubkeyProfile.cjs.js"),u=require("./PubkeyRelays.cjs.js");exports.modelDefaults=e.modelDefaults,exports.NostrEvent=r.NostrEvent,exports.SOURCE=r.SOURCE,exports.Nip66CheckEvent=s.Nip66CheckEvent,exports.DeltaEvent=t.DeltaEvent,exports.RelayCheckAggregate=o.RelayCheckAggregate,exports.RelayCheckAggregator=o.RelayCheckAggregator,exports.Geocoded=i.Geocoded,exports.Monitor=c.Monitor,exports.Nip11=j.Nip11,exports.PubkeyProfile=a.PubkeyProfile,exports.PubkeyRelays=u.PubkeyRelays;
+//# sourceMappingURL=index.cjs.js.map

package/dist/server/models/index.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/server/models/index.esm.js

@@ -0,0 +1,2 @@
+export{modelDefaults}from"./_.esm.js";export{NostrEvent,SOURCE}from"./Event.esm.js";export{Nip66CheckEvent}from"./Nip66CheckEvent.esm.js";export{DeltaEvent}from"./DeltaEvent.esm.js";export{RelayCheckAggregate,RelayCheckAggregator}from"./RelayCheckAggregate.esm.js";export{Geocoded}from"./Geocoded.esm.js";export{Monitor}from"./Monitor.esm.js";export{Nip11}from"./Nip11.esm.js";export{PubkeyProfile}from"./PubkeyProfile.esm.js";export{PubkeyRelays}from"./PubkeyRelays.esm.js";
+//# sourceMappingURL=index.esm.js.map

package/dist/server/models/index.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/_arx.cjs.js

@@ -0,0 +1,2 @@
+"use strict";var e=require("./_assert.cjs.js"),r=require("./utils.cjs.js");const _utf8ToBytes=e=>Uint8Array.from(e.split("").map((e=>e.charCodeAt(0)))),t=_utf8ToBytes("expand 16-byte k"),n=_utf8ToBytes("expand 32-byte k"),o=r.u32(t),s=r.u32(n);function isAligned32(e){return e.byteOffset%4==0}s.slice();const i=2**32-1,u=new Uint32Array;exports.createCipher=function createCipher(t,n){const{allowShortKeys:c,extendNonceFn:l,counterLength:h,counterRight:a,rounds:f}=r.checkOpts({allowShortKeys:!1,counterLength:8,counterRight:!1,rounds:20},n);if("function"!=typeof t)throw new Error("core must be a function");return e.number(h),e.number(f),e.bool(a),e.bool(c),(n,w,y,b,g=0)=>{e.bytes(n),e.bytes(w),e.bytes(y);const p=y.length;if(b||(b=new Uint8Array(p)),e.bytes(b),e.number(g),g<0||g>=i)throw new Error("arx: counter overflow");if(b.length<p)throw new Error(`arx: output (${b.length}) is shorter than data (${p})`);const d=[];let x,A,m=n.length;if(32===m)x=n.slice(),d.push(x),A=s;else{if(16!==m||!c)throw new Error(`arx: invalid 32-byte key, got length=${m}`);x=new Uint8Array(32),x.set(n),x.set(n,16),A=o,d.push(x)}isAligned32(w)||(w=w.slice(),d.push(w));const E=r.u32(x);if(l){if(24!==w.length)throw new Error("arx: extended nonce must be 24 bytes");l(A,E,r.u32(w.subarray(0,16)),E),w=w.subarray(16)}const U=16-h;if(U!==w.length)throw new Error(`arx: nonce must be ${U} or 16 bytes`);if(12!==U){const e=new Uint8Array(12);e.set(w,a?0:12-w.length),w=e,d.push(w)}const k=r.u32(w);for(!function runCipher(e,t,n,o,s,c,l,h){const a=s.length,f=new Uint8Array(64),w=r.u32(f),y=isAligned32(s)&&isAligned32(c),b=y?r.u32(s):u,g=y?r.u32(c):u;for(let r=0;r<a;l++){if(e(t,n,o,w,l,h),l>=i)throw new Error("arx: counter overflow");const u=Math.min(64,a-r);if(y&&64===u){const e=r/4;if(r%4!=0)throw new Error("arx: invalid block position");for(let r,t=0;t<16;t++)r=e+t,g[r]=b[r]^w[t];r+=64}else{for(let e,t=0;t<u;t++)e=r+t,c[e]=s[e]^f[t];r+=u}}}(t,A,E,k,y,b,g,f);d.length>0;)d.pop().fill(0);return b}},exports.rotl=function rotl(e,r){return e<<r|e>>>32-r};
+//# sourceMappingURL=_arx.cjs.js.map

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/_arx.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_arx.cjs.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+ciphers@0.5.3/node_modules/@noble/ciphers/esm/_arx.js"],"sourcesContent":["// Basic utils for ARX (add-rotate-xor) salsa and chacha ciphers.\nimport { number as anumber, bytes as abytes, bool as abool } from './_assert.js';\nimport { checkOpts, u32 } from './utils.js';\n/*\nRFC8439 requires multi-step cipher stream, where\nauthKey starts with counter: 0, actual msg with counter: 1.\n\nFor this, we need a way to re-use nonce / counter:\n\n    const counter = new Uint8Array(4);\n    chacha(..., counter, ...); // counter is now 1\n    chacha(..., counter, ...); // counter is now 2\n\nThis is complicated:\n\n- 32-bit counters are enough, no need for 64-bit: max ArrayBuffer size in JS is 4GB\n- Original papers don't allow mutating counters\n- Counter overflow is undefined [^1]\n- Idea A: allow providing (nonce | counter) instead of just nonce, re-use it\n- Caveat: Cannot be re-used through all cases:\n- * chacha has (counter | nonce)\n- * xchacha has (nonce16 | counter | nonce16)\n- Idea B: separate nonce / counter and provide separate API for counter re-use\n- Caveat: there are different counter sizes depending on an algorithm.\n- salsa & chacha also differ in structures of key & sigma:\n  salsa20:      s[0] | k(4) | s[1] | nonce(2) | ctr(2) | s[2] | k(4) | s[3]\n  chacha:       s(4) | k(8) | ctr(1) | nonce(3)\n  chacha20orig: s(4) | k(8) | ctr(2) | nonce(2)\n- Idea C: helper method such as `setSalsaState(key, nonce, sigma, data)`\n- Caveat: we can't re-use counter array\n\nxchacha [^2] uses the subkey and remaining 8 byte nonce with ChaCha20 as normal\n(prefixed by 4 NUL bytes, since [RFC8439] specifies a 12-byte nonce).\n\n[^1]: https://mailarchive.ietf.org/arch/msg/cfrg/gsOnTJzcbgG6OqD8Sc0GO5aR_tU/\n[^2]: https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha#appendix-A.2\n*/\n// We can't make top-level var depend on utils.utf8ToBytes\n// because it's not present in all envs. Creating a similar fn here\nconst _utf8ToBytes = (str) => Uint8Array.from(str.split('').map((c) => c.charCodeAt(0)));\nconst sigma16 = _utf8ToBytes('expand 16-byte k');\nconst sigma32 = _utf8ToBytes('expand 32-byte k');\nconst sigma16_32 = u32(sigma16);\nconst sigma32_32 = u32(sigma32);\nexport const sigma = sigma32_32.slice();\nexport function rotl(a, b) {\n    return (a << b) | (a >>> (32 - b));\n}\n// Is byte array aligned to 4 byte offset (u32)?\nfunction isAligned32(b) {\n    return b.byteOffset % 4 === 0;\n}\n// Salsa and Chacha block length is always 512-bit\nconst BLOCK_LEN = 64;\nconst BLOCK_LEN32 = 16;\n// new Uint32Array([2**32])   // => Uint32Array(1) [ 0 ]\n// new Uint32Array([2**32-1]) // => Uint32Array(1) [ 4294967295 ]\nconst MAX_COUNTER = 2 ** 32 - 1;\nconst U32_EMPTY = new Uint32Array();\nfunction runCipher(core, sigma, key, nonce, data, output, counter, rounds) {\n    const len = data.length;\n    const block = new Uint8Array(BLOCK_LEN);\n    const b32 = u32(block);\n    // Make sure that buffers aligned to 4 bytes\n    const isAligned = isAligned32(data) && isAligned32(output);\n    const d32 = isAligned ? u32(data) : U32_EMPTY;\n    const o32 = isAligned ? u32(output) : U32_EMPTY;\n    for (let pos = 0; pos < len; counter++) {\n        core(sigma, key, nonce, b32, counter, rounds);\n        if (counter >= MAX_COUNTER)\n            throw new Error('arx: counter overflow');\n        const take = Math.min(BLOCK_LEN, len - pos);\n        // aligned to 4 bytes\n        if (isAligned && take === BLOCK_LEN) {\n            const pos32 = pos / 4;\n            if (pos % 4 !== 0)\n                throw new Error('arx: invalid block position');\n            for (let j = 0, posj; j < BLOCK_LEN32; j++) {\n                posj = pos32 + j;\n                o32[posj] = d32[posj] ^ b32[j];\n            }\n            pos += BLOCK_LEN;\n            continue;\n        }\n        for (let j = 0, posj; j < take; j++) {\n            posj = pos + j;\n            output[posj] = data[posj] ^ block[j];\n        }\n        pos += take;\n    }\n}\nexport function createCipher(core, opts) {\n    const { allowShortKeys, extendNonceFn, counterLength, counterRight, rounds } = checkOpts({ allowShortKeys: false, counterLength: 8, counterRight: false, rounds: 20 }, opts);\n    if (typeof core !== 'function')\n        throw new Error('core must be a function');\n    anumber(counterLength);\n    anumber(rounds);\n    abool(counterRight);\n    abool(allowShortKeys);\n    return (key, nonce, data, output, counter = 0) => {\n        abytes(key);\n        abytes(nonce);\n        abytes(data);\n        const len = data.length;\n        if (!output)\n            output = new Uint8Array(len);\n        abytes(output);\n        anumber(counter);\n        if (counter < 0 || counter >= MAX_COUNTER)\n            throw new Error('arx: counter overflow');\n        if (output.length < len)\n            throw new Error(`arx: output (${output.length}) is shorter than data (${len})`);\n        const toClean = [];\n        // Key & sigma\n        // key=16 -> sigma16, k=key|key\n        // key=32 -> sigma32, k=key\n        let l = key.length, k, sigma;\n        if (l === 32) {\n            k = key.slice();\n            toClean.push(k);\n            sigma = sigma32_32;\n        }\n        else if (l === 16 && allowShortKeys) {\n            k = new Uint8Array(32);\n            k.set(key);\n            k.set(key, 16);\n            sigma = sigma16_32;\n            toClean.push(k);\n        }\n        else {\n            throw new Error(`arx: invalid 32-byte key, got length=${l}`);\n        }\n        // Nonce\n        // salsa20:      8   (8-byte counter)\n        // chacha20orig: 8   (8-byte counter)\n        // chacha20:     12  (4-byte counter)\n        // xsalsa20:     24  (16 -> hsalsa,  8 -> old nonce)\n        // xchacha20:    24  (16 -> hchacha, 8 -> old nonce)\n        // Align nonce to 4 bytes\n        if (!isAligned32(nonce)) {\n            nonce = nonce.slice();\n            toClean.push(nonce);\n        }\n        const k32 = u32(k);\n        // hsalsa & hchacha: handle extended nonce\n        if (extendNonceFn) {\n            if (nonce.length !== 24)\n                throw new Error(`arx: extended nonce must be 24 bytes`);\n            extendNonceFn(sigma, k32, u32(nonce.subarray(0, 16)), k32);\n            nonce = nonce.subarray(16);\n        }\n        // Handle nonce counter\n        const nonceNcLen = 16 - counterLength;\n        if (nonceNcLen !== nonce.length)\n            throw new Error(`arx: nonce must be ${nonceNcLen} or 16 bytes`);\n        // Pad counter when nonce is 64 bit\n        if (nonceNcLen !== 12) {\n            const nc = new Uint8Array(12);\n            nc.set(nonce, counterRight ? 0 : 12 - nonce.length);\n            nonce = nc;\n            toClean.push(nonce);\n        }\n        const n32 = u32(nonce);\n        runCipher(core, sigma, k32, n32, data, output, counter, rounds);\n        while (toClean.length > 0)\n            toClean.pop().fill(0);\n        return output;\n    };\n}\n//# sourceMappingURL=_arx.js.map"],"names":["_utf8ToBytes","str","Uint8Array","from","split","map","c","charCodeAt","sigma16","sigma32","sigma16_32","u32","sigma32_32","isAligned32","b","byteOffset","slice","MAX_COUNTER","U32_EMPTY","Uint32Array","createCipher","core","opts","allowShortKeys","extendNonceFn","counterLength","counterRight","rounds","checkOpts","Error","anumber","abool","key","nonce","data","output","counter","abytes","len","length","toClean","k","sigma","l","push","set","k32","subarray","nonceNcLen","nc","n32","runCipher","block","b32","isAligned","d32","o32","pos","take","Math","min","pos32","posj","j","pop","fill","rotl","a"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/_arx.esm.js

@@ -0,0 +1,2 @@
+import{number as r,bool as t,bytes as e}from"./_assert.esm.js";import{checkOpts as n,u32 as o}from"./utils.esm.js";const _utf8ToBytes=r=>Uint8Array.from(r.split("").map((r=>r.charCodeAt(0)))),i=_utf8ToBytes("expand 16-byte k"),s=_utf8ToBytes("expand 32-byte k"),l=o(i),c=o(s);function rotl(r,t){return r<<t|r>>>32-t}function isAligned32(r){return r.byteOffset%4==0}c.slice();const h=2**32-1,a=new Uint32Array;function createCipher(i,s){const{allowShortKeys:f,extendNonceFn:u,counterLength:w,counterRight:g,rounds:p}=n({allowShortKeys:!1,counterLength:8,counterRight:!1,rounds:20},s);if("function"!=typeof i)throw new Error("core must be a function");return r(w),r(p),t(g),t(f),(t,n,s,y,d=0)=>{e(t),e(n),e(s);const b=s.length;if(y||(y=new Uint8Array(b)),e(y),r(d),d<0||d>=h)throw new Error("arx: counter overflow");if(y.length<b)throw new Error(`arx: output (${y.length}) is shorter than data (${b})`);const m=[];let x,A,E=t.length;if(32===E)x=t.slice(),m.push(x),A=c;else{if(16!==E||!f)throw new Error(`arx: invalid 32-byte key, got length=${E}`);x=new Uint8Array(32),x.set(t),x.set(t,16),A=l,m.push(x)}isAligned32(n)||(n=n.slice(),m.push(n));const U=o(x);if(u){if(24!==n.length)throw new Error("arx: extended nonce must be 24 bytes");u(A,U,o(n.subarray(0,16)),U),n=n.subarray(16)}const k=16-w;if(k!==n.length)throw new Error(`arx: nonce must be ${k} or 16 bytes`);if(12!==k){const r=new Uint8Array(12);r.set(n,g?0:12-n.length),n=r,m.push(n)}const v=o(n);for(!function runCipher(r,t,e,n,i,s,l,c){const f=i.length,u=new Uint8Array(64),w=o(u),g=isAligned32(i)&&isAligned32(s),p=g?o(i):a,y=g?o(s):a;for(let o=0;o<f;l++){if(r(t,e,n,w,l,c),l>=h)throw new Error("arx: counter overflow");const a=Math.min(64,f-o);if(g&&64===a){const r=o/4;if(o%4!=0)throw new Error("arx: invalid block position");for(let t,e=0;e<16;e++)t=r+e,y[t]=p[t]^w[e];o+=64}else{for(let r,t=0;t<a;t++)r=o+t,s[r]=i[r]^u[t];o+=a}}}(i,A,U,v,s,y,d,p);m.length>0;)m.pop().fill(0);return y}}export{createCipher,rotl};
+//# sourceMappingURL=_arx.esm.js.map

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/_arx.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_arx.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+ciphers@0.5.3/node_modules/@noble/ciphers/esm/_arx.js"],"sourcesContent":["// Basic utils for ARX (add-rotate-xor) salsa and chacha ciphers.\nimport { number as anumber, bytes as abytes, bool as abool } from './_assert.js';\nimport { checkOpts, u32 } from './utils.js';\n/*\nRFC8439 requires multi-step cipher stream, where\nauthKey starts with counter: 0, actual msg with counter: 1.\n\nFor this, we need a way to re-use nonce / counter:\n\n    const counter = new Uint8Array(4);\n    chacha(..., counter, ...); // counter is now 1\n    chacha(..., counter, ...); // counter is now 2\n\nThis is complicated:\n\n- 32-bit counters are enough, no need for 64-bit: max ArrayBuffer size in JS is 4GB\n- Original papers don't allow mutating counters\n- Counter overflow is undefined [^1]\n- Idea A: allow providing (nonce | counter) instead of just nonce, re-use it\n- Caveat: Cannot be re-used through all cases:\n- * chacha has (counter | nonce)\n- * xchacha has (nonce16 | counter | nonce16)\n- Idea B: separate nonce / counter and provide separate API for counter re-use\n- Caveat: there are different counter sizes depending on an algorithm.\n- salsa & chacha also differ in structures of key & sigma:\n  salsa20:      s[0] | k(4) | s[1] | nonce(2) | ctr(2) | s[2] | k(4) | s[3]\n  chacha:       s(4) | k(8) | ctr(1) | nonce(3)\n  chacha20orig: s(4) | k(8) | ctr(2) | nonce(2)\n- Idea C: helper method such as `setSalsaState(key, nonce, sigma, data)`\n- Caveat: we can't re-use counter array\n\nxchacha [^2] uses the subkey and remaining 8 byte nonce with ChaCha20 as normal\n(prefixed by 4 NUL bytes, since [RFC8439] specifies a 12-byte nonce).\n\n[^1]: https://mailarchive.ietf.org/arch/msg/cfrg/gsOnTJzcbgG6OqD8Sc0GO5aR_tU/\n[^2]: https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha#appendix-A.2\n*/\n// We can't make top-level var depend on utils.utf8ToBytes\n// because it's not present in all envs. Creating a similar fn here\nconst _utf8ToBytes = (str) => Uint8Array.from(str.split('').map((c) => c.charCodeAt(0)));\nconst sigma16 = _utf8ToBytes('expand 16-byte k');\nconst sigma32 = _utf8ToBytes('expand 32-byte k');\nconst sigma16_32 = u32(sigma16);\nconst sigma32_32 = u32(sigma32);\nexport const sigma = sigma32_32.slice();\nexport function rotl(a, b) {\n    return (a << b) | (a >>> (32 - b));\n}\n// Is byte array aligned to 4 byte offset (u32)?\nfunction isAligned32(b) {\n    return b.byteOffset % 4 === 0;\n}\n// Salsa and Chacha block length is always 512-bit\nconst BLOCK_LEN = 64;\nconst BLOCK_LEN32 = 16;\n// new Uint32Array([2**32])   // => Uint32Array(1) [ 0 ]\n// new Uint32Array([2**32-1]) // => Uint32Array(1) [ 4294967295 ]\nconst MAX_COUNTER = 2 ** 32 - 1;\nconst U32_EMPTY = new Uint32Array();\nfunction runCipher(core, sigma, key, nonce, data, output, counter, rounds) {\n    const len = data.length;\n    const block = new Uint8Array(BLOCK_LEN);\n    const b32 = u32(block);\n    // Make sure that buffers aligned to 4 bytes\n    const isAligned = isAligned32(data) && isAligned32(output);\n    const d32 = isAligned ? u32(data) : U32_EMPTY;\n    const o32 = isAligned ? u32(output) : U32_EMPTY;\n    for (let pos = 0; pos < len; counter++) {\n        core(sigma, key, nonce, b32, counter, rounds);\n        if (counter >= MAX_COUNTER)\n            throw new Error('arx: counter overflow');\n        const take = Math.min(BLOCK_LEN, len - pos);\n        // aligned to 4 bytes\n        if (isAligned && take === BLOCK_LEN) {\n            const pos32 = pos / 4;\n            if (pos % 4 !== 0)\n                throw new Error('arx: invalid block position');\n            for (let j = 0, posj; j < BLOCK_LEN32; j++) {\n                posj = pos32 + j;\n                o32[posj] = d32[posj] ^ b32[j];\n            }\n            pos += BLOCK_LEN;\n            continue;\n        }\n        for (let j = 0, posj; j < take; j++) {\n            posj = pos + j;\n            output[posj] = data[posj] ^ block[j];\n        }\n        pos += take;\n    }\n}\nexport function createCipher(core, opts) {\n    const { allowShortKeys, extendNonceFn, counterLength, counterRight, rounds } = checkOpts({ allowShortKeys: false, counterLength: 8, counterRight: false, rounds: 20 }, opts);\n    if (typeof core !== 'function')\n        throw new Error('core must be a function');\n    anumber(counterLength);\n    anumber(rounds);\n    abool(counterRight);\n    abool(allowShortKeys);\n    return (key, nonce, data, output, counter = 0) => {\n        abytes(key);\n        abytes(nonce);\n        abytes(data);\n        const len = data.length;\n        if (!output)\n            output = new Uint8Array(len);\n        abytes(output);\n        anumber(counter);\n        if (counter < 0 || counter >= MAX_COUNTER)\n            throw new Error('arx: counter overflow');\n        if (output.length < len)\n            throw new Error(`arx: output (${output.length}) is shorter than data (${len})`);\n        const toClean = [];\n        // Key & sigma\n        // key=16 -> sigma16, k=key|key\n        // key=32 -> sigma32, k=key\n        let l = key.length, k, sigma;\n        if (l === 32) {\n            k = key.slice();\n            toClean.push(k);\n            sigma = sigma32_32;\n        }\n        else if (l === 16 && allowShortKeys) {\n            k = new Uint8Array(32);\n            k.set(key);\n            k.set(key, 16);\n            sigma = sigma16_32;\n            toClean.push(k);\n        }\n        else {\n            throw new Error(`arx: invalid 32-byte key, got length=${l}`);\n        }\n        // Nonce\n        // salsa20:      8   (8-byte counter)\n        // chacha20orig: 8   (8-byte counter)\n        // chacha20:     12  (4-byte counter)\n        // xsalsa20:     24  (16 -> hsalsa,  8 -> old nonce)\n        // xchacha20:    24  (16 -> hchacha, 8 -> old nonce)\n        // Align nonce to 4 bytes\n        if (!isAligned32(nonce)) {\n            nonce = nonce.slice();\n            toClean.push(nonce);\n        }\n        const k32 = u32(k);\n        // hsalsa & hchacha: handle extended nonce\n        if (extendNonceFn) {\n            if (nonce.length !== 24)\n                throw new Error(`arx: extended nonce must be 24 bytes`);\n            extendNonceFn(sigma, k32, u32(nonce.subarray(0, 16)), k32);\n            nonce = nonce.subarray(16);\n        }\n        // Handle nonce counter\n        const nonceNcLen = 16 - counterLength;\n        if (nonceNcLen !== nonce.length)\n            throw new Error(`arx: nonce must be ${nonceNcLen} or 16 bytes`);\n        // Pad counter when nonce is 64 bit\n        if (nonceNcLen !== 12) {\n            const nc = new Uint8Array(12);\n            nc.set(nonce, counterRight ? 0 : 12 - nonce.length);\n            nonce = nc;\n            toClean.push(nonce);\n        }\n        const n32 = u32(nonce);\n        runCipher(core, sigma, k32, n32, data, output, counter, rounds);\n        while (toClean.length > 0)\n            toClean.pop().fill(0);\n        return output;\n    };\n}\n//# sourceMappingURL=_arx.js.map"],"names":["_utf8ToBytes","str","Uint8Array","from","split","map","c","charCodeAt","sigma16","sigma32","sigma16_32","u32","sigma32_32","rotl","a","b","isAligned32","byteOffset","slice","MAX_COUNTER","U32_EMPTY","Uint32Array","createCipher","core","opts","allowShortKeys","extendNonceFn","counterLength","counterRight","rounds","checkOpts","Error","anumber","abool","key","nonce","data","output","counter","abytes","len","length","toClean","k","sigma","l","push","set","k32","subarray","nonceNcLen","nc","n32","runCipher","block","b32","isAligned","d32","o32","pos","take","Math","min","pos32","posj","j","pop","fill"],"mappings":"mHAuCA,MAAMA,aAAgBC,GAAQC,WAAWC,KAAKF,EAAIG,MAAM,IAAIC,KAAKC,GAAMA,EAAEC,WAAW,MAC9EC,EAAUR,aAAa,oBACvBS,EAAUT,aAAa,oBACvBU,EAAaC,EAAIH,GACjBI,EAAaD,EAAIF,GAEhB,SAASI,KAAKC,EAAGC,GACpB,OAAQD,GAAKC,EAAMD,IAAO,GAAKC,CACnC,CAEA,SAASC,YAAYD,GACjB,OAAOA,EAAEE,WAAa,GAAM,CAChC,CAPqBL,EAAWM,QAShC,MAIMC,EAAc,GAAK,GAAK,EACxBC,EAAY,IAAIC,YAiCf,SAASC,aAAaC,EAAMC,GAC/B,MAAMC,eAAEA,EAAcC,cAAEA,EAAaC,cAAEA,EAAaC,aAAEA,EAAYC,OAAEA,GAAWC,EAAU,CAAEL,gBAAgB,EAAOE,cAAe,EAAGC,cAAc,EAAOC,OAAQ,IAAML,GACvK,GAAoB,mBAATD,EACP,MAAM,IAAIQ,MAAM,2BAKpB,OAJAC,EAAQL,GACRK,EAAQH,GACRI,EAAML,GACNK,EAAMR,GACC,CAACS,EAAKC,EAAOC,EAAMC,EAAQC,EAAU,KACxCC,EAAOL,GACPK,EAAOJ,GACPI,EAAOH,GACP,MAAMI,EAAMJ,EAAKK,OAKjB,GAJKJ,IACDA,EAAS,IAAInC,WAAWsC,IAC5BD,EAAOF,GACPL,EAAQM,GACJA,EAAU,GAAKA,GAAWnB,EAC1B,MAAM,IAAIY,MAAM,yBACpB,GAAIM,EAAOI,OAASD,EAChB,MAAM,IAAIT,MAAM,gBAAgBM,EAAOI,iCAAiCD,MAC5E,MAAME,EAAU,GAIhB,IAAoBC,EAAGC,EAAnBC,EAAIX,EAAIO,OACZ,GAAU,KAANI,EACAF,EAAIT,EAAIhB,QACRwB,EAAQI,KAAKH,GACbC,EAAQhC,MAEP,IAAU,KAANiC,IAAYpB,EAQjB,MAAM,IAAIM,MAAM,wCAAwCc,KAPxDF,EAAI,IAAIzC,WAAW,IACnByC,EAAEI,IAAIb,GACNS,EAAEI,IAAIb,EAAK,IACXU,EAAQlC,EACRgC,EAAQI,KAAKH,EAIjB,CAQK3B,YAAYmB,KACbA,EAAQA,EAAMjB,QACdwB,EAAQI,KAAKX,IAEjB,MAAMa,EAAMrC,EAAIgC,GAEhB,GAAIjB,EAAe,CACf,GAAqB,KAAjBS,EAAMM,OACN,MAAM,IAAIV,MAAM,wCACpBL,EAAckB,EAAOI,EAAKrC,EAAIwB,EAAMc,SAAS,EAAG,KAAMD,GACtDb,EAAQA,EAAMc,SAAS,GAC3B,CAEA,MAAMC,EAAa,GAAKvB,EACxB,GAAIuB,IAAef,EAAMM,OACrB,MAAM,IAAIV,MAAM,sBAAsBmB,iBAE1C,GAAmB,KAAfA,EAAmB,CACnB,MAAMC,EAAK,IAAIjD,WAAW,IAC1BiD,EAAGJ,IAAIZ,EAAOP,EAAe,EAAI,GAAKO,EAAMM,QAC5CN,EAAQgB,EACRT,EAAQI,KAAKX,EACjB,CACA,MAAMiB,EAAMzC,EAAIwB,GAEhB,KAzGR,SAASkB,UAAU9B,EAAMqB,EAAOV,EAAKC,EAAOC,EAAMC,EAAQC,EAAST,GAC/D,MAAMW,EAAMJ,EAAKK,OACXa,EAAQ,IAAIpD,WARJ,IASRqD,EAAM5C,EAAI2C,GAEVE,EAAYxC,YAAYoB,IAASpB,YAAYqB,GAC7CoB,EAAMD,EAAY7C,EAAIyB,GAAQhB,EAC9BsC,EAAMF,EAAY7C,EAAI0B,GAAUjB,EACtC,IAAK,IAAIuC,EAAM,EAAGA,EAAMnB,EAAKF,IAAW,CAEpC,GADAf,EAAKqB,EAAOV,EAAKC,EAAOoB,EAAKjB,EAAST,GAClCS,GAAWnB,EACX,MAAM,IAAIY,MAAM,yBACpB,MAAM6B,EAAOC,KAAKC,IAlBR,GAkBuBtB,EAAMmB,GAEvC,GAAIH,GApBM,KAoBOI,EAAjB,CACI,MAAMG,EAAQJ,EAAM,EACpB,GAAIA,EAAM,GAAM,EACZ,MAAM,IAAI5B,MAAM,+BACpB,IAAK,IAAWiC,EAAPC,EAAI,EAASA,EAvBd,GAuB+BA,IACnCD,EAAOD,EAAQE,EACfP,EAAIM,GAAQP,EAAIO,GAAQT,EAAIU,GAEhCN,GA5BM,EA8BV,KAVA,CAWA,IAAK,IAAWK,EAAPC,EAAI,EAASA,EAAIL,EAAMK,IAC5BD,EAAOL,EAAMM,EACb5B,EAAO2B,GAAQ5B,EAAK4B,GAAQV,EAAMW,GAEtCN,GAAOC,CALP,CAMJ,CACJ,CAyEQP,CAAU9B,EAAMqB,EAAOI,EAAKI,EAAKhB,EAAMC,EAAQC,EAAST,GACjDa,EAAQD,OAAS,GACpBC,EAAQwB,MAAMC,KAAK,GACvB,OAAO9B,CAAM,CAErB","x_google_ignoreList":[0]}

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/_assert.cjs.js

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

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/_assert.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_assert.cjs.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+ciphers@0.5.3/node_modules/@noble/ciphers/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}\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(hash) {\n    if (typeof hash !== 'function' || typeof hash.create !== 'function')\n        throw new Error('hash must 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":["isBytes","a","Uint8Array","constructor","name","bool","b","Error","bytes","lengths","length","includes","number","n","Number","isSafeInteger"],"mappings":"aAQO,SAASA,QAAQC,GACpB,OAAQA,aAAaC,YACX,MAALD,GAA0B,iBAANA,GAAyC,eAAvBA,EAAEE,YAAYC,IAC7D,cAPA,SAASC,KAAKC,GACV,GAAiB,kBAANA,EACP,MAAM,IAAIC,MAAM,yBAAyBD,IACjD,gBAKA,SAASE,MAAMF,KAAMG,GACjB,IAAKT,QAAQM,GACT,MAAM,IAAIC,MAAM,uBACpB,GAAIE,EAAQC,OAAS,IAAMD,EAAQE,SAASL,EAAEI,QAC1C,MAAM,IAAIH,MAAM,iCAAiCE,oBAA0BH,EAAEI,SACrF,yCAjBA,SAASE,OAAOC,GACZ,IAAKC,OAAOC,cAAcF,IAAMA,EAAI,EAChC,MAAM,IAAIN,MAAM,kCAAkCM,IAC1D","x_google_ignoreList":[0]}

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/_assert.esm.js

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

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/_assert.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_assert.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+ciphers@0.5.3/node_modules/@noble/ciphers/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}\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(hash) {\n    if (typeof hash !== 'function' || typeof hash.create !== 'function')\n        throw new Error('hash must 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","bool","b","isBytes","a","Uint8Array","constructor","name","bytes","lengths","length","includes"],"mappings":"AAAA,SAASA,OAAOC,GACZ,IAAKC,OAAOC,cAAcF,IAAMA,EAAI,EAChC,MAAM,IAAIG,MAAM,kCAAkCH,IAC1D,CACA,SAASI,KAAKC,GACV,GAAiB,kBAANA,EACP,MAAM,IAAIF,MAAM,yBAAyBE,IACjD,CACO,SAASC,QAAQC,GACpB,OAAQA,aAAaC,YACX,MAALD,GAA0B,iBAANA,GAAyC,eAAvBA,EAAEE,YAAYC,IAC7D,CACA,SAASC,MAAMN,KAAMO,GACjB,IAAKN,QAAQD,GACT,MAAM,IAAIF,MAAM,uBACpB,GAAIS,EAAQC,OAAS,IAAMD,EAAQE,SAAST,EAAEQ,QAC1C,MAAM,IAAIV,MAAM,iCAAiCS,oBAA0BP,EAAEQ,SACrF","x_google_ignoreList":[0]}

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/aes.cjs.js

@@ -0,0 +1,2 @@
+"use strict";var t=require("./utils.cjs.js"),e=require("./_assert.cjs.js");const n=16;function mul2(t){return t<<1^283&-(t>>7)}function mul(t,e){let n=0;for(;e>0;e>>=1)n^=t&-(1&e),t=mul2(t);return n}const r=(()=>{let t=new Uint8Array(256);for(let e=0,n=1;e<256;e++,n^=mul2(n))t[e]=n;const e=new Uint8Array(256);e[0]=99;for(let n=0;n<255;n++){let r=t[255-n];r|=r<<8,e[t[n]]=255&(r^r>>4^r>>5^r>>6^r>>7^99)}return e})(),o=r.map(((t,e)=>r.indexOf(e))),rotl32_8=t=>t<<8|t>>>24;function genTtable(t,e){if(256!==t.length)throw new Error("Wrong sbox length");const n=new Uint32Array(256).map(((n,r)=>e(t[r]))),r=n.map(rotl32_8),o=r.map(rotl32_8),s=o.map(rotl32_8),l=new Uint32Array(65536),c=new Uint32Array(65536),p=new Uint16Array(65536);for(let e=0;e<256;e++)for(let a=0;a<256;a++){const i=256*e+a;l[i]=n[e]^r[a],c[i]=o[e]^s[a],p[i]=t[e]<<8|t[a]}return{sbox:t,sbox2:p,T0:n,T1:r,T2:o,T3:s,T01:l,T23:c}}const s=genTtable(r,(t=>mul(t,3)<<24|t<<16|t<<8|mul(t,2))),l=genTtable(o,(t=>mul(t,11)<<24|mul(t,13)<<16|mul(t,9)<<8|mul(t,14))),c=(()=>{const t=new Uint8Array(16);for(let e=0,n=1;e<16;e++,n=mul2(n))t[e]=n;return t})();function expandKeyLE(n){e.bytes(n);const r=n.length;if(![16,24,32].includes(r))throw new Error(`aes: wrong key size: should be 16, 24 or 32, got: ${r}`);const{sbox2:o}=s,l=t.u32(n),p=l.length,subByte=t=>applySbox(o,t,t,t,t),a=new Uint32Array(r+28);a.set(l);for(let t=p;t<a.length;t++){let e=a[t-1];t%p==0?e=subByte((i=e)<<24|i>>>8)^c[t/p-1]:p>6&&t%p==4&&(e=subByte(e)),a[t]=a[t-p]^e}var i;return a}function expandKeyDecLE(t){const e=expandKeyLE(t),n=e.slice(),r=e.length,{sbox2:o}=s,{T0:c,T1:p,T2:a,T3:i}=l;for(let t=0;t<r;t+=4)for(let o=0;o<4;o++)n[t+o]=e[r-t-4+o];e.fill(0);for(let t=4;t<r-4;t++){const e=n[t],r=applySbox(o,e,e,e,e);n[t]=c[255&r]^p[r>>>8&255]^a[r>>>16&255]^i[r>>>24]}return n}function apply0123(t,e,n,r,o,s){return t[n<<8&65280|r>>>8&255]^e[o>>>8&65280|s>>>24&255]}function applySbox(t,e,n,r,o){return t[255&e|65280&n]|t[r>>>16&255|o>>>16&65280]<<16}function encrypt(t,e,n,r,o){const{sbox2:l,T01:c,T23:p}=s;let a=0;e^=t[a++],n^=t[a++],r^=t[a++],o^=t[a++];const i=t.length/4-2;for(let s=0;s<i;s++){const s=t[a++]^apply0123(c,p,e,n,r,o),l=t[a++]^apply0123(c,p,n,r,o,e),i=t[a++]^apply0123(c,p,r,o,e,n),u=t[a++]^apply0123(c,p,o,e,n,r);e=s,n=l,r=i,o=u}return{s0:t[a++]^applySbox(l,e,n,r,o),s1:t[a++]^applySbox(l,n,r,o,e),s2:t[a++]^applySbox(l,r,o,e,n),s3:t[a++]^applySbox(l,o,e,n,r)}}function decrypt(t,e,n,r,o){const{sbox2:s,T01:c,T23:p}=l;let a=0;e^=t[a++],n^=t[a++],r^=t[a++],o^=t[a++];const i=t.length/4-2;for(let s=0;s<i;s++){const s=t[a++]^apply0123(c,p,e,o,r,n),l=t[a++]^apply0123(c,p,n,e,o,r),i=t[a++]^apply0123(c,p,r,n,e,o),u=t[a++]^apply0123(c,p,o,r,n,e);e=s,n=l,r=i,o=u}return{s0:t[a++]^applySbox(s,e,o,r,n),s1:t[a++]^applySbox(s,n,e,o,r),s2:t[a++]^applySbox(s,r,n,e,o),s3:t[a++]^applySbox(s,o,r,n,e)}}function getDst(t,n){if(!n)return new Uint8Array(t);if(e.bytes(n),n.length<t)throw new Error(`aes: wrong destination length, expected at least ${t}, got: ${n.length}`);return n}const p=t.wrapCipher({blockSize:16,nonceLength:16},(function cbc(r,o,s={}){e.bytes(r),e.bytes(o,16);const l=!s.disablePadding;return{encrypt:(e,s)=>{const c=expandKeyLE(r),{b:p,o:a,out:i}=function validateBlockEncrypt(e,r,o){let s=e.length;const l=s%n;if(!r&&0!==l)throw new Error("aec/(cbc-ecb): unpadded plaintext with disabled padding");const c=t.u32(e);if(r){let t=n-l;t||(t=n),s+=t}const p=getDst(s,o);return{b:c,o:t.u32(p),out:p}}(e,l,s),u=t.u32(o);let y=u[0],f=u[1],b=u[2],d=u[3],g=0;for(;g+4<=p.length;)y^=p[g+0],f^=p[g+1],b^=p[g+2],d^=p[g+3],({s0:y,s1:f,s2:b,s3:d}=encrypt(c,y,f,b,d)),a[g++]=y,a[g++]=f,a[g++]=b,a[g++]=d;if(l){const r=function padPCKS(e){const r=new Uint8Array(16),o=t.u32(r);r.set(e);const s=n-e.length;for(let t=n-s;t<n;t++)r[t]=s;return o}(e.subarray(4*g));y^=r[0],f^=r[1],b^=r[2],d^=r[3],({s0:y,s1:f,s2:b,s3:d}=encrypt(c,y,f,b,d)),a[g++]=y,a[g++]=f,a[g++]=b,a[g++]=d}return c.fill(0),i},decrypt:(s,c)=>{!function validateBlockDecrypt(t){if(e.bytes(t),t.length%n!=0)throw new Error("aes/(cbc-ecb).decrypt ciphertext should consist of blocks with size 16")}(s);const p=expandKeyDecLE(r),a=t.u32(o),i=getDst(s.length,c),u=t.u32(s),y=t.u32(i);let f=a[0],b=a[1],d=a[2],g=a[3];for(let t=0;t+4<=u.length;){const e=f,n=b,r=d,o=g;f=u[t+0],b=u[t+1],d=u[t+2],g=u[t+3];const{s0:s,s1:l,s2:c,s3:a}=decrypt(p,f,b,d,g);y[t++]=s^e,y[t++]=l^n,y[t++]=c^r,y[t++]=a^o}return p.fill(0),function validatePCKS(t,e){if(!e)return t;const n=t.length;if(!n)throw new Error("aes/pcks5: empty ciphertext not allowed");const r=t[n-1];if(r<=0||r>16)throw new Error(`aes/pcks5: wrong padding byte: ${r}`);const o=t.subarray(0,-r);for(let e=0;e<r;e++)if(t[n-e-1]!==r)throw new Error("aes/pcks5: wrong padding");return o}(i,l)}}}));exports.cbc=p,exports.expandKeyDecLE=expandKeyDecLE,exports.expandKeyLE=expandKeyLE;
+//# sourceMappingURL=aes.cjs.js.map

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/aes.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aes.cjs.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+ciphers@0.5.3/node_modules/@noble/ciphers/esm/aes.js"],"sourcesContent":["// prettier-ignore\nimport { wrapCipher, createView, setBigUint64, equalBytes, u32, u8, } from './utils.js';\nimport { ghash, polyval } from './_polyval.js';\nimport { bytes as abytes } from './_assert.js';\n/*\nAES (Advanced Encryption Standard) aka Rijndael block cipher.\n\nData is split into 128-bit blocks. Encrypted in 10/12/14 rounds (128/192/256 bits). In every round:\n1. **S-box**, table substitution\n2. **Shift rows**, cyclic shift left of all rows of data array\n3. **Mix columns**, multiplying every column by fixed polynomial\n4. **Add round key**, round_key xor i-th column of array\n\nResources:\n- FIPS-197 https://csrc.nist.gov/files/pubs/fips/197/final/docs/fips-197.pdf\n- Original proposal: https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/aes-development/rijndael-ammended.pdf\n*/\nconst BLOCK_SIZE = 16;\nconst BLOCK_SIZE32 = 4;\nconst EMPTY_BLOCK = new Uint8Array(BLOCK_SIZE);\nconst POLY = 0x11b; // 1 + x + x**3 + x**4 + x**8\n// TODO: remove multiplication, binary ops only\nfunction mul2(n) {\n    return (n << 1) ^ (POLY & -(n >> 7));\n}\nfunction mul(a, b) {\n    let res = 0;\n    for (; b > 0; b >>= 1) {\n        // Montgomery ladder\n        res ^= a & -(b & 1); // if (b&1) res ^=a (but const-time).\n        a = mul2(a); // a = 2*a\n    }\n    return res;\n}\n// AES S-box is generated using finite field inversion,\n// an affine transform, and xor of a constant 0x63.\nconst sbox = /* @__PURE__ */ (() => {\n    let t = new Uint8Array(256);\n    for (let i = 0, x = 1; i < 256; i++, x ^= mul2(x))\n        t[i] = x;\n    const box = new Uint8Array(256);\n    box[0] = 0x63; // first elm\n    for (let i = 0; i < 255; i++) {\n        let x = t[255 - i];\n        x |= x << 8;\n        box[t[i]] = (x ^ (x >> 4) ^ (x >> 5) ^ (x >> 6) ^ (x >> 7) ^ 0x63) & 0xff;\n    }\n    return box;\n})();\n// Inverted S-box\nconst invSbox = /* @__PURE__ */ sbox.map((_, j) => sbox.indexOf(j));\n// Rotate u32 by 8\nconst rotr32_8 = (n) => (n << 24) | (n >>> 8);\nconst rotl32_8 = (n) => (n << 8) | (n >>> 24);\n// T-table is optimization suggested in 5.2 of original proposal (missed from FIPS-197). Changes:\n// - LE instead of BE\n// - bigger tables: T0 and T1 are merged into T01 table and T2 & T3 into T23;\n//   so index is u16, instead of u8. This speeds up things, unexpectedly\nfunction genTtable(sbox, fn) {\n    if (sbox.length !== 256)\n        throw new Error('Wrong sbox length');\n    const T0 = new Uint32Array(256).map((_, j) => fn(sbox[j]));\n    const T1 = T0.map(rotl32_8);\n    const T2 = T1.map(rotl32_8);\n    const T3 = T2.map(rotl32_8);\n    const T01 = new Uint32Array(256 * 256);\n    const T23 = new Uint32Array(256 * 256);\n    const sbox2 = new Uint16Array(256 * 256);\n    for (let i = 0; i < 256; i++) {\n        for (let j = 0; j < 256; j++) {\n            const idx = i * 256 + j;\n            T01[idx] = T0[i] ^ T1[j];\n            T23[idx] = T2[i] ^ T3[j];\n            sbox2[idx] = (sbox[i] << 8) | sbox[j];\n        }\n    }\n    return { sbox, sbox2, T0, T1, T2, T3, T01, T23 };\n}\nconst tableEncoding = /* @__PURE__ */ genTtable(sbox, (s) => (mul(s, 3) << 24) | (s << 16) | (s << 8) | mul(s, 2));\nconst tableDecoding = /* @__PURE__ */ genTtable(invSbox, (s) => (mul(s, 11) << 24) | (mul(s, 13) << 16) | (mul(s, 9) << 8) | mul(s, 14));\nconst xPowers = /* @__PURE__ */ (() => {\n    const p = new Uint8Array(16);\n    for (let i = 0, x = 1; i < 16; i++, x = mul2(x))\n        p[i] = x;\n    return p;\n})();\nexport function expandKeyLE(key) {\n    abytes(key);\n    const len = key.length;\n    if (![16, 24, 32].includes(len))\n        throw new Error(`aes: wrong key size: should be 16, 24 or 32, got: ${len}`);\n    const { sbox2 } = tableEncoding;\n    const k32 = u32(key);\n    const Nk = k32.length;\n    const subByte = (n) => applySbox(sbox2, n, n, n, n);\n    const xk = new Uint32Array(len + 28); // expanded key\n    xk.set(k32);\n    // 4.3.1 Key expansion\n    for (let i = Nk; i < xk.length; i++) {\n        let t = xk[i - 1];\n        if (i % Nk === 0)\n            t = subByte(rotr32_8(t)) ^ xPowers[i / Nk - 1];\n        else if (Nk > 6 && i % Nk === 4)\n            t = subByte(t);\n        xk[i] = xk[i - Nk] ^ t;\n    }\n    return xk;\n}\nexport function expandKeyDecLE(key) {\n    const encKey = expandKeyLE(key);\n    const xk = encKey.slice();\n    const Nk = encKey.length;\n    const { sbox2 } = tableEncoding;\n    const { T0, T1, T2, T3 } = tableDecoding;\n    // Inverse key by chunks of 4 (rounds)\n    for (let i = 0; i < Nk; i += 4) {\n        for (let j = 0; j < 4; j++)\n            xk[i + j] = encKey[Nk - i - 4 + j];\n    }\n    encKey.fill(0);\n    // apply InvMixColumn except first & last round\n    for (let i = 4; i < Nk - 4; i++) {\n        const x = xk[i];\n        const w = applySbox(sbox2, x, x, x, x);\n        xk[i] = T0[w & 0xff] ^ T1[(w >>> 8) & 0xff] ^ T2[(w >>> 16) & 0xff] ^ T3[w >>> 24];\n    }\n    return xk;\n}\n// Apply tables\nfunction apply0123(T01, T23, s0, s1, s2, s3) {\n    return (T01[((s0 << 8) & 0xff00) | ((s1 >>> 8) & 0xff)] ^\n        T23[((s2 >>> 8) & 0xff00) | ((s3 >>> 24) & 0xff)]);\n}\nfunction applySbox(sbox2, s0, s1, s2, s3) {\n    return (sbox2[(s0 & 0xff) | (s1 & 0xff00)] |\n        (sbox2[((s2 >>> 16) & 0xff) | ((s3 >>> 16) & 0xff00)] << 16));\n}\nfunction encrypt(xk, s0, s1, s2, s3) {\n    const { sbox2, T01, T23 } = tableEncoding;\n    let k = 0;\n    (s0 ^= xk[k++]), (s1 ^= xk[k++]), (s2 ^= xk[k++]), (s3 ^= xk[k++]);\n    const rounds = xk.length / 4 - 2;\n    for (let i = 0; i < rounds; i++) {\n        const t0 = xk[k++] ^ apply0123(T01, T23, s0, s1, s2, s3);\n        const t1 = xk[k++] ^ apply0123(T01, T23, s1, s2, s3, s0);\n        const t2 = xk[k++] ^ apply0123(T01, T23, s2, s3, s0, s1);\n        const t3 = xk[k++] ^ apply0123(T01, T23, s3, s0, s1, s2);\n        (s0 = t0), (s1 = t1), (s2 = t2), (s3 = t3);\n    }\n    // last round (without mixcolumns, so using SBOX2 table)\n    const t0 = xk[k++] ^ applySbox(sbox2, s0, s1, s2, s3);\n    const t1 = xk[k++] ^ applySbox(sbox2, s1, s2, s3, s0);\n    const t2 = xk[k++] ^ applySbox(sbox2, s2, s3, s0, s1);\n    const t3 = xk[k++] ^ applySbox(sbox2, s3, s0, s1, s2);\n    return { s0: t0, s1: t1, s2: t2, s3: t3 };\n}\nfunction decrypt(xk, s0, s1, s2, s3) {\n    const { sbox2, T01, T23 } = tableDecoding;\n    let k = 0;\n    (s0 ^= xk[k++]), (s1 ^= xk[k++]), (s2 ^= xk[k++]), (s3 ^= xk[k++]);\n    const rounds = xk.length / 4 - 2;\n    for (let i = 0; i < rounds; i++) {\n        const t0 = xk[k++] ^ apply0123(T01, T23, s0, s3, s2, s1);\n        const t1 = xk[k++] ^ apply0123(T01, T23, s1, s0, s3, s2);\n        const t2 = xk[k++] ^ apply0123(T01, T23, s2, s1, s0, s3);\n        const t3 = xk[k++] ^ apply0123(T01, T23, s3, s2, s1, s0);\n        (s0 = t0), (s1 = t1), (s2 = t2), (s3 = t3);\n    }\n    // Last round\n    const t0 = xk[k++] ^ applySbox(sbox2, s0, s3, s2, s1);\n    const t1 = xk[k++] ^ applySbox(sbox2, s1, s0, s3, s2);\n    const t2 = xk[k++] ^ applySbox(sbox2, s2, s1, s0, s3);\n    const t3 = xk[k++] ^ applySbox(sbox2, s3, s2, s1, s0);\n    return { s0: t0, s1: t1, s2: t2, s3: t3 };\n}\nfunction getDst(len, dst) {\n    if (!dst)\n        return new Uint8Array(len);\n    abytes(dst);\n    if (dst.length < len)\n        throw new Error(`aes: wrong destination length, expected at least ${len}, got: ${dst.length}`);\n    return dst;\n}\n// TODO: investigate merging with ctr32\nfunction ctrCounter(xk, nonce, src, dst) {\n    abytes(nonce, BLOCK_SIZE);\n    abytes(src);\n    const srcLen = src.length;\n    dst = getDst(srcLen, dst);\n    const ctr = nonce;\n    const c32 = u32(ctr);\n    // Fill block (empty, ctr=0)\n    let { s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]);\n    const src32 = u32(src);\n    const dst32 = u32(dst);\n    // process blocks\n    for (let i = 0; i + 4 <= src32.length; i += 4) {\n        dst32[i + 0] = src32[i + 0] ^ s0;\n        dst32[i + 1] = src32[i + 1] ^ s1;\n        dst32[i + 2] = src32[i + 2] ^ s2;\n        dst32[i + 3] = src32[i + 3] ^ s3;\n        // Full 128 bit counter with wrap around\n        let carry = 1;\n        for (let i = ctr.length - 1; i >= 0; i--) {\n            carry = (carry + (ctr[i] & 0xff)) | 0;\n            ctr[i] = carry & 0xff;\n            carry >>>= 8;\n        }\n        ({ s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]));\n    }\n    // leftovers (less than block)\n    // It's possible to handle > u32 fast, but is it worth it?\n    const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);\n    if (start < srcLen) {\n        const b32 = new Uint32Array([s0, s1, s2, s3]);\n        const buf = u8(b32);\n        for (let i = start, pos = 0; i < srcLen; i++, pos++)\n            dst[i] = src[i] ^ buf[pos];\n    }\n    return dst;\n}\n// AES CTR with overflowing 32 bit counter\n// It's possible to do 32le significantly simpler (and probably faster) by using u32.\n// But, we need both, and perf bottleneck is in ghash anyway.\nfunction ctr32(xk, isLE, nonce, src, dst) {\n    abytes(nonce, BLOCK_SIZE);\n    abytes(src);\n    dst = getDst(src.length, dst);\n    const ctr = nonce; // write new value to nonce, so it can be re-used\n    const c32 = u32(ctr);\n    const view = createView(ctr);\n    const src32 = u32(src);\n    const dst32 = u32(dst);\n    const ctrPos = isLE ? 0 : 12;\n    const srcLen = src.length;\n    // Fill block (empty, ctr=0)\n    let ctrNum = view.getUint32(ctrPos, isLE); // read current counter value\n    let { s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]);\n    // process blocks\n    for (let i = 0; i + 4 <= src32.length; i += 4) {\n        dst32[i + 0] = src32[i + 0] ^ s0;\n        dst32[i + 1] = src32[i + 1] ^ s1;\n        dst32[i + 2] = src32[i + 2] ^ s2;\n        dst32[i + 3] = src32[i + 3] ^ s3;\n        ctrNum = (ctrNum + 1) >>> 0; // u32 wrap\n        view.setUint32(ctrPos, ctrNum, isLE);\n        ({ s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]));\n    }\n    // leftovers (less than a block)\n    const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);\n    if (start < srcLen) {\n        const b32 = new Uint32Array([s0, s1, s2, s3]);\n        const buf = u8(b32);\n        for (let i = start, pos = 0; i < srcLen; i++, pos++)\n            dst[i] = src[i] ^ buf[pos];\n    }\n    return dst;\n}\n/**\n * CTR: counter mode. Creates stream cipher.\n * Requires good IV. Parallelizable. OK, but no MAC.\n */\nexport const ctr = wrapCipher({ blockSize: 16, nonceLength: 16 }, function ctr(key, nonce) {\n    abytes(key);\n    abytes(nonce, BLOCK_SIZE);\n    function processCtr(buf, dst) {\n        const xk = expandKeyLE(key);\n        const n = nonce.slice();\n        const out = ctrCounter(xk, n, buf, dst);\n        xk.fill(0);\n        n.fill(0);\n        return out;\n    }\n    return {\n        encrypt: (plaintext, dst) => processCtr(plaintext, dst),\n        decrypt: (ciphertext, dst) => processCtr(ciphertext, dst),\n    };\n});\nfunction validateBlockDecrypt(data) {\n    abytes(data);\n    if (data.length % BLOCK_SIZE !== 0) {\n        throw new Error(`aes/(cbc-ecb).decrypt ciphertext should consist of blocks with size ${BLOCK_SIZE}`);\n    }\n}\nfunction validateBlockEncrypt(plaintext, pcks5, dst) {\n    let outLen = plaintext.length;\n    const remaining = outLen % BLOCK_SIZE;\n    if (!pcks5 && remaining !== 0)\n        throw new Error('aec/(cbc-ecb): unpadded plaintext with disabled padding');\n    const b = u32(plaintext);\n    if (pcks5) {\n        let left = BLOCK_SIZE - remaining;\n        if (!left)\n            left = BLOCK_SIZE; // if no bytes left, create empty padding block\n        outLen = outLen + left;\n    }\n    const out = getDst(outLen, dst);\n    const o = u32(out);\n    return { b, o, out };\n}\nfunction validatePCKS(data, pcks5) {\n    if (!pcks5)\n        return data;\n    const len = data.length;\n    if (!len)\n        throw new Error(`aes/pcks5: empty ciphertext not allowed`);\n    const lastByte = data[len - 1];\n    if (lastByte <= 0 || lastByte > 16)\n        throw new Error(`aes/pcks5: wrong padding byte: ${lastByte}`);\n    const out = data.subarray(0, -lastByte);\n    for (let i = 0; i < lastByte; i++)\n        if (data[len - i - 1] !== lastByte)\n            throw new Error(`aes/pcks5: wrong padding`);\n    return out;\n}\nfunction padPCKS(left) {\n    const tmp = new Uint8Array(16);\n    const tmp32 = u32(tmp);\n    tmp.set(left);\n    const paddingByte = BLOCK_SIZE - left.length;\n    for (let i = BLOCK_SIZE - paddingByte; i < BLOCK_SIZE; i++)\n        tmp[i] = paddingByte;\n    return tmp32;\n}\n/**\n * ECB: Electronic CodeBook. Simple deterministic replacement.\n * Dangerous: always map x to y. See [AES Penguin](https://words.filippo.io/the-ecb-penguin/).\n */\nexport const ecb = wrapCipher({ blockSize: 16 }, function ecb(key, opts = {}) {\n    abytes(key);\n    const pcks5 = !opts.disablePadding;\n    return {\n        encrypt: (plaintext, dst) => {\n            abytes(plaintext);\n            const { b, o, out: _out } = validateBlockEncrypt(plaintext, pcks5, dst);\n            const xk = expandKeyLE(key);\n            let i = 0;\n            for (; i + 4 <= b.length;) {\n                const { s0, s1, s2, s3 } = encrypt(xk, b[i + 0], b[i + 1], b[i + 2], b[i + 3]);\n                (o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3);\n            }\n            if (pcks5) {\n                const tmp32 = padPCKS(plaintext.subarray(i * 4));\n                const { s0, s1, s2, s3 } = encrypt(xk, tmp32[0], tmp32[1], tmp32[2], tmp32[3]);\n                (o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3);\n            }\n            xk.fill(0);\n            return _out;\n        },\n        decrypt: (ciphertext, dst) => {\n            validateBlockDecrypt(ciphertext);\n            const xk = expandKeyDecLE(key);\n            const out = getDst(ciphertext.length, dst);\n            const b = u32(ciphertext);\n            const o = u32(out);\n            for (let i = 0; i + 4 <= b.length;) {\n                const { s0, s1, s2, s3 } = decrypt(xk, b[i + 0], b[i + 1], b[i + 2], b[i + 3]);\n                (o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3);\n            }\n            xk.fill(0);\n            return validatePCKS(out, pcks5);\n        },\n    };\n});\n/**\n * CBC: Cipher-Block-Chaining. Key is previous round’s block.\n * Fragile: needs proper padding. Unauthenticated: needs MAC.\n */\nexport const cbc = wrapCipher({ blockSize: 16, nonceLength: 16 }, function cbc(key, iv, opts = {}) {\n    abytes(key);\n    abytes(iv, 16);\n    const pcks5 = !opts.disablePadding;\n    return {\n        encrypt: (plaintext, dst) => {\n            const xk = expandKeyLE(key);\n            const { b, o, out: _out } = validateBlockEncrypt(plaintext, pcks5, dst);\n            const n32 = u32(iv);\n            // prettier-ignore\n            let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];\n            let i = 0;\n            for (; i + 4 <= b.length;) {\n                (s0 ^= b[i + 0]), (s1 ^= b[i + 1]), (s2 ^= b[i + 2]), (s3 ^= b[i + 3]);\n                ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));\n                (o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3);\n            }\n            if (pcks5) {\n                const tmp32 = padPCKS(plaintext.subarray(i * 4));\n                (s0 ^= tmp32[0]), (s1 ^= tmp32[1]), (s2 ^= tmp32[2]), (s3 ^= tmp32[3]);\n                ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));\n                (o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3);\n            }\n            xk.fill(0);\n            return _out;\n        },\n        decrypt: (ciphertext, dst) => {\n            validateBlockDecrypt(ciphertext);\n            const xk = expandKeyDecLE(key);\n            const n32 = u32(iv);\n            const out = getDst(ciphertext.length, dst);\n            const b = u32(ciphertext);\n            const o = u32(out);\n            // prettier-ignore\n            let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];\n            for (let i = 0; i + 4 <= b.length;) {\n                // prettier-ignore\n                const ps0 = s0, ps1 = s1, ps2 = s2, ps3 = s3;\n                (s0 = b[i + 0]), (s1 = b[i + 1]), (s2 = b[i + 2]), (s3 = b[i + 3]);\n                const { s0: o0, s1: o1, s2: o2, s3: o3 } = decrypt(xk, s0, s1, s2, s3);\n                (o[i++] = o0 ^ ps0), (o[i++] = o1 ^ ps1), (o[i++] = o2 ^ ps2), (o[i++] = o3 ^ ps3);\n            }\n            xk.fill(0);\n            return validatePCKS(out, pcks5);\n        },\n    };\n});\n/**\n * CFB: Cipher Feedback Mode. The input for the block cipher is the previous cipher output.\n * Unauthenticated: needs MAC.\n */\nexport const cfb = wrapCipher({ blockSize: 16, nonceLength: 16 }, function cfb(key, iv) {\n    abytes(key);\n    abytes(iv, 16);\n    function processCfb(src, isEncrypt, dst) {\n        const xk = expandKeyLE(key);\n        const srcLen = src.length;\n        dst = getDst(srcLen, dst);\n        const src32 = u32(src);\n        const dst32 = u32(dst);\n        const next32 = isEncrypt ? dst32 : src32;\n        const n32 = u32(iv);\n        // prettier-ignore\n        let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];\n        for (let i = 0; i + 4 <= src32.length;) {\n            const { s0: e0, s1: e1, s2: e2, s3: e3 } = encrypt(xk, s0, s1, s2, s3);\n            dst32[i + 0] = src32[i + 0] ^ e0;\n            dst32[i + 1] = src32[i + 1] ^ e1;\n            dst32[i + 2] = src32[i + 2] ^ e2;\n            dst32[i + 3] = src32[i + 3] ^ e3;\n            (s0 = next32[i++]), (s1 = next32[i++]), (s2 = next32[i++]), (s3 = next32[i++]);\n        }\n        // leftovers (less than block)\n        const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);\n        if (start < srcLen) {\n            ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));\n            const buf = u8(new Uint32Array([s0, s1, s2, s3]));\n            for (let i = start, pos = 0; i < srcLen; i++, pos++)\n                dst[i] = src[i] ^ buf[pos];\n            buf.fill(0);\n        }\n        xk.fill(0);\n        return dst;\n    }\n    return {\n        encrypt: (plaintext, dst) => processCfb(plaintext, true, dst),\n        decrypt: (ciphertext, dst) => processCfb(ciphertext, false, dst),\n    };\n});\n// TODO: merge with chacha, however gcm has bitLen while chacha has byteLen\nfunction computeTag(fn, isLE, key, data, AAD) {\n    const h = fn.create(key, data.length + (AAD?.length || 0));\n    if (AAD)\n        h.update(AAD);\n    h.update(data);\n    const num = new Uint8Array(16);\n    const view = createView(num);\n    if (AAD)\n        setBigUint64(view, 0, BigInt(AAD.length * 8), isLE);\n    setBigUint64(view, 8, BigInt(data.length * 8), isLE);\n    h.update(num);\n    return h.digest();\n}\n/**\n * GCM: Galois/Counter Mode.\n * Good, modern version of CTR, parallel, with MAC.\n * Be careful: MACs can be forged.\n */\nexport const gcm = wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16 }, function gcm(key, nonce, AAD) {\n    abytes(nonce);\n    // Nonce can be pretty much anything (even 1 byte). But smaller nonces less secure.\n    if (nonce.length === 0)\n        throw new Error('aes/gcm: empty nonce');\n    const tagLength = 16;\n    function _computeTag(authKey, tagMask, data) {\n        const tag = computeTag(ghash, false, authKey, data, AAD);\n        for (let i = 0; i < tagMask.length; i++)\n            tag[i] ^= tagMask[i];\n        return tag;\n    }\n    function deriveKeys() {\n        const xk = expandKeyLE(key);\n        const authKey = EMPTY_BLOCK.slice();\n        const counter = EMPTY_BLOCK.slice();\n        ctr32(xk, false, counter, counter, authKey);\n        if (nonce.length === 12) {\n            counter.set(nonce);\n        }\n        else {\n            // Spec (NIST 800-38d) supports variable size nonce.\n            // Not supported for now, but can be useful.\n            const nonceLen = EMPTY_BLOCK.slice();\n            const view = createView(nonceLen);\n            setBigUint64(view, 8, BigInt(nonce.length * 8), false);\n            // ghash(nonce || u64be(0) || u64be(nonceLen*8))\n            ghash.create(authKey).update(nonce).update(nonceLen).digestInto(counter);\n        }\n        const tagMask = ctr32(xk, false, counter, EMPTY_BLOCK);\n        return { xk, authKey, counter, tagMask };\n    }\n    return {\n        encrypt: (plaintext) => {\n            abytes(plaintext);\n            const { xk, authKey, counter, tagMask } = deriveKeys();\n            const out = new Uint8Array(plaintext.length + tagLength);\n            ctr32(xk, false, counter, plaintext, out);\n            const tag = _computeTag(authKey, tagMask, out.subarray(0, out.length - tagLength));\n            out.set(tag, plaintext.length);\n            xk.fill(0);\n            return out;\n        },\n        decrypt: (ciphertext) => {\n            abytes(ciphertext);\n            if (ciphertext.length < tagLength)\n                throw new Error(`aes/gcm: ciphertext less than tagLen (${tagLength})`);\n            const { xk, authKey, counter, tagMask } = deriveKeys();\n            const data = ciphertext.subarray(0, -tagLength);\n            const passedTag = ciphertext.subarray(-tagLength);\n            const tag = _computeTag(authKey, tagMask, data);\n            if (!equalBytes(tag, passedTag))\n                throw new Error('aes/gcm: invalid ghash tag');\n            const out = ctr32(xk, false, counter, data);\n            authKey.fill(0);\n            tagMask.fill(0);\n            xk.fill(0);\n            return out;\n        },\n    };\n});\nconst limit = (name, min, max) => (value) => {\n    if (!Number.isSafeInteger(value) || min > value || value > max)\n        throw new Error(`${name}: invalid value=${value}, must be [${min}..${max}]`);\n};\n/**\n * AES-GCM-SIV: classic AES-GCM with nonce-misuse resistance.\n * Guarantees that, when a nonce is repeated, the only security loss is that identical\n * plaintexts will produce identical ciphertexts.\n * RFC 8452, https://datatracker.ietf.org/doc/html/rfc8452\n */\nexport const siv = wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16 }, function siv(key, nonce, AAD) {\n    const tagLength = 16;\n    // From RFC 8452: Section 6\n    const AAD_LIMIT = limit('AAD', 0, 2 ** 36);\n    const PLAIN_LIMIT = limit('plaintext', 0, 2 ** 36);\n    const NONCE_LIMIT = limit('nonce', 12, 12);\n    const CIPHER_LIMIT = limit('ciphertext', 16, 2 ** 36 + 16);\n    abytes(nonce);\n    NONCE_LIMIT(nonce.length);\n    if (AAD) {\n        abytes(AAD);\n        AAD_LIMIT(AAD.length);\n    }\n    function deriveKeys() {\n        const len = key.length;\n        if (len !== 16 && len !== 24 && len !== 32)\n            throw new Error(`key length must be 16, 24 or 32 bytes, got: ${len} bytes`);\n        const xk = expandKeyLE(key);\n        const encKey = new Uint8Array(len);\n        const authKey = new Uint8Array(16);\n        const n32 = u32(nonce);\n        // prettier-ignore\n        let s0 = 0, s1 = n32[0], s2 = n32[1], s3 = n32[2];\n        let counter = 0;\n        for (const derivedKey of [authKey, encKey].map(u32)) {\n            const d32 = u32(derivedKey);\n            for (let i = 0; i < d32.length; i += 2) {\n                // aes(u32le(0) || nonce)[:8] || aes(u32le(1) || nonce)[:8] ...\n                const { s0: o0, s1: o1 } = encrypt(xk, s0, s1, s2, s3);\n                d32[i + 0] = o0;\n                d32[i + 1] = o1;\n                s0 = ++counter; // increment counter inside state\n            }\n        }\n        xk.fill(0);\n        return { authKey, encKey: expandKeyLE(encKey) };\n    }\n    function _computeTag(encKey, authKey, data) {\n        const tag = computeTag(polyval, true, authKey, data, AAD);\n        // Compute the expected tag by XORing S_s and the nonce, clearing the\n        // most significant bit of the last byte and encrypting with the\n        // message-encryption key.\n        for (let i = 0; i < 12; i++)\n            tag[i] ^= nonce[i];\n        tag[15] &= 0x7f; // Clear the highest bit\n        // encrypt tag as block\n        const t32 = u32(tag);\n        // prettier-ignore\n        let s0 = t32[0], s1 = t32[1], s2 = t32[2], s3 = t32[3];\n        ({ s0, s1, s2, s3 } = encrypt(encKey, s0, s1, s2, s3));\n        (t32[0] = s0), (t32[1] = s1), (t32[2] = s2), (t32[3] = s3);\n        return tag;\n    }\n    // actual decrypt/encrypt of message.\n    function processSiv(encKey, tag, input) {\n        let block = tag.slice();\n        block[15] |= 0x80; // Force highest bit\n        return ctr32(encKey, true, block, input);\n    }\n    return {\n        encrypt: (plaintext) => {\n            abytes(plaintext);\n            PLAIN_LIMIT(plaintext.length);\n            const { encKey, authKey } = deriveKeys();\n            const tag = _computeTag(encKey, authKey, plaintext);\n            const out = new Uint8Array(plaintext.length + tagLength);\n            out.set(tag, plaintext.length);\n            out.set(processSiv(encKey, tag, plaintext));\n            encKey.fill(0);\n            authKey.fill(0);\n            return out;\n        },\n        decrypt: (ciphertext) => {\n            abytes(ciphertext);\n            CIPHER_LIMIT(ciphertext.length);\n            const tag = ciphertext.subarray(-tagLength);\n            const { encKey, authKey } = deriveKeys();\n            const plaintext = processSiv(encKey, tag, ciphertext.subarray(0, -tagLength));\n            const expectedTag = _computeTag(encKey, authKey, plaintext);\n            encKey.fill(0);\n            authKey.fill(0);\n            if (!equalBytes(tag, expectedTag))\n                throw new Error('invalid polyval tag');\n            return plaintext;\n        },\n    };\n});\nfunction isBytes32(a) {\n    return (a != null &&\n        typeof a === 'object' &&\n        (a instanceof Uint32Array || a.constructor.name === 'Uint32Array'));\n}\nfunction encryptBlock(xk, block) {\n    abytes(block, 16);\n    if (!isBytes32(xk))\n        throw new Error('_encryptBlock accepts result of expandKeyLE');\n    const b32 = u32(block);\n    let { s0, s1, s2, s3 } = encrypt(xk, b32[0], b32[1], b32[2], b32[3]);\n    (b32[0] = s0), (b32[1] = s1), (b32[2] = s2), (b32[3] = s3);\n    return block;\n}\nfunction decryptBlock(xk, block) {\n    abytes(block, 16);\n    if (!isBytes32(xk))\n        throw new Error('_decryptBlock accepts result of expandKeyLE');\n    const b32 = u32(block);\n    let { s0, s1, s2, s3 } = decrypt(xk, b32[0], b32[1], b32[2], b32[3]);\n    (b32[0] = s0), (b32[1] = s1), (b32[2] = s2), (b32[3] = s3);\n    return block;\n}\n// Highly unsafe private functions for implementing new modes or ciphers based on AES\n// Can change at any time, no API guarantees\nexport const unsafe = {\n    expandKeyLE,\n    expandKeyDecLE,\n    encrypt,\n    decrypt,\n    encryptBlock,\n    decryptBlock,\n    ctrCounter,\n    ctr32,\n};\n//# sourceMappingURL=aes.js.map"],"names":["BLOCK_SIZE","mul2","n","mul","a","b","res","sbox","t","Uint8Array","i","x","box","invSbox","map","_","j","indexOf","rotl32_8","genTtable","fn","length","Error","T0","Uint32Array","T1","T2","T3","T01","T23","sbox2","Uint16Array","idx","tableEncoding","s","tableDecoding","xPowers","p","expandKeyLE","key","abytes","len","includes","k32","u32","Nk","subByte","applySbox","xk","set","expandKeyDecLE","encKey","slice","fill","w","apply0123","s0","s1","s2","s3","encrypt","k","rounds","t0","t1","t2","t3","decrypt","getDst","dst","cbc","wrapCipher","blockSize","nonceLength","iv","opts","pcks5","disablePadding","plaintext","o","out","_out","validateBlockEncrypt","outLen","remaining","left","n32","tmp32","padPCKS","tmp","paddingByte","subarray","ciphertext","validateBlockDecrypt","data","ps0","ps1","ps2","ps3","o0","o1","o2","o3","validatePCKS","lastByte"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/aes.esm.js

@@ -0,0 +1,2 @@
+import{wrapCipher as t,u32 as n}from"./utils.esm.js";import{bytes as e}from"./_assert.esm.js";const r=16;function mul2(t){return t<<1^283&-(t>>7)}function mul(t,n){let e=0;for(;n>0;n>>=1)e^=t&-(1&n),t=mul2(t);return e}const o=(()=>{let t=new Uint8Array(256);for(let n=0,e=1;n<256;n++,e^=mul2(e))t[n]=e;const n=new Uint8Array(256);n[0]=99;for(let e=0;e<255;e++){let r=t[255-e];r|=r<<8,n[t[e]]=255&(r^r>>4^r>>5^r>>6^r>>7^99)}return n})(),l=o.map(((t,n)=>o.indexOf(n))),rotl32_8=t=>t<<8|t>>>24;function genTtable(t,n){if(256!==t.length)throw new Error("Wrong sbox length");const e=new Uint32Array(256).map(((e,r)=>n(t[r]))),r=e.map(rotl32_8),o=r.map(rotl32_8),l=o.map(rotl32_8),s=new Uint32Array(65536),c=new Uint32Array(65536),p=new Uint16Array(65536);for(let n=0;n<256;n++)for(let a=0;a<256;a++){const i=256*n+a;s[i]=e[n]^r[a],c[i]=o[n]^l[a],p[i]=t[n]<<8|t[a]}return{sbox:t,sbox2:p,T0:e,T1:r,T2:o,T3:l,T01:s,T23:c}}const s=genTtable(o,(t=>mul(t,3)<<24|t<<16|t<<8|mul(t,2))),c=genTtable(l,(t=>mul(t,11)<<24|mul(t,13)<<16|mul(t,9)<<8|mul(t,14))),p=(()=>{const t=new Uint8Array(16);for(let n=0,e=1;n<16;n++,e=mul2(e))t[n]=e;return t})();function expandKeyLE(t){e(t);const r=t.length;if(![16,24,32].includes(r))throw new Error(`aes: wrong key size: should be 16, 24 or 32, got: ${r}`);const{sbox2:o}=s,l=n(t),c=l.length,subByte=t=>applySbox(o,t,t,t,t),a=new Uint32Array(r+28);a.set(l);for(let t=c;t<a.length;t++){let n=a[t-1];t%c==0?n=subByte((i=n)<<24|i>>>8)^p[t/c-1]:c>6&&t%c==4&&(n=subByte(n)),a[t]=a[t-c]^n}var i;return a}function expandKeyDecLE(t){const n=expandKeyLE(t),e=n.slice(),r=n.length,{sbox2:o}=s,{T0:l,T1:p,T2:a,T3:i}=c;for(let t=0;t<r;t+=4)for(let o=0;o<4;o++)e[t+o]=n[r-t-4+o];n.fill(0);for(let t=4;t<r-4;t++){const n=e[t],r=applySbox(o,n,n,n,n);e[t]=l[255&r]^p[r>>>8&255]^a[r>>>16&255]^i[r>>>24]}return e}function apply0123(t,n,e,r,o,l){return t[e<<8&65280|r>>>8&255]^n[o>>>8&65280|l>>>24&255]}function applySbox(t,n,e,r,o){return t[255&n|65280&e]|t[r>>>16&255|o>>>16&65280]<<16}function encrypt(t,n,e,r,o){const{sbox2:l,T01:c,T23:p}=s;let a=0;n^=t[a++],e^=t[a++],r^=t[a++],o^=t[a++];const i=t.length/4-2;for(let l=0;l<i;l++){const l=t[a++]^apply0123(c,p,n,e,r,o),s=t[a++]^apply0123(c,p,e,r,o,n),i=t[a++]^apply0123(c,p,r,o,n,e),u=t[a++]^apply0123(c,p,o,n,e,r);n=l,e=s,r=i,o=u}return{s0:t[a++]^applySbox(l,n,e,r,o),s1:t[a++]^applySbox(l,e,r,o,n),s2:t[a++]^applySbox(l,r,o,n,e),s3:t[a++]^applySbox(l,o,n,e,r)}}function decrypt(t,n,e,r,o){const{sbox2:l,T01:s,T23:p}=c;let a=0;n^=t[a++],e^=t[a++],r^=t[a++],o^=t[a++];const i=t.length/4-2;for(let l=0;l<i;l++){const l=t[a++]^apply0123(s,p,n,o,r,e),c=t[a++]^apply0123(s,p,e,n,o,r),i=t[a++]^apply0123(s,p,r,e,n,o),u=t[a++]^apply0123(s,p,o,r,e,n);n=l,e=c,r=i,o=u}return{s0:t[a++]^applySbox(l,n,o,r,e),s1:t[a++]^applySbox(l,e,n,o,r),s2:t[a++]^applySbox(l,r,e,n,o),s3:t[a++]^applySbox(l,o,r,e,n)}}function getDst(t,n){if(!n)return new Uint8Array(t);if(e(n),n.length<t)throw new Error(`aes: wrong destination length, expected at least ${t}, got: ${n.length}`);return n}const a=t({blockSize:16,nonceLength:16},(function cbc(t,o,l={}){e(t),e(o,16);const s=!l.disablePadding;return{encrypt:(e,l)=>{const c=expandKeyLE(t),{b:p,o:a,out:i}=function validateBlockEncrypt(t,e,o){let l=t.length;const s=l%r;if(!e&&0!==s)throw new Error("aec/(cbc-ecb): unpadded plaintext with disabled padding");const c=n(t);if(e){let t=r-s;t||(t=r),l+=t}const p=getDst(l,o);return{b:c,o:n(p),out:p}}(e,s,l),u=n(o);let y=u[0],f=u[1],b=u[2],d=u[3],g=0;for(;g+4<=p.length;)y^=p[g+0],f^=p[g+1],b^=p[g+2],d^=p[g+3],({s0:y,s1:f,s2:b,s3:d}=encrypt(c,y,f,b,d)),a[g++]=y,a[g++]=f,a[g++]=b,a[g++]=d;if(s){const t=function padPCKS(t){const e=new Uint8Array(16),o=n(e);e.set(t);const l=r-t.length;for(let t=r-l;t<r;t++)e[t]=l;return o}(e.subarray(4*g));y^=t[0],f^=t[1],b^=t[2],d^=t[3],({s0:y,s1:f,s2:b,s3:d}=encrypt(c,y,f,b,d)),a[g++]=y,a[g++]=f,a[g++]=b,a[g++]=d}return c.fill(0),i},decrypt:(l,c)=>{!function validateBlockDecrypt(t){if(e(t),t.length%r!=0)throw new Error("aes/(cbc-ecb).decrypt ciphertext should consist of blocks with size 16")}(l);const p=expandKeyDecLE(t),a=n(o),i=getDst(l.length,c),u=n(l),y=n(i);let f=a[0],b=a[1],d=a[2],g=a[3];for(let t=0;t+4<=u.length;){const n=f,e=b,r=d,o=g;f=u[t+0],b=u[t+1],d=u[t+2],g=u[t+3];const{s0:l,s1:s,s2:c,s3:a}=decrypt(p,f,b,d,g);y[t++]=l^n,y[t++]=s^e,y[t++]=c^r,y[t++]=a^o}return p.fill(0),function validatePCKS(t,n){if(!n)return t;const e=t.length;if(!e)throw new Error("aes/pcks5: empty ciphertext not allowed");const r=t[e-1];if(r<=0||r>16)throw new Error(`aes/pcks5: wrong padding byte: ${r}`);const o=t.subarray(0,-r);for(let n=0;n<r;n++)if(t[e-n-1]!==r)throw new Error("aes/pcks5: wrong padding");return o}(i,s)}}}));export{a as cbc,expandKeyDecLE,expandKeyLE};
+//# sourceMappingURL=aes.esm.js.map

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/aes.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aes.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+ciphers@0.5.3/node_modules/@noble/ciphers/esm/aes.js"],"sourcesContent":["// prettier-ignore\nimport { wrapCipher, createView, setBigUint64, equalBytes, u32, u8, } from './utils.js';\nimport { ghash, polyval } from './_polyval.js';\nimport { bytes as abytes } from './_assert.js';\n/*\nAES (Advanced Encryption Standard) aka Rijndael block cipher.\n\nData is split into 128-bit blocks. Encrypted in 10/12/14 rounds (128/192/256 bits). In every round:\n1. **S-box**, table substitution\n2. **Shift rows**, cyclic shift left of all rows of data array\n3. **Mix columns**, multiplying every column by fixed polynomial\n4. **Add round key**, round_key xor i-th column of array\n\nResources:\n- FIPS-197 https://csrc.nist.gov/files/pubs/fips/197/final/docs/fips-197.pdf\n- Original proposal: https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/aes-development/rijndael-ammended.pdf\n*/\nconst BLOCK_SIZE = 16;\nconst BLOCK_SIZE32 = 4;\nconst EMPTY_BLOCK = new Uint8Array(BLOCK_SIZE);\nconst POLY = 0x11b; // 1 + x + x**3 + x**4 + x**8\n// TODO: remove multiplication, binary ops only\nfunction mul2(n) {\n    return (n << 1) ^ (POLY & -(n >> 7));\n}\nfunction mul(a, b) {\n    let res = 0;\n    for (; b > 0; b >>= 1) {\n        // Montgomery ladder\n        res ^= a & -(b & 1); // if (b&1) res ^=a (but const-time).\n        a = mul2(a); // a = 2*a\n    }\n    return res;\n}\n// AES S-box is generated using finite field inversion,\n// an affine transform, and xor of a constant 0x63.\nconst sbox = /* @__PURE__ */ (() => {\n    let t = new Uint8Array(256);\n    for (let i = 0, x = 1; i < 256; i++, x ^= mul2(x))\n        t[i] = x;\n    const box = new Uint8Array(256);\n    box[0] = 0x63; // first elm\n    for (let i = 0; i < 255; i++) {\n        let x = t[255 - i];\n        x |= x << 8;\n        box[t[i]] = (x ^ (x >> 4) ^ (x >> 5) ^ (x >> 6) ^ (x >> 7) ^ 0x63) & 0xff;\n    }\n    return box;\n})();\n// Inverted S-box\nconst invSbox = /* @__PURE__ */ sbox.map((_, j) => sbox.indexOf(j));\n// Rotate u32 by 8\nconst rotr32_8 = (n) => (n << 24) | (n >>> 8);\nconst rotl32_8 = (n) => (n << 8) | (n >>> 24);\n// T-table is optimization suggested in 5.2 of original proposal (missed from FIPS-197). Changes:\n// - LE instead of BE\n// - bigger tables: T0 and T1 are merged into T01 table and T2 & T3 into T23;\n//   so index is u16, instead of u8. This speeds up things, unexpectedly\nfunction genTtable(sbox, fn) {\n    if (sbox.length !== 256)\n        throw new Error('Wrong sbox length');\n    const T0 = new Uint32Array(256).map((_, j) => fn(sbox[j]));\n    const T1 = T0.map(rotl32_8);\n    const T2 = T1.map(rotl32_8);\n    const T3 = T2.map(rotl32_8);\n    const T01 = new Uint32Array(256 * 256);\n    const T23 = new Uint32Array(256 * 256);\n    const sbox2 = new Uint16Array(256 * 256);\n    for (let i = 0; i < 256; i++) {\n        for (let j = 0; j < 256; j++) {\n            const idx = i * 256 + j;\n            T01[idx] = T0[i] ^ T1[j];\n            T23[idx] = T2[i] ^ T3[j];\n            sbox2[idx] = (sbox[i] << 8) | sbox[j];\n        }\n    }\n    return { sbox, sbox2, T0, T1, T2, T3, T01, T23 };\n}\nconst tableEncoding = /* @__PURE__ */ genTtable(sbox, (s) => (mul(s, 3) << 24) | (s << 16) | (s << 8) | mul(s, 2));\nconst tableDecoding = /* @__PURE__ */ genTtable(invSbox, (s) => (mul(s, 11) << 24) | (mul(s, 13) << 16) | (mul(s, 9) << 8) | mul(s, 14));\nconst xPowers = /* @__PURE__ */ (() => {\n    const p = new Uint8Array(16);\n    for (let i = 0, x = 1; i < 16; i++, x = mul2(x))\n        p[i] = x;\n    return p;\n})();\nexport function expandKeyLE(key) {\n    abytes(key);\n    const len = key.length;\n    if (![16, 24, 32].includes(len))\n        throw new Error(`aes: wrong key size: should be 16, 24 or 32, got: ${len}`);\n    const { sbox2 } = tableEncoding;\n    const k32 = u32(key);\n    const Nk = k32.length;\n    const subByte = (n) => applySbox(sbox2, n, n, n, n);\n    const xk = new Uint32Array(len + 28); // expanded key\n    xk.set(k32);\n    // 4.3.1 Key expansion\n    for (let i = Nk; i < xk.length; i++) {\n        let t = xk[i - 1];\n        if (i % Nk === 0)\n            t = subByte(rotr32_8(t)) ^ xPowers[i / Nk - 1];\n        else if (Nk > 6 && i % Nk === 4)\n            t = subByte(t);\n        xk[i] = xk[i - Nk] ^ t;\n    }\n    return xk;\n}\nexport function expandKeyDecLE(key) {\n    const encKey = expandKeyLE(key);\n    const xk = encKey.slice();\n    const Nk = encKey.length;\n    const { sbox2 } = tableEncoding;\n    const { T0, T1, T2, T3 } = tableDecoding;\n    // Inverse key by chunks of 4 (rounds)\n    for (let i = 0; i < Nk; i += 4) {\n        for (let j = 0; j < 4; j++)\n            xk[i + j] = encKey[Nk - i - 4 + j];\n    }\n    encKey.fill(0);\n    // apply InvMixColumn except first & last round\n    for (let i = 4; i < Nk - 4; i++) {\n        const x = xk[i];\n        const w = applySbox(sbox2, x, x, x, x);\n        xk[i] = T0[w & 0xff] ^ T1[(w >>> 8) & 0xff] ^ T2[(w >>> 16) & 0xff] ^ T3[w >>> 24];\n    }\n    return xk;\n}\n// Apply tables\nfunction apply0123(T01, T23, s0, s1, s2, s3) {\n    return (T01[((s0 << 8) & 0xff00) | ((s1 >>> 8) & 0xff)] ^\n        T23[((s2 >>> 8) & 0xff00) | ((s3 >>> 24) & 0xff)]);\n}\nfunction applySbox(sbox2, s0, s1, s2, s3) {\n    return (sbox2[(s0 & 0xff) | (s1 & 0xff00)] |\n        (sbox2[((s2 >>> 16) & 0xff) | ((s3 >>> 16) & 0xff00)] << 16));\n}\nfunction encrypt(xk, s0, s1, s2, s3) {\n    const { sbox2, T01, T23 } = tableEncoding;\n    let k = 0;\n    (s0 ^= xk[k++]), (s1 ^= xk[k++]), (s2 ^= xk[k++]), (s3 ^= xk[k++]);\n    const rounds = xk.length / 4 - 2;\n    for (let i = 0; i < rounds; i++) {\n        const t0 = xk[k++] ^ apply0123(T01, T23, s0, s1, s2, s3);\n        const t1 = xk[k++] ^ apply0123(T01, T23, s1, s2, s3, s0);\n        const t2 = xk[k++] ^ apply0123(T01, T23, s2, s3, s0, s1);\n        const t3 = xk[k++] ^ apply0123(T01, T23, s3, s0, s1, s2);\n        (s0 = t0), (s1 = t1), (s2 = t2), (s3 = t3);\n    }\n    // last round (without mixcolumns, so using SBOX2 table)\n    const t0 = xk[k++] ^ applySbox(sbox2, s0, s1, s2, s3);\n    const t1 = xk[k++] ^ applySbox(sbox2, s1, s2, s3, s0);\n    const t2 = xk[k++] ^ applySbox(sbox2, s2, s3, s0, s1);\n    const t3 = xk[k++] ^ applySbox(sbox2, s3, s0, s1, s2);\n    return { s0: t0, s1: t1, s2: t2, s3: t3 };\n}\nfunction decrypt(xk, s0, s1, s2, s3) {\n    const { sbox2, T01, T23 } = tableDecoding;\n    let k = 0;\n    (s0 ^= xk[k++]), (s1 ^= xk[k++]), (s2 ^= xk[k++]), (s3 ^= xk[k++]);\n    const rounds = xk.length / 4 - 2;\n    for (let i = 0; i < rounds; i++) {\n        const t0 = xk[k++] ^ apply0123(T01, T23, s0, s3, s2, s1);\n        const t1 = xk[k++] ^ apply0123(T01, T23, s1, s0, s3, s2);\n        const t2 = xk[k++] ^ apply0123(T01, T23, s2, s1, s0, s3);\n        const t3 = xk[k++] ^ apply0123(T01, T23, s3, s2, s1, s0);\n        (s0 = t0), (s1 = t1), (s2 = t2), (s3 = t3);\n    }\n    // Last round\n    const t0 = xk[k++] ^ applySbox(sbox2, s0, s3, s2, s1);\n    const t1 = xk[k++] ^ applySbox(sbox2, s1, s0, s3, s2);\n    const t2 = xk[k++] ^ applySbox(sbox2, s2, s1, s0, s3);\n    const t3 = xk[k++] ^ applySbox(sbox2, s3, s2, s1, s0);\n    return { s0: t0, s1: t1, s2: t2, s3: t3 };\n}\nfunction getDst(len, dst) {\n    if (!dst)\n        return new Uint8Array(len);\n    abytes(dst);\n    if (dst.length < len)\n        throw new Error(`aes: wrong destination length, expected at least ${len}, got: ${dst.length}`);\n    return dst;\n}\n// TODO: investigate merging with ctr32\nfunction ctrCounter(xk, nonce, src, dst) {\n    abytes(nonce, BLOCK_SIZE);\n    abytes(src);\n    const srcLen = src.length;\n    dst = getDst(srcLen, dst);\n    const ctr = nonce;\n    const c32 = u32(ctr);\n    // Fill block (empty, ctr=0)\n    let { s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]);\n    const src32 = u32(src);\n    const dst32 = u32(dst);\n    // process blocks\n    for (let i = 0; i + 4 <= src32.length; i += 4) {\n        dst32[i + 0] = src32[i + 0] ^ s0;\n        dst32[i + 1] = src32[i + 1] ^ s1;\n        dst32[i + 2] = src32[i + 2] ^ s2;\n        dst32[i + 3] = src32[i + 3] ^ s3;\n        // Full 128 bit counter with wrap around\n        let carry = 1;\n        for (let i = ctr.length - 1; i >= 0; i--) {\n            carry = (carry + (ctr[i] & 0xff)) | 0;\n            ctr[i] = carry & 0xff;\n            carry >>>= 8;\n        }\n        ({ s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]));\n    }\n    // leftovers (less than block)\n    // It's possible to handle > u32 fast, but is it worth it?\n    const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);\n    if (start < srcLen) {\n        const b32 = new Uint32Array([s0, s1, s2, s3]);\n        const buf = u8(b32);\n        for (let i = start, pos = 0; i < srcLen; i++, pos++)\n            dst[i] = src[i] ^ buf[pos];\n    }\n    return dst;\n}\n// AES CTR with overflowing 32 bit counter\n// It's possible to do 32le significantly simpler (and probably faster) by using u32.\n// But, we need both, and perf bottleneck is in ghash anyway.\nfunction ctr32(xk, isLE, nonce, src, dst) {\n    abytes(nonce, BLOCK_SIZE);\n    abytes(src);\n    dst = getDst(src.length, dst);\n    const ctr = nonce; // write new value to nonce, so it can be re-used\n    const c32 = u32(ctr);\n    const view = createView(ctr);\n    const src32 = u32(src);\n    const dst32 = u32(dst);\n    const ctrPos = isLE ? 0 : 12;\n    const srcLen = src.length;\n    // Fill block (empty, ctr=0)\n    let ctrNum = view.getUint32(ctrPos, isLE); // read current counter value\n    let { s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]);\n    // process blocks\n    for (let i = 0; i + 4 <= src32.length; i += 4) {\n        dst32[i + 0] = src32[i + 0] ^ s0;\n        dst32[i + 1] = src32[i + 1] ^ s1;\n        dst32[i + 2] = src32[i + 2] ^ s2;\n        dst32[i + 3] = src32[i + 3] ^ s3;\n        ctrNum = (ctrNum + 1) >>> 0; // u32 wrap\n        view.setUint32(ctrPos, ctrNum, isLE);\n        ({ s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]));\n    }\n    // leftovers (less than a block)\n    const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);\n    if (start < srcLen) {\n        const b32 = new Uint32Array([s0, s1, s2, s3]);\n        const buf = u8(b32);\n        for (let i = start, pos = 0; i < srcLen; i++, pos++)\n            dst[i] = src[i] ^ buf[pos];\n    }\n    return dst;\n}\n/**\n * CTR: counter mode. Creates stream cipher.\n * Requires good IV. Parallelizable. OK, but no MAC.\n */\nexport const ctr = wrapCipher({ blockSize: 16, nonceLength: 16 }, function ctr(key, nonce) {\n    abytes(key);\n    abytes(nonce, BLOCK_SIZE);\n    function processCtr(buf, dst) {\n        const xk = expandKeyLE(key);\n        const n = nonce.slice();\n        const out = ctrCounter(xk, n, buf, dst);\n        xk.fill(0);\n        n.fill(0);\n        return out;\n    }\n    return {\n        encrypt: (plaintext, dst) => processCtr(plaintext, dst),\n        decrypt: (ciphertext, dst) => processCtr(ciphertext, dst),\n    };\n});\nfunction validateBlockDecrypt(data) {\n    abytes(data);\n    if (data.length % BLOCK_SIZE !== 0) {\n        throw new Error(`aes/(cbc-ecb).decrypt ciphertext should consist of blocks with size ${BLOCK_SIZE}`);\n    }\n}\nfunction validateBlockEncrypt(plaintext, pcks5, dst) {\n    let outLen = plaintext.length;\n    const remaining = outLen % BLOCK_SIZE;\n    if (!pcks5 && remaining !== 0)\n        throw new Error('aec/(cbc-ecb): unpadded plaintext with disabled padding');\n    const b = u32(plaintext);\n    if (pcks5) {\n        let left = BLOCK_SIZE - remaining;\n        if (!left)\n            left = BLOCK_SIZE; // if no bytes left, create empty padding block\n        outLen = outLen + left;\n    }\n    const out = getDst(outLen, dst);\n    const o = u32(out);\n    return { b, o, out };\n}\nfunction validatePCKS(data, pcks5) {\n    if (!pcks5)\n        return data;\n    const len = data.length;\n    if (!len)\n        throw new Error(`aes/pcks5: empty ciphertext not allowed`);\n    const lastByte = data[len - 1];\n    if (lastByte <= 0 || lastByte > 16)\n        throw new Error(`aes/pcks5: wrong padding byte: ${lastByte}`);\n    const out = data.subarray(0, -lastByte);\n    for (let i = 0; i < lastByte; i++)\n        if (data[len - i - 1] !== lastByte)\n            throw new Error(`aes/pcks5: wrong padding`);\n    return out;\n}\nfunction padPCKS(left) {\n    const tmp = new Uint8Array(16);\n    const tmp32 = u32(tmp);\n    tmp.set(left);\n    const paddingByte = BLOCK_SIZE - left.length;\n    for (let i = BLOCK_SIZE - paddingByte; i < BLOCK_SIZE; i++)\n        tmp[i] = paddingByte;\n    return tmp32;\n}\n/**\n * ECB: Electronic CodeBook. Simple deterministic replacement.\n * Dangerous: always map x to y. See [AES Penguin](https://words.filippo.io/the-ecb-penguin/).\n */\nexport const ecb = wrapCipher({ blockSize: 16 }, function ecb(key, opts = {}) {\n    abytes(key);\n    const pcks5 = !opts.disablePadding;\n    return {\n        encrypt: (plaintext, dst) => {\n            abytes(plaintext);\n            const { b, o, out: _out } = validateBlockEncrypt(plaintext, pcks5, dst);\n            const xk = expandKeyLE(key);\n            let i = 0;\n            for (; i + 4 <= b.length;) {\n                const { s0, s1, s2, s3 } = encrypt(xk, b[i + 0], b[i + 1], b[i + 2], b[i + 3]);\n                (o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3);\n            }\n            if (pcks5) {\n                const tmp32 = padPCKS(plaintext.subarray(i * 4));\n                const { s0, s1, s2, s3 } = encrypt(xk, tmp32[0], tmp32[1], tmp32[2], tmp32[3]);\n                (o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3);\n            }\n            xk.fill(0);\n            return _out;\n        },\n        decrypt: (ciphertext, dst) => {\n            validateBlockDecrypt(ciphertext);\n            const xk = expandKeyDecLE(key);\n            const out = getDst(ciphertext.length, dst);\n            const b = u32(ciphertext);\n            const o = u32(out);\n            for (let i = 0; i + 4 <= b.length;) {\n                const { s0, s1, s2, s3 } = decrypt(xk, b[i + 0], b[i + 1], b[i + 2], b[i + 3]);\n                (o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3);\n            }\n            xk.fill(0);\n            return validatePCKS(out, pcks5);\n        },\n    };\n});\n/**\n * CBC: Cipher-Block-Chaining. Key is previous round’s block.\n * Fragile: needs proper padding. Unauthenticated: needs MAC.\n */\nexport const cbc = wrapCipher({ blockSize: 16, nonceLength: 16 }, function cbc(key, iv, opts = {}) {\n    abytes(key);\n    abytes(iv, 16);\n    const pcks5 = !opts.disablePadding;\n    return {\n        encrypt: (plaintext, dst) => {\n            const xk = expandKeyLE(key);\n            const { b, o, out: _out } = validateBlockEncrypt(plaintext, pcks5, dst);\n            const n32 = u32(iv);\n            // prettier-ignore\n            let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];\n            let i = 0;\n            for (; i + 4 <= b.length;) {\n                (s0 ^= b[i + 0]), (s1 ^= b[i + 1]), (s2 ^= b[i + 2]), (s3 ^= b[i + 3]);\n                ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));\n                (o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3);\n            }\n            if (pcks5) {\n                const tmp32 = padPCKS(plaintext.subarray(i * 4));\n                (s0 ^= tmp32[0]), (s1 ^= tmp32[1]), (s2 ^= tmp32[2]), (s3 ^= tmp32[3]);\n                ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));\n                (o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3);\n            }\n            xk.fill(0);\n            return _out;\n        },\n        decrypt: (ciphertext, dst) => {\n            validateBlockDecrypt(ciphertext);\n            const xk = expandKeyDecLE(key);\n            const n32 = u32(iv);\n            const out = getDst(ciphertext.length, dst);\n            const b = u32(ciphertext);\n            const o = u32(out);\n            // prettier-ignore\n            let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];\n            for (let i = 0; i + 4 <= b.length;) {\n                // prettier-ignore\n                const ps0 = s0, ps1 = s1, ps2 = s2, ps3 = s3;\n                (s0 = b[i + 0]), (s1 = b[i + 1]), (s2 = b[i + 2]), (s3 = b[i + 3]);\n                const { s0: o0, s1: o1, s2: o2, s3: o3 } = decrypt(xk, s0, s1, s2, s3);\n                (o[i++] = o0 ^ ps0), (o[i++] = o1 ^ ps1), (o[i++] = o2 ^ ps2), (o[i++] = o3 ^ ps3);\n            }\n            xk.fill(0);\n            return validatePCKS(out, pcks5);\n        },\n    };\n});\n/**\n * CFB: Cipher Feedback Mode. The input for the block cipher is the previous cipher output.\n * Unauthenticated: needs MAC.\n */\nexport const cfb = wrapCipher({ blockSize: 16, nonceLength: 16 }, function cfb(key, iv) {\n    abytes(key);\n    abytes(iv, 16);\n    function processCfb(src, isEncrypt, dst) {\n        const xk = expandKeyLE(key);\n        const srcLen = src.length;\n        dst = getDst(srcLen, dst);\n        const src32 = u32(src);\n        const dst32 = u32(dst);\n        const next32 = isEncrypt ? dst32 : src32;\n        const n32 = u32(iv);\n        // prettier-ignore\n        let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];\n        for (let i = 0; i + 4 <= src32.length;) {\n            const { s0: e0, s1: e1, s2: e2, s3: e3 } = encrypt(xk, s0, s1, s2, s3);\n            dst32[i + 0] = src32[i + 0] ^ e0;\n            dst32[i + 1] = src32[i + 1] ^ e1;\n            dst32[i + 2] = src32[i + 2] ^ e2;\n            dst32[i + 3] = src32[i + 3] ^ e3;\n            (s0 = next32[i++]), (s1 = next32[i++]), (s2 = next32[i++]), (s3 = next32[i++]);\n        }\n        // leftovers (less than block)\n        const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);\n        if (start < srcLen) {\n            ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));\n            const buf = u8(new Uint32Array([s0, s1, s2, s3]));\n            for (let i = start, pos = 0; i < srcLen; i++, pos++)\n                dst[i] = src[i] ^ buf[pos];\n            buf.fill(0);\n        }\n        xk.fill(0);\n        return dst;\n    }\n    return {\n        encrypt: (plaintext, dst) => processCfb(plaintext, true, dst),\n        decrypt: (ciphertext, dst) => processCfb(ciphertext, false, dst),\n    };\n});\n// TODO: merge with chacha, however gcm has bitLen while chacha has byteLen\nfunction computeTag(fn, isLE, key, data, AAD) {\n    const h = fn.create(key, data.length + (AAD?.length || 0));\n    if (AAD)\n        h.update(AAD);\n    h.update(data);\n    const num = new Uint8Array(16);\n    const view = createView(num);\n    if (AAD)\n        setBigUint64(view, 0, BigInt(AAD.length * 8), isLE);\n    setBigUint64(view, 8, BigInt(data.length * 8), isLE);\n    h.update(num);\n    return h.digest();\n}\n/**\n * GCM: Galois/Counter Mode.\n * Good, modern version of CTR, parallel, with MAC.\n * Be careful: MACs can be forged.\n */\nexport const gcm = wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16 }, function gcm(key, nonce, AAD) {\n    abytes(nonce);\n    // Nonce can be pretty much anything (even 1 byte). But smaller nonces less secure.\n    if (nonce.length === 0)\n        throw new Error('aes/gcm: empty nonce');\n    const tagLength = 16;\n    function _computeTag(authKey, tagMask, data) {\n        const tag = computeTag(ghash, false, authKey, data, AAD);\n        for (let i = 0; i < tagMask.length; i++)\n            tag[i] ^= tagMask[i];\n        return tag;\n    }\n    function deriveKeys() {\n        const xk = expandKeyLE(key);\n        const authKey = EMPTY_BLOCK.slice();\n        const counter = EMPTY_BLOCK.slice();\n        ctr32(xk, false, counter, counter, authKey);\n        if (nonce.length === 12) {\n            counter.set(nonce);\n        }\n        else {\n            // Spec (NIST 800-38d) supports variable size nonce.\n            // Not supported for now, but can be useful.\n            const nonceLen = EMPTY_BLOCK.slice();\n            const view = createView(nonceLen);\n            setBigUint64(view, 8, BigInt(nonce.length * 8), false);\n            // ghash(nonce || u64be(0) || u64be(nonceLen*8))\n            ghash.create(authKey).update(nonce).update(nonceLen).digestInto(counter);\n        }\n        const tagMask = ctr32(xk, false, counter, EMPTY_BLOCK);\n        return { xk, authKey, counter, tagMask };\n    }\n    return {\n        encrypt: (plaintext) => {\n            abytes(plaintext);\n            const { xk, authKey, counter, tagMask } = deriveKeys();\n            const out = new Uint8Array(plaintext.length + tagLength);\n            ctr32(xk, false, counter, plaintext, out);\n            const tag = _computeTag(authKey, tagMask, out.subarray(0, out.length - tagLength));\n            out.set(tag, plaintext.length);\n            xk.fill(0);\n            return out;\n        },\n        decrypt: (ciphertext) => {\n            abytes(ciphertext);\n            if (ciphertext.length < tagLength)\n                throw new Error(`aes/gcm: ciphertext less than tagLen (${tagLength})`);\n            const { xk, authKey, counter, tagMask } = deriveKeys();\n            const data = ciphertext.subarray(0, -tagLength);\n            const passedTag = ciphertext.subarray(-tagLength);\n            const tag = _computeTag(authKey, tagMask, data);\n            if (!equalBytes(tag, passedTag))\n                throw new Error('aes/gcm: invalid ghash tag');\n            const out = ctr32(xk, false, counter, data);\n            authKey.fill(0);\n            tagMask.fill(0);\n            xk.fill(0);\n            return out;\n        },\n    };\n});\nconst limit = (name, min, max) => (value) => {\n    if (!Number.isSafeInteger(value) || min > value || value > max)\n        throw new Error(`${name}: invalid value=${value}, must be [${min}..${max}]`);\n};\n/**\n * AES-GCM-SIV: classic AES-GCM with nonce-misuse resistance.\n * Guarantees that, when a nonce is repeated, the only security loss is that identical\n * plaintexts will produce identical ciphertexts.\n * RFC 8452, https://datatracker.ietf.org/doc/html/rfc8452\n */\nexport const siv = wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16 }, function siv(key, nonce, AAD) {\n    const tagLength = 16;\n    // From RFC 8452: Section 6\n    const AAD_LIMIT = limit('AAD', 0, 2 ** 36);\n    const PLAIN_LIMIT = limit('plaintext', 0, 2 ** 36);\n    const NONCE_LIMIT = limit('nonce', 12, 12);\n    const CIPHER_LIMIT = limit('ciphertext', 16, 2 ** 36 + 16);\n    abytes(nonce);\n    NONCE_LIMIT(nonce.length);\n    if (AAD) {\n        abytes(AAD);\n        AAD_LIMIT(AAD.length);\n    }\n    function deriveKeys() {\n        const len = key.length;\n        if (len !== 16 && len !== 24 && len !== 32)\n            throw new Error(`key length must be 16, 24 or 32 bytes, got: ${len} bytes`);\n        const xk = expandKeyLE(key);\n        const encKey = new Uint8Array(len);\n        const authKey = new Uint8Array(16);\n        const n32 = u32(nonce);\n        // prettier-ignore\n        let s0 = 0, s1 = n32[0], s2 = n32[1], s3 = n32[2];\n        let counter = 0;\n        for (const derivedKey of [authKey, encKey].map(u32)) {\n            const d32 = u32(derivedKey);\n            for (let i = 0; i < d32.length; i += 2) {\n                // aes(u32le(0) || nonce)[:8] || aes(u32le(1) || nonce)[:8] ...\n                const { s0: o0, s1: o1 } = encrypt(xk, s0, s1, s2, s3);\n                d32[i + 0] = o0;\n                d32[i + 1] = o1;\n                s0 = ++counter; // increment counter inside state\n            }\n        }\n        xk.fill(0);\n        return { authKey, encKey: expandKeyLE(encKey) };\n    }\n    function _computeTag(encKey, authKey, data) {\n        const tag = computeTag(polyval, true, authKey, data, AAD);\n        // Compute the expected tag by XORing S_s and the nonce, clearing the\n        // most significant bit of the last byte and encrypting with the\n        // message-encryption key.\n        for (let i = 0; i < 12; i++)\n            tag[i] ^= nonce[i];\n        tag[15] &= 0x7f; // Clear the highest bit\n        // encrypt tag as block\n        const t32 = u32(tag);\n        // prettier-ignore\n        let s0 = t32[0], s1 = t32[1], s2 = t32[2], s3 = t32[3];\n        ({ s0, s1, s2, s3 } = encrypt(encKey, s0, s1, s2, s3));\n        (t32[0] = s0), (t32[1] = s1), (t32[2] = s2), (t32[3] = s3);\n        return tag;\n    }\n    // actual decrypt/encrypt of message.\n    function processSiv(encKey, tag, input) {\n        let block = tag.slice();\n        block[15] |= 0x80; // Force highest bit\n        return ctr32(encKey, true, block, input);\n    }\n    return {\n        encrypt: (plaintext) => {\n            abytes(plaintext);\n            PLAIN_LIMIT(plaintext.length);\n            const { encKey, authKey } = deriveKeys();\n            const tag = _computeTag(encKey, authKey, plaintext);\n            const out = new Uint8Array(plaintext.length + tagLength);\n            out.set(tag, plaintext.length);\n            out.set(processSiv(encKey, tag, plaintext));\n            encKey.fill(0);\n            authKey.fill(0);\n            return out;\n        },\n        decrypt: (ciphertext) => {\n            abytes(ciphertext);\n            CIPHER_LIMIT(ciphertext.length);\n            const tag = ciphertext.subarray(-tagLength);\n            const { encKey, authKey } = deriveKeys();\n            const plaintext = processSiv(encKey, tag, ciphertext.subarray(0, -tagLength));\n            const expectedTag = _computeTag(encKey, authKey, plaintext);\n            encKey.fill(0);\n            authKey.fill(0);\n            if (!equalBytes(tag, expectedTag))\n                throw new Error('invalid polyval tag');\n            return plaintext;\n        },\n    };\n});\nfunction isBytes32(a) {\n    return (a != null &&\n        typeof a === 'object' &&\n        (a instanceof Uint32Array || a.constructor.name === 'Uint32Array'));\n}\nfunction encryptBlock(xk, block) {\n    abytes(block, 16);\n    if (!isBytes32(xk))\n        throw new Error('_encryptBlock accepts result of expandKeyLE');\n    const b32 = u32(block);\n    let { s0, s1, s2, s3 } = encrypt(xk, b32[0], b32[1], b32[2], b32[3]);\n    (b32[0] = s0), (b32[1] = s1), (b32[2] = s2), (b32[3] = s3);\n    return block;\n}\nfunction decryptBlock(xk, block) {\n    abytes(block, 16);\n    if (!isBytes32(xk))\n        throw new Error('_decryptBlock accepts result of expandKeyLE');\n    const b32 = u32(block);\n    let { s0, s1, s2, s3 } = decrypt(xk, b32[0], b32[1], b32[2], b32[3]);\n    (b32[0] = s0), (b32[1] = s1), (b32[2] = s2), (b32[3] = s3);\n    return block;\n}\n// Highly unsafe private functions for implementing new modes or ciphers based on AES\n// Can change at any time, no API guarantees\nexport const unsafe = {\n    expandKeyLE,\n    expandKeyDecLE,\n    encrypt,\n    decrypt,\n    encryptBlock,\n    decryptBlock,\n    ctrCounter,\n    ctr32,\n};\n//# sourceMappingURL=aes.js.map"],"names":["BLOCK_SIZE","mul2","n","mul","a","b","res","sbox","t","Uint8Array","i","x","box","invSbox","map","_","j","indexOf","rotl32_8","genTtable","fn","length","Error","T0","Uint32Array","T1","T2","T3","T01","T23","sbox2","Uint16Array","idx","tableEncoding","s","tableDecoding","xPowers","p","expandKeyLE","key","abytes","len","includes","k32","u32","Nk","subByte","applySbox","xk","set","expandKeyDecLE","encKey","slice","fill","w","apply0123","s0","s1","s2","s3","encrypt","k","rounds","t0","t1","t2","t3","decrypt","getDst","dst","cbc","wrapCipher","blockSize","nonceLength","iv","opts","pcks5","disablePadding","plaintext","o","out","_out","validateBlockEncrypt","outLen","remaining","left","n32","tmp32","padPCKS","tmp","paddingByte","subarray","ciphertext","validateBlockDecrypt","data","ps0","ps1","ps2","ps3","o0","o1","o2","o3","validatePCKS","lastByte"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/chacha.cjs.js

@@ -0,0 +1,2 @@
+"use strict";var r=require("./_arx.cjs.js");function chachaCore(t,o,l,e,c,a=20){let h=t[0],s=t[1],n=t[2],i=t[3],u=o[0],C=o[1],f=o[2],g=o[3],j=o[4],p=o[5],x=o[6],q=o[7],v=c,w=l[0],y=l[1],K=l[2],L=h,R=s,S=n,_=i,b=u,d=C,k=f,m=g,z=j,A=p,B=x,D=q,E=v,F=w,G=y,H=K;for(let t=0;t<a;t+=2)L=L+b|0,E=r.rotl(E^L,16),z=z+E|0,b=r.rotl(b^z,12),L=L+b|0,E=r.rotl(E^L,8),z=z+E|0,b=r.rotl(b^z,7),R=R+d|0,F=r.rotl(F^R,16),A=A+F|0,d=r.rotl(d^A,12),R=R+d|0,F=r.rotl(F^R,8),A=A+F|0,d=r.rotl(d^A,7),S=S+k|0,G=r.rotl(G^S,16),B=B+G|0,k=r.rotl(k^B,12),S=S+k|0,G=r.rotl(G^S,8),B=B+G|0,k=r.rotl(k^B,7),_=_+m|0,H=r.rotl(H^_,16),D=D+H|0,m=r.rotl(m^D,12),_=_+m|0,H=r.rotl(H^_,8),D=D+H|0,m=r.rotl(m^D,7),L=L+d|0,H=r.rotl(H^L,16),B=B+H|0,d=r.rotl(d^B,12),L=L+d|0,H=r.rotl(H^L,8),B=B+H|0,d=r.rotl(d^B,7),R=R+k|0,E=r.rotl(E^R,16),D=D+E|0,k=r.rotl(k^D,12),R=R+k|0,E=r.rotl(E^R,8),D=D+E|0,k=r.rotl(k^D,7),S=S+m|0,F=r.rotl(F^S,16),z=z+F|0,m=r.rotl(m^z,12),S=S+m|0,F=r.rotl(F^S,8),z=z+F|0,m=r.rotl(m^z,7),_=_+b|0,G=r.rotl(G^_,16),A=A+G|0,b=r.rotl(b^A,12),_=_+b|0,G=r.rotl(G^_,8),A=A+G|0,b=r.rotl(b^A,7);let I=0;e[I++]=h+L|0,e[I++]=s+R|0,e[I++]=n+S|0,e[I++]=i+_|0,e[I++]=u+b|0,e[I++]=C+d|0,e[I++]=f+k|0,e[I++]=g+m|0,e[I++]=j+z|0,e[I++]=p+A|0,e[I++]=x+B|0,e[I++]=q+D|0,e[I++]=v+E|0,e[I++]=w+F|0,e[I++]=y+G|0,e[I++]=K+H|0}const t=r.createCipher(chachaCore,{counterRight:!1,counterLength:4,allowShortKeys:!1});exports.chacha20=t;
+//# sourceMappingURL=chacha.cjs.js.map

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/chacha.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chacha.cjs.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+ciphers@0.5.3/node_modules/@noble/ciphers/esm/chacha.js"],"sourcesContent":["// prettier-ignore\nimport { wrapCipher, createView, equalBytes, setBigUint64, } from './utils.js';\nimport { poly1305 } from './_poly1305.js';\nimport { createCipher, rotl } from './_arx.js';\nimport { bytes as abytes } from './_assert.js';\n// ChaCha20 stream cipher was released in 2008. ChaCha aims to increase\n// the diffusion per round, but had slightly less cryptanalysis.\n// https://cr.yp.to/chacha.html, http://cr.yp.to/chacha/chacha-20080128.pdf\n/**\n * ChaCha core function.\n */\n// prettier-ignore\nfunction chachaCore(s, k, n, out, cnt, rounds = 20) {\n    let y00 = s[0], y01 = s[1], y02 = s[2], y03 = s[3], // \"expa\"   \"nd 3\"  \"2-by\"  \"te k\"\n    y04 = k[0], y05 = k[1], y06 = k[2], y07 = k[3], // Key      Key     Key     Key\n    y08 = k[4], y09 = k[5], y10 = k[6], y11 = k[7], // Key      Key     Key     Key\n    y12 = cnt, y13 = n[0], y14 = n[1], y15 = n[2]; // Counter  Counter\tNonce   Nonce\n    // Save state to temporary variables\n    let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;\n    for (let r = 0; r < rounds; r += 2) {\n        x00 = (x00 + x04) | 0;\n        x12 = rotl(x12 ^ x00, 16);\n        x08 = (x08 + x12) | 0;\n        x04 = rotl(x04 ^ x08, 12);\n        x00 = (x00 + x04) | 0;\n        x12 = rotl(x12 ^ x00, 8);\n        x08 = (x08 + x12) | 0;\n        x04 = rotl(x04 ^ x08, 7);\n        x01 = (x01 + x05) | 0;\n        x13 = rotl(x13 ^ x01, 16);\n        x09 = (x09 + x13) | 0;\n        x05 = rotl(x05 ^ x09, 12);\n        x01 = (x01 + x05) | 0;\n        x13 = rotl(x13 ^ x01, 8);\n        x09 = (x09 + x13) | 0;\n        x05 = rotl(x05 ^ x09, 7);\n        x02 = (x02 + x06) | 0;\n        x14 = rotl(x14 ^ x02, 16);\n        x10 = (x10 + x14) | 0;\n        x06 = rotl(x06 ^ x10, 12);\n        x02 = (x02 + x06) | 0;\n        x14 = rotl(x14 ^ x02, 8);\n        x10 = (x10 + x14) | 0;\n        x06 = rotl(x06 ^ x10, 7);\n        x03 = (x03 + x07) | 0;\n        x15 = rotl(x15 ^ x03, 16);\n        x11 = (x11 + x15) | 0;\n        x07 = rotl(x07 ^ x11, 12);\n        x03 = (x03 + x07) | 0;\n        x15 = rotl(x15 ^ x03, 8);\n        x11 = (x11 + x15) | 0;\n        x07 = rotl(x07 ^ x11, 7);\n        x00 = (x00 + x05) | 0;\n        x15 = rotl(x15 ^ x00, 16);\n        x10 = (x10 + x15) | 0;\n        x05 = rotl(x05 ^ x10, 12);\n        x00 = (x00 + x05) | 0;\n        x15 = rotl(x15 ^ x00, 8);\n        x10 = (x10 + x15) | 0;\n        x05 = rotl(x05 ^ x10, 7);\n        x01 = (x01 + x06) | 0;\n        x12 = rotl(x12 ^ x01, 16);\n        x11 = (x11 + x12) | 0;\n        x06 = rotl(x06 ^ x11, 12);\n        x01 = (x01 + x06) | 0;\n        x12 = rotl(x12 ^ x01, 8);\n        x11 = (x11 + x12) | 0;\n        x06 = rotl(x06 ^ x11, 7);\n        x02 = (x02 + x07) | 0;\n        x13 = rotl(x13 ^ x02, 16);\n        x08 = (x08 + x13) | 0;\n        x07 = rotl(x07 ^ x08, 12);\n        x02 = (x02 + x07) | 0;\n        x13 = rotl(x13 ^ x02, 8);\n        x08 = (x08 + x13) | 0;\n        x07 = rotl(x07 ^ x08, 7);\n        x03 = (x03 + x04) | 0;\n        x14 = rotl(x14 ^ x03, 16);\n        x09 = (x09 + x14) | 0;\n        x04 = rotl(x04 ^ x09, 12);\n        x03 = (x03 + x04) | 0;\n        x14 = rotl(x14 ^ x03, 8);\n        x09 = (x09 + x14) | 0;\n        x04 = rotl(x04 ^ x09, 7);\n    }\n    // Write output\n    let oi = 0;\n    out[oi++] = (y00 + x00) | 0;\n    out[oi++] = (y01 + x01) | 0;\n    out[oi++] = (y02 + x02) | 0;\n    out[oi++] = (y03 + x03) | 0;\n    out[oi++] = (y04 + x04) | 0;\n    out[oi++] = (y05 + x05) | 0;\n    out[oi++] = (y06 + x06) | 0;\n    out[oi++] = (y07 + x07) | 0;\n    out[oi++] = (y08 + x08) | 0;\n    out[oi++] = (y09 + x09) | 0;\n    out[oi++] = (y10 + x10) | 0;\n    out[oi++] = (y11 + x11) | 0;\n    out[oi++] = (y12 + x12) | 0;\n    out[oi++] = (y13 + x13) | 0;\n    out[oi++] = (y14 + x14) | 0;\n    out[oi++] = (y15 + x15) | 0;\n}\n/**\n * hchacha helper method, used primarily in xchacha, to hash\n * key and nonce into key' and nonce'.\n * Same as chachaCore, but there doesn't seem to be a way to move the block\n * out without 25% performance hit.\n */\n// prettier-ignore\nexport function hchacha(s, k, i, o32) {\n    let x00 = s[0], x01 = s[1], x02 = s[2], x03 = s[3], x04 = k[0], x05 = k[1], x06 = k[2], x07 = k[3], x08 = k[4], x09 = k[5], x10 = k[6], x11 = k[7], x12 = i[0], x13 = i[1], x14 = i[2], x15 = i[3];\n    for (let r = 0; r < 20; r += 2) {\n        x00 = (x00 + x04) | 0;\n        x12 = rotl(x12 ^ x00, 16);\n        x08 = (x08 + x12) | 0;\n        x04 = rotl(x04 ^ x08, 12);\n        x00 = (x00 + x04) | 0;\n        x12 = rotl(x12 ^ x00, 8);\n        x08 = (x08 + x12) | 0;\n        x04 = rotl(x04 ^ x08, 7);\n        x01 = (x01 + x05) | 0;\n        x13 = rotl(x13 ^ x01, 16);\n        x09 = (x09 + x13) | 0;\n        x05 = rotl(x05 ^ x09, 12);\n        x01 = (x01 + x05) | 0;\n        x13 = rotl(x13 ^ x01, 8);\n        x09 = (x09 + x13) | 0;\n        x05 = rotl(x05 ^ x09, 7);\n        x02 = (x02 + x06) | 0;\n        x14 = rotl(x14 ^ x02, 16);\n        x10 = (x10 + x14) | 0;\n        x06 = rotl(x06 ^ x10, 12);\n        x02 = (x02 + x06) | 0;\n        x14 = rotl(x14 ^ x02, 8);\n        x10 = (x10 + x14) | 0;\n        x06 = rotl(x06 ^ x10, 7);\n        x03 = (x03 + x07) | 0;\n        x15 = rotl(x15 ^ x03, 16);\n        x11 = (x11 + x15) | 0;\n        x07 = rotl(x07 ^ x11, 12);\n        x03 = (x03 + x07) | 0;\n        x15 = rotl(x15 ^ x03, 8);\n        x11 = (x11 + x15) | 0;\n        x07 = rotl(x07 ^ x11, 7);\n        x00 = (x00 + x05) | 0;\n        x15 = rotl(x15 ^ x00, 16);\n        x10 = (x10 + x15) | 0;\n        x05 = rotl(x05 ^ x10, 12);\n        x00 = (x00 + x05) | 0;\n        x15 = rotl(x15 ^ x00, 8);\n        x10 = (x10 + x15) | 0;\n        x05 = rotl(x05 ^ x10, 7);\n        x01 = (x01 + x06) | 0;\n        x12 = rotl(x12 ^ x01, 16);\n        x11 = (x11 + x12) | 0;\n        x06 = rotl(x06 ^ x11, 12);\n        x01 = (x01 + x06) | 0;\n        x12 = rotl(x12 ^ x01, 8);\n        x11 = (x11 + x12) | 0;\n        x06 = rotl(x06 ^ x11, 7);\n        x02 = (x02 + x07) | 0;\n        x13 = rotl(x13 ^ x02, 16);\n        x08 = (x08 + x13) | 0;\n        x07 = rotl(x07 ^ x08, 12);\n        x02 = (x02 + x07) | 0;\n        x13 = rotl(x13 ^ x02, 8);\n        x08 = (x08 + x13) | 0;\n        x07 = rotl(x07 ^ x08, 7);\n        x03 = (x03 + x04) | 0;\n        x14 = rotl(x14 ^ x03, 16);\n        x09 = (x09 + x14) | 0;\n        x04 = rotl(x04 ^ x09, 12);\n        x03 = (x03 + x04) | 0;\n        x14 = rotl(x14 ^ x03, 8);\n        x09 = (x09 + x14) | 0;\n        x04 = rotl(x04 ^ x09, 7);\n    }\n    let oi = 0;\n    o32[oi++] = x00;\n    o32[oi++] = x01;\n    o32[oi++] = x02;\n    o32[oi++] = x03;\n    o32[oi++] = x12;\n    o32[oi++] = x13;\n    o32[oi++] = x14;\n    o32[oi++] = x15;\n}\n/**\n * Original, non-RFC chacha20 from DJB. 8-byte nonce, 8-byte counter.\n */\nexport const chacha20orig = /* @__PURE__ */ createCipher(chachaCore, {\n    counterRight: false,\n    counterLength: 8,\n    allowShortKeys: true,\n});\n/**\n * ChaCha stream cipher. Conforms to RFC 8439 (IETF, TLS). 12-byte nonce, 4-byte counter.\n * With 12-byte nonce, it's not safe to use fill it with random (CSPRNG), due to collision chance.\n */\nexport const chacha20 = /* @__PURE__ */ createCipher(chachaCore, {\n    counterRight: false,\n    counterLength: 4,\n    allowShortKeys: false,\n});\n/**\n * XChaCha eXtended-nonce ChaCha. 24-byte nonce.\n * With 24-byte nonce, it's safe to use fill it with random (CSPRNG).\n * https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha\n */\nexport const xchacha20 = /* @__PURE__ */ createCipher(chachaCore, {\n    counterRight: false,\n    counterLength: 8,\n    extendNonceFn: hchacha,\n    allowShortKeys: false,\n});\n/**\n * Reduced 8-round chacha, described in original paper.\n */\nexport const chacha8 = /* @__PURE__ */ createCipher(chachaCore, {\n    counterRight: false,\n    counterLength: 4,\n    rounds: 8,\n});\n/**\n * Reduced 12-round chacha, described in original paper.\n */\nexport const chacha12 = /* @__PURE__ */ createCipher(chachaCore, {\n    counterRight: false,\n    counterLength: 4,\n    rounds: 12,\n});\nconst ZEROS16 = /* @__PURE__ */ new Uint8Array(16);\n// Pad to digest size with zeros\nconst updatePadded = (h, msg) => {\n    h.update(msg);\n    const left = msg.length % 16;\n    if (left)\n        h.update(ZEROS16.subarray(left));\n};\nconst ZEROS32 = /* @__PURE__ */ new Uint8Array(32);\nfunction computeTag(fn, key, nonce, data, AAD) {\n    const authKey = fn(key, nonce, ZEROS32);\n    const h = poly1305.create(authKey);\n    if (AAD)\n        updatePadded(h, AAD);\n    updatePadded(h, data);\n    const num = new Uint8Array(16);\n    const view = createView(num);\n    setBigUint64(view, 0, BigInt(AAD ? AAD.length : 0), true);\n    setBigUint64(view, 8, BigInt(data.length), true);\n    h.update(num);\n    const res = h.digest();\n    authKey.fill(0);\n    return res;\n}\n/**\n * AEAD algorithm from RFC 8439.\n * Salsa20 and chacha (RFC 8439) use poly1305 differently.\n * We could have composed them similar to:\n * https://github.com/paulmillr/scure-base/blob/b266c73dde977b1dd7ef40ef7a23cc15aab526b3/index.ts#L250\n * But it's hard because of authKey:\n * In salsa20, authKey changes position in salsa stream.\n * In chacha, authKey can't be computed inside computeTag, it modifies the counter.\n */\nexport const _poly1305_aead = (xorStream) => (key, nonce, AAD) => {\n    const tagLength = 16;\n    abytes(key, 32);\n    abytes(nonce);\n    return {\n        encrypt: (plaintext, output) => {\n            const plength = plaintext.length;\n            const clength = plength + tagLength;\n            if (output) {\n                abytes(output, clength);\n            }\n            else {\n                output = new Uint8Array(clength);\n            }\n            xorStream(key, nonce, plaintext, output, 1);\n            const tag = computeTag(xorStream, key, nonce, output.subarray(0, -tagLength), AAD);\n            output.set(tag, plength); // append tag\n            return output;\n        },\n        decrypt: (ciphertext, output) => {\n            const clength = ciphertext.length;\n            const plength = clength - tagLength;\n            if (clength < tagLength)\n                throw new Error(`encrypted data must be at least ${tagLength} bytes`);\n            if (output) {\n                abytes(output, plength);\n            }\n            else {\n                output = new Uint8Array(plength);\n            }\n            const data = ciphertext.subarray(0, -tagLength);\n            const passedTag = ciphertext.subarray(-tagLength);\n            const tag = computeTag(xorStream, key, nonce, data, AAD);\n            if (!equalBytes(passedTag, tag))\n                throw new Error('invalid tag');\n            xorStream(key, nonce, data, output, 1);\n            return output;\n        },\n    };\n};\n/**\n * ChaCha20-Poly1305 from RFC 8439.\n * With 12-byte nonce, it's not safe to use fill it with random (CSPRNG), due to collision chance.\n */\nexport const chacha20poly1305 = /* @__PURE__ */ wrapCipher({ blockSize: 64, nonceLength: 12, tagLength: 16 }, _poly1305_aead(chacha20));\n/**\n * XChaCha20-Poly1305 extended-nonce chacha.\n * https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha\n * With 24-byte nonce, it's safe to use fill it with random (CSPRNG).\n */\nexport const xchacha20poly1305 = /* @__PURE__ */ wrapCipher({ blockSize: 64, nonceLength: 24, tagLength: 16 }, _poly1305_aead(xchacha20));\n//# sourceMappingURL=chacha.js.map"],"names":["chachaCore","s","k","n","out","cnt","rounds","y00","y01","y02","y03","y04","y05","y06","y07","y08","y09","y10","y11","y12","y13","y14","y15","x00","x01","x02","x03","x04","x05","x06","x07","x08","x09","x10","x11","x12","x13","x14","x15","r","rotl","oi","chacha20","createCipher","counterRight","counterLength","allowShortKeys"],"mappings":"4CAYA,SAASA,WAAWC,EAAGC,EAAGC,EAAGC,EAAKC,EAAKC,EAAS,IAC5C,IAAIC,EAAMN,EAAE,GAAIO,EAAMP,EAAE,GAAIQ,EAAMR,EAAE,GAAIS,EAAMT,EAAE,GAChDU,EAAMT,EAAE,GAAIU,EAAMV,EAAE,GAAIW,EAAMX,EAAE,GAAIY,EAAMZ,EAAE,GAC5Ca,EAAMb,EAAE,GAAIc,EAAMd,EAAE,GAAIe,EAAMf,EAAE,GAAIgB,EAAMhB,EAAE,GAC5CiB,EAAMd,EAAKe,EAAMjB,EAAE,GAAIkB,EAAMlB,EAAE,GAAImB,EAAMnB,EAAE,GAEvCoB,EAAMhB,EAAKiB,EAAMhB,EAAKiB,EAAMhB,EAAKiB,EAAMhB,EAAKiB,EAAMhB,EAAKiB,EAAMhB,EAAKiB,EAAMhB,EAAKiB,EAAMhB,EAAKiB,EAAMhB,EAAKiB,EAAMhB,EAAKiB,EAAMhB,EAAKiB,EAAMhB,EAAKiB,EAAMhB,EAAKiB,EAAMhB,EAAKiB,EAAMhB,EAAKiB,EAAMhB,EAC/K,IAAK,IAAIiB,EAAI,EAAGA,EAAIjC,EAAQiC,GAAK,EAC7BhB,EAAOA,EAAMI,EAAO,EACpBQ,EAAMK,EAAAA,KAAKL,EAAMZ,EAAK,IACtBQ,EAAOA,EAAMI,EAAO,EACpBR,EAAMa,EAAAA,KAAKb,EAAMI,EAAK,IACtBR,EAAOA,EAAMI,EAAO,EACpBQ,EAAMK,EAAAA,KAAKL,EAAMZ,EAAK,GACtBQ,EAAOA,EAAMI,EAAO,EACpBR,EAAMa,EAAAA,KAAKb,EAAMI,EAAK,GACtBP,EAAOA,EAAMI,EAAO,EACpBQ,EAAMI,EAAAA,KAAKJ,EAAMZ,EAAK,IACtBQ,EAAOA,EAAMI,EAAO,EACpBR,EAAMY,EAAAA,KAAKZ,EAAMI,EAAK,IACtBR,EAAOA,EAAMI,EAAO,EACpBQ,EAAMI,EAAAA,KAAKJ,EAAMZ,EAAK,GACtBQ,EAAOA,EAAMI,EAAO,EACpBR,EAAMY,EAAAA,KAAKZ,EAAMI,EAAK,GACtBP,EAAOA,EAAMI,EAAO,EACpBQ,EAAMG,EAAAA,KAAKH,EAAMZ,EAAK,IACtBQ,EAAOA,EAAMI,EAAO,EACpBR,EAAMW,EAAAA,KAAKX,EAAMI,EAAK,IACtBR,EAAOA,EAAMI,EAAO,EACpBQ,EAAMG,EAAAA,KAAKH,EAAMZ,EAAK,GACtBQ,EAAOA,EAAMI,EAAO,EACpBR,EAAMW,EAAAA,KAAKX,EAAMI,EAAK,GACtBP,EAAOA,EAAMI,EAAO,EACpBQ,EAAME,EAAAA,KAAKF,EAAMZ,EAAK,IACtBQ,EAAOA,EAAMI,EAAO,EACpBR,EAAMU,EAAAA,KAAKV,EAAMI,EAAK,IACtBR,EAAOA,EAAMI,EAAO,EACpBQ,EAAME,EAAAA,KAAKF,EAAMZ,EAAK,GACtBQ,EAAOA,EAAMI,EAAO,EACpBR,EAAMU,EAAAA,KAAKV,EAAMI,EAAK,GACtBX,EAAOA,EAAMK,EAAO,EACpBU,EAAME,EAAAA,KAAKF,EAAMf,EAAK,IACtBU,EAAOA,EAAMK,EAAO,EACpBV,EAAMY,EAAAA,KAAKZ,EAAMK,EAAK,IACtBV,EAAOA,EAAMK,EAAO,EACpBU,EAAME,EAAAA,KAAKF,EAAMf,EAAK,GACtBU,EAAOA,EAAMK,EAAO,EACpBV,EAAMY,EAAAA,KAAKZ,EAAMK,EAAK,GACtBT,EAAOA,EAAMK,EAAO,EACpBM,EAAMK,EAAAA,KAAKL,EAAMX,EAAK,IACtBU,EAAOA,EAAMC,EAAO,EACpBN,EAAMW,EAAAA,KAAKX,EAAMK,EAAK,IACtBV,EAAOA,EAAMK,EAAO,EACpBM,EAAMK,EAAAA,KAAKL,EAAMX,EAAK,GACtBU,EAAOA,EAAMC,EAAO,EACpBN,EAAMW,EAAAA,KAAKX,EAAMK,EAAK,GACtBT,EAAOA,EAAMK,EAAO,EACpBM,EAAMI,EAAAA,KAAKJ,EAAMX,EAAK,IACtBM,EAAOA,EAAMK,EAAO,EACpBN,EAAMU,EAAAA,KAAKV,EAAMC,EAAK,IACtBN,EAAOA,EAAMK,EAAO,EACpBM,EAAMI,EAAAA,KAAKJ,EAAMX,EAAK,GACtBM,EAAOA,EAAMK,EAAO,EACpBN,EAAMU,EAAAA,KAAKV,EAAMC,EAAK,GACtBL,EAAOA,EAAMC,EAAO,EACpBU,EAAMG,EAAAA,KAAKH,EAAMX,EAAK,IACtBM,EAAOA,EAAMK,EAAO,EACpBV,EAAMa,EAAAA,KAAKb,EAAMK,EAAK,IACtBN,EAAOA,EAAMC,EAAO,EACpBU,EAAMG,EAAAA,KAAKH,EAAMX,EAAK,GACtBM,EAAOA,EAAMK,EAAO,EACpBV,EAAMa,EAAAA,KAAKb,EAAMK,EAAK,GAG1B,IAAIS,EAAK,EACTrC,EAAIqC,KAASlC,EAAMgB,EAAO,EAC1BnB,EAAIqC,KAASjC,EAAMgB,EAAO,EAC1BpB,EAAIqC,KAAShC,EAAMgB,EAAO,EAC1BrB,EAAIqC,KAAS/B,EAAMgB,EAAO,EAC1BtB,EAAIqC,KAAS9B,EAAMgB,EAAO,EAC1BvB,EAAIqC,KAAS7B,EAAMgB,EAAO,EAC1BxB,EAAIqC,KAAS5B,EAAMgB,EAAO,EAC1BzB,EAAIqC,KAAS3B,EAAMgB,EAAO,EAC1B1B,EAAIqC,KAAS1B,EAAMgB,EAAO,EAC1B3B,EAAIqC,KAASzB,EAAMgB,EAAO,EAC1B5B,EAAIqC,KAASxB,EAAMgB,EAAO,EAC1B7B,EAAIqC,KAASvB,EAAMgB,EAAO,EAC1B9B,EAAIqC,KAAStB,EAAMgB,EAAO,EAC1B/B,EAAIqC,KAASrB,EAAMgB,EAAO,EAC1BhC,EAAIqC,KAASpB,EAAMgB,EAAO,EAC1BjC,EAAIqC,KAASnB,EAAMgB,EAAO,CAC9B,CAkGY,MAACI,EAA2BC,EAAAA,aAAa3C,WAAY,CAC7D4C,cAAc,EACdC,cAAe,EACfC,gBAAgB","x_google_ignoreList":[0]}

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/chacha.esm.js

@@ -0,0 +1,2 @@
+import{createCipher as o,rotl as t}from"./_arx.esm.js";function chachaCore(o,e,r,c,h,a=20){let n=o[0],l=o[1],s=o[2],f=o[3],i=e[0],m=e[1],u=e[2],g=e[3],p=e[4],x=e[5],C=e[6],j=e[7],w=h,y=r[0],K=r[1],L=r[2],R=n,S=l,_=s,b=f,d=i,k=m,q=u,v=g,z=p,A=x,B=C,D=j,E=w,F=y,G=K,H=L;for(let o=0;o<a;o+=2)R=R+d|0,E=t(E^R,16),z=z+E|0,d=t(d^z,12),R=R+d|0,E=t(E^R,8),z=z+E|0,d=t(d^z,7),S=S+k|0,F=t(F^S,16),A=A+F|0,k=t(k^A,12),S=S+k|0,F=t(F^S,8),A=A+F|0,k=t(k^A,7),_=_+q|0,G=t(G^_,16),B=B+G|0,q=t(q^B,12),_=_+q|0,G=t(G^_,8),B=B+G|0,q=t(q^B,7),b=b+v|0,H=t(H^b,16),D=D+H|0,v=t(v^D,12),b=b+v|0,H=t(H^b,8),D=D+H|0,v=t(v^D,7),R=R+k|0,H=t(H^R,16),B=B+H|0,k=t(k^B,12),R=R+k|0,H=t(H^R,8),B=B+H|0,k=t(k^B,7),S=S+q|0,E=t(E^S,16),D=D+E|0,q=t(q^D,12),S=S+q|0,E=t(E^S,8),D=D+E|0,q=t(q^D,7),_=_+v|0,F=t(F^_,16),z=z+F|0,v=t(v^z,12),_=_+v|0,F=t(F^_,8),z=z+F|0,v=t(v^z,7),b=b+d|0,G=t(G^b,16),A=A+G|0,d=t(d^A,12),b=b+d|0,G=t(G^b,8),A=A+G|0,d=t(d^A,7);let I=0;c[I++]=n+R|0,c[I++]=l+S|0,c[I++]=s+_|0,c[I++]=f+b|0,c[I++]=i+d|0,c[I++]=m+k|0,c[I++]=u+q|0,c[I++]=g+v|0,c[I++]=p+z|0,c[I++]=x+A|0,c[I++]=C+B|0,c[I++]=j+D|0,c[I++]=w+E|0,c[I++]=y+F|0,c[I++]=K+G|0,c[I++]=L+H|0}const e=o(chachaCore,{counterRight:!1,counterLength:4,allowShortKeys:!1});export{e as chacha20};
+//# sourceMappingURL=chacha.esm.js.map

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/chacha.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chacha.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+ciphers@0.5.3/node_modules/@noble/ciphers/esm/chacha.js"],"sourcesContent":["// prettier-ignore\nimport { wrapCipher, createView, equalBytes, setBigUint64, } from './utils.js';\nimport { poly1305 } from './_poly1305.js';\nimport { createCipher, rotl } from './_arx.js';\nimport { bytes as abytes } from './_assert.js';\n// ChaCha20 stream cipher was released in 2008. ChaCha aims to increase\n// the diffusion per round, but had slightly less cryptanalysis.\n// https://cr.yp.to/chacha.html, http://cr.yp.to/chacha/chacha-20080128.pdf\n/**\n * ChaCha core function.\n */\n// prettier-ignore\nfunction chachaCore(s, k, n, out, cnt, rounds = 20) {\n    let y00 = s[0], y01 = s[1], y02 = s[2], y03 = s[3], // \"expa\"   \"nd 3\"  \"2-by\"  \"te k\"\n    y04 = k[0], y05 = k[1], y06 = k[2], y07 = k[3], // Key      Key     Key     Key\n    y08 = k[4], y09 = k[5], y10 = k[6], y11 = k[7], // Key      Key     Key     Key\n    y12 = cnt, y13 = n[0], y14 = n[1], y15 = n[2]; // Counter  Counter\tNonce   Nonce\n    // Save state to temporary variables\n    let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;\n    for (let r = 0; r < rounds; r += 2) {\n        x00 = (x00 + x04) | 0;\n        x12 = rotl(x12 ^ x00, 16);\n        x08 = (x08 + x12) | 0;\n        x04 = rotl(x04 ^ x08, 12);\n        x00 = (x00 + x04) | 0;\n        x12 = rotl(x12 ^ x00, 8);\n        x08 = (x08 + x12) | 0;\n        x04 = rotl(x04 ^ x08, 7);\n        x01 = (x01 + x05) | 0;\n        x13 = rotl(x13 ^ x01, 16);\n        x09 = (x09 + x13) | 0;\n        x05 = rotl(x05 ^ x09, 12);\n        x01 = (x01 + x05) | 0;\n        x13 = rotl(x13 ^ x01, 8);\n        x09 = (x09 + x13) | 0;\n        x05 = rotl(x05 ^ x09, 7);\n        x02 = (x02 + x06) | 0;\n        x14 = rotl(x14 ^ x02, 16);\n        x10 = (x10 + x14) | 0;\n        x06 = rotl(x06 ^ x10, 12);\n        x02 = (x02 + x06) | 0;\n        x14 = rotl(x14 ^ x02, 8);\n        x10 = (x10 + x14) | 0;\n        x06 = rotl(x06 ^ x10, 7);\n        x03 = (x03 + x07) | 0;\n        x15 = rotl(x15 ^ x03, 16);\n        x11 = (x11 + x15) | 0;\n        x07 = rotl(x07 ^ x11, 12);\n        x03 = (x03 + x07) | 0;\n        x15 = rotl(x15 ^ x03, 8);\n        x11 = (x11 + x15) | 0;\n        x07 = rotl(x07 ^ x11, 7);\n        x00 = (x00 + x05) | 0;\n        x15 = rotl(x15 ^ x00, 16);\n        x10 = (x10 + x15) | 0;\n        x05 = rotl(x05 ^ x10, 12);\n        x00 = (x00 + x05) | 0;\n        x15 = rotl(x15 ^ x00, 8);\n        x10 = (x10 + x15) | 0;\n        x05 = rotl(x05 ^ x10, 7);\n        x01 = (x01 + x06) | 0;\n        x12 = rotl(x12 ^ x01, 16);\n        x11 = (x11 + x12) | 0;\n        x06 = rotl(x06 ^ x11, 12);\n        x01 = (x01 + x06) | 0;\n        x12 = rotl(x12 ^ x01, 8);\n        x11 = (x11 + x12) | 0;\n        x06 = rotl(x06 ^ x11, 7);\n        x02 = (x02 + x07) | 0;\n        x13 = rotl(x13 ^ x02, 16);\n        x08 = (x08 + x13) | 0;\n        x07 = rotl(x07 ^ x08, 12);\n        x02 = (x02 + x07) | 0;\n        x13 = rotl(x13 ^ x02, 8);\n        x08 = (x08 + x13) | 0;\n        x07 = rotl(x07 ^ x08, 7);\n        x03 = (x03 + x04) | 0;\n        x14 = rotl(x14 ^ x03, 16);\n        x09 = (x09 + x14) | 0;\n        x04 = rotl(x04 ^ x09, 12);\n        x03 = (x03 + x04) | 0;\n        x14 = rotl(x14 ^ x03, 8);\n        x09 = (x09 + x14) | 0;\n        x04 = rotl(x04 ^ x09, 7);\n    }\n    // Write output\n    let oi = 0;\n    out[oi++] = (y00 + x00) | 0;\n    out[oi++] = (y01 + x01) | 0;\n    out[oi++] = (y02 + x02) | 0;\n    out[oi++] = (y03 + x03) | 0;\n    out[oi++] = (y04 + x04) | 0;\n    out[oi++] = (y05 + x05) | 0;\n    out[oi++] = (y06 + x06) | 0;\n    out[oi++] = (y07 + x07) | 0;\n    out[oi++] = (y08 + x08) | 0;\n    out[oi++] = (y09 + x09) | 0;\n    out[oi++] = (y10 + x10) | 0;\n    out[oi++] = (y11 + x11) | 0;\n    out[oi++] = (y12 + x12) | 0;\n    out[oi++] = (y13 + x13) | 0;\n    out[oi++] = (y14 + x14) | 0;\n    out[oi++] = (y15 + x15) | 0;\n}\n/**\n * hchacha helper method, used primarily in xchacha, to hash\n * key and nonce into key' and nonce'.\n * Same as chachaCore, but there doesn't seem to be a way to move the block\n * out without 25% performance hit.\n */\n// prettier-ignore\nexport function hchacha(s, k, i, o32) {\n    let x00 = s[0], x01 = s[1], x02 = s[2], x03 = s[3], x04 = k[0], x05 = k[1], x06 = k[2], x07 = k[3], x08 = k[4], x09 = k[5], x10 = k[6], x11 = k[7], x12 = i[0], x13 = i[1], x14 = i[2], x15 = i[3];\n    for (let r = 0; r < 20; r += 2) {\n        x00 = (x00 + x04) | 0;\n        x12 = rotl(x12 ^ x00, 16);\n        x08 = (x08 + x12) | 0;\n        x04 = rotl(x04 ^ x08, 12);\n        x00 = (x00 + x04) | 0;\n        x12 = rotl(x12 ^ x00, 8);\n        x08 = (x08 + x12) | 0;\n        x04 = rotl(x04 ^ x08, 7);\n        x01 = (x01 + x05) | 0;\n        x13 = rotl(x13 ^ x01, 16);\n        x09 = (x09 + x13) | 0;\n        x05 = rotl(x05 ^ x09, 12);\n        x01 = (x01 + x05) | 0;\n        x13 = rotl(x13 ^ x01, 8);\n        x09 = (x09 + x13) | 0;\n        x05 = rotl(x05 ^ x09, 7);\n        x02 = (x02 + x06) | 0;\n        x14 = rotl(x14 ^ x02, 16);\n        x10 = (x10 + x14) | 0;\n        x06 = rotl(x06 ^ x10, 12);\n        x02 = (x02 + x06) | 0;\n        x14 = rotl(x14 ^ x02, 8);\n        x10 = (x10 + x14) | 0;\n        x06 = rotl(x06 ^ x10, 7);\n        x03 = (x03 + x07) | 0;\n        x15 = rotl(x15 ^ x03, 16);\n        x11 = (x11 + x15) | 0;\n        x07 = rotl(x07 ^ x11, 12);\n        x03 = (x03 + x07) | 0;\n        x15 = rotl(x15 ^ x03, 8);\n        x11 = (x11 + x15) | 0;\n        x07 = rotl(x07 ^ x11, 7);\n        x00 = (x00 + x05) | 0;\n        x15 = rotl(x15 ^ x00, 16);\n        x10 = (x10 + x15) | 0;\n        x05 = rotl(x05 ^ x10, 12);\n        x00 = (x00 + x05) | 0;\n        x15 = rotl(x15 ^ x00, 8);\n        x10 = (x10 + x15) | 0;\n        x05 = rotl(x05 ^ x10, 7);\n        x01 = (x01 + x06) | 0;\n        x12 = rotl(x12 ^ x01, 16);\n        x11 = (x11 + x12) | 0;\n        x06 = rotl(x06 ^ x11, 12);\n        x01 = (x01 + x06) | 0;\n        x12 = rotl(x12 ^ x01, 8);\n        x11 = (x11 + x12) | 0;\n        x06 = rotl(x06 ^ x11, 7);\n        x02 = (x02 + x07) | 0;\n        x13 = rotl(x13 ^ x02, 16);\n        x08 = (x08 + x13) | 0;\n        x07 = rotl(x07 ^ x08, 12);\n        x02 = (x02 + x07) | 0;\n        x13 = rotl(x13 ^ x02, 8);\n        x08 = (x08 + x13) | 0;\n        x07 = rotl(x07 ^ x08, 7);\n        x03 = (x03 + x04) | 0;\n        x14 = rotl(x14 ^ x03, 16);\n        x09 = (x09 + x14) | 0;\n        x04 = rotl(x04 ^ x09, 12);\n        x03 = (x03 + x04) | 0;\n        x14 = rotl(x14 ^ x03, 8);\n        x09 = (x09 + x14) | 0;\n        x04 = rotl(x04 ^ x09, 7);\n    }\n    let oi = 0;\n    o32[oi++] = x00;\n    o32[oi++] = x01;\n    o32[oi++] = x02;\n    o32[oi++] = x03;\n    o32[oi++] = x12;\n    o32[oi++] = x13;\n    o32[oi++] = x14;\n    o32[oi++] = x15;\n}\n/**\n * Original, non-RFC chacha20 from DJB. 8-byte nonce, 8-byte counter.\n */\nexport const chacha20orig = /* @__PURE__ */ createCipher(chachaCore, {\n    counterRight: false,\n    counterLength: 8,\n    allowShortKeys: true,\n});\n/**\n * ChaCha stream cipher. Conforms to RFC 8439 (IETF, TLS). 12-byte nonce, 4-byte counter.\n * With 12-byte nonce, it's not safe to use fill it with random (CSPRNG), due to collision chance.\n */\nexport const chacha20 = /* @__PURE__ */ createCipher(chachaCore, {\n    counterRight: false,\n    counterLength: 4,\n    allowShortKeys: false,\n});\n/**\n * XChaCha eXtended-nonce ChaCha. 24-byte nonce.\n * With 24-byte nonce, it's safe to use fill it with random (CSPRNG).\n * https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha\n */\nexport const xchacha20 = /* @__PURE__ */ createCipher(chachaCore, {\n    counterRight: false,\n    counterLength: 8,\n    extendNonceFn: hchacha,\n    allowShortKeys: false,\n});\n/**\n * Reduced 8-round chacha, described in original paper.\n */\nexport const chacha8 = /* @__PURE__ */ createCipher(chachaCore, {\n    counterRight: false,\n    counterLength: 4,\n    rounds: 8,\n});\n/**\n * Reduced 12-round chacha, described in original paper.\n */\nexport const chacha12 = /* @__PURE__ */ createCipher(chachaCore, {\n    counterRight: false,\n    counterLength: 4,\n    rounds: 12,\n});\nconst ZEROS16 = /* @__PURE__ */ new Uint8Array(16);\n// Pad to digest size with zeros\nconst updatePadded = (h, msg) => {\n    h.update(msg);\n    const left = msg.length % 16;\n    if (left)\n        h.update(ZEROS16.subarray(left));\n};\nconst ZEROS32 = /* @__PURE__ */ new Uint8Array(32);\nfunction computeTag(fn, key, nonce, data, AAD) {\n    const authKey = fn(key, nonce, ZEROS32);\n    const h = poly1305.create(authKey);\n    if (AAD)\n        updatePadded(h, AAD);\n    updatePadded(h, data);\n    const num = new Uint8Array(16);\n    const view = createView(num);\n    setBigUint64(view, 0, BigInt(AAD ? AAD.length : 0), true);\n    setBigUint64(view, 8, BigInt(data.length), true);\n    h.update(num);\n    const res = h.digest();\n    authKey.fill(0);\n    return res;\n}\n/**\n * AEAD algorithm from RFC 8439.\n * Salsa20 and chacha (RFC 8439) use poly1305 differently.\n * We could have composed them similar to:\n * https://github.com/paulmillr/scure-base/blob/b266c73dde977b1dd7ef40ef7a23cc15aab526b3/index.ts#L250\n * But it's hard because of authKey:\n * In salsa20, authKey changes position in salsa stream.\n * In chacha, authKey can't be computed inside computeTag, it modifies the counter.\n */\nexport const _poly1305_aead = (xorStream) => (key, nonce, AAD) => {\n    const tagLength = 16;\n    abytes(key, 32);\n    abytes(nonce);\n    return {\n        encrypt: (plaintext, output) => {\n            const plength = plaintext.length;\n            const clength = plength + tagLength;\n            if (output) {\n                abytes(output, clength);\n            }\n            else {\n                output = new Uint8Array(clength);\n            }\n            xorStream(key, nonce, plaintext, output, 1);\n            const tag = computeTag(xorStream, key, nonce, output.subarray(0, -tagLength), AAD);\n            output.set(tag, plength); // append tag\n            return output;\n        },\n        decrypt: (ciphertext, output) => {\n            const clength = ciphertext.length;\n            const plength = clength - tagLength;\n            if (clength < tagLength)\n                throw new Error(`encrypted data must be at least ${tagLength} bytes`);\n            if (output) {\n                abytes(output, plength);\n            }\n            else {\n                output = new Uint8Array(plength);\n            }\n            const data = ciphertext.subarray(0, -tagLength);\n            const passedTag = ciphertext.subarray(-tagLength);\n            const tag = computeTag(xorStream, key, nonce, data, AAD);\n            if (!equalBytes(passedTag, tag))\n                throw new Error('invalid tag');\n            xorStream(key, nonce, data, output, 1);\n            return output;\n        },\n    };\n};\n/**\n * ChaCha20-Poly1305 from RFC 8439.\n * With 12-byte nonce, it's not safe to use fill it with random (CSPRNG), due to collision chance.\n */\nexport const chacha20poly1305 = /* @__PURE__ */ wrapCipher({ blockSize: 64, nonceLength: 12, tagLength: 16 }, _poly1305_aead(chacha20));\n/**\n * XChaCha20-Poly1305 extended-nonce chacha.\n * https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha\n * With 24-byte nonce, it's safe to use fill it with random (CSPRNG).\n */\nexport const xchacha20poly1305 = /* @__PURE__ */ wrapCipher({ blockSize: 64, nonceLength: 24, tagLength: 16 }, _poly1305_aead(xchacha20));\n//# sourceMappingURL=chacha.js.map"],"names":["chachaCore","s","k","n","out","cnt","rounds","y00","y01","y02","y03","y04","y05","y06","y07","y08","y09","y10","y11","y12","y13","y14","y15","x00","x01","x02","x03","x04","x05","x06","x07","x08","x09","x10","x11","x12","x13","x14","x15","r","rotl","oi","chacha20","createCipher","counterRight","counterLength","allowShortKeys"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/utils.cjs.js

@@ -0,0 +1,3 @@
+"use strict";
+/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */const e=68===new Uint8Array(new Uint32Array([287454020]).buffer)[0];if(!e)throw new Error("Non little-endian hardware is not supported");exports.checkOpts=function checkOpts(e,t){if(null==t||"object"!=typeof t)throw new Error("options must be defined");return Object.assign(e,t)},exports.equalBytes=function equalBytes(e,t){if(e.length!==t.length)return!1;let r=0;for(let n=0;n<e.length;n++)r|=e[n]^t[n];return 0===r},exports.isLE=e,exports.u32=e=>new Uint32Array(e.buffer,e.byteOffset,Math.floor(e.byteLength/4)),exports.wrapCipher=(e,t)=>(Object.assign(t,e),t);
+//# sourceMappingURL=utils.cjs.js.map

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/utils.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+ciphers@0.5.3/node_modules/@noble/ciphers/esm/utils.js"],"sourcesContent":["/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */\nimport { bytes as abytes, isBytes } from './_assert.js';\n// Cast array to different type\nexport const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexport const u16 = (arr) => new Uint16Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 2));\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// big-endian hardware is rare. Just in case someone still decides to run ciphers:\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');\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}\nexport function hexToNumber(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    // Big Endian\n    return BigInt(hex === '' ? '0' : `0x${hex}`);\n}\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes) {\n    return hexToNumber(bytesToHex(bytes));\n}\nexport function numberToBytesBE(n, len) {\n    return hexToBytes(n.toString(16).padStart(len * 2, '0'));\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(`string expected, got ${typeof str}`);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * @example bytesToUtf8(new Uint8Array([97, 98, 99])) // 'abc'\n */\nexport function bytesToUtf8(bytes) {\n    return new TextDecoder().decode(bytes);\n}\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    else if (isBytes(data))\n        data = data.slice();\n    else\n        throw new Error(`Uint8Array expected, got ${typeof 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}\nexport function checkOpts(defaults, opts) {\n    if (opts == null || typeof opts !== 'object')\n        throw new Error('options must be defined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\n// Compares 2 u8a-s in kinda constant time\nexport function equalBytes(a, b) {\n    if (a.length !== b.length)\n        return false;\n    let diff = 0;\n    for (let i = 0; i < a.length; i++)\n        diff |= a[i] ^ b[i];\n    return diff === 0;\n}\n// For runtime check if class implements interface\nexport class Hash {\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nexport const wrapCipher = (params, c) => {\n    Object.assign(c, params);\n    return c;\n};\n// Polyfill for Safari 14\nexport function setBigUint64(view, byteOffset, value, isLE) {\n    if (typeof view.setBigUint64 === 'function')\n        return view.setBigUint64(byteOffset, value, isLE);\n    const _32n = BigInt(32);\n    const _u32_max = BigInt(0xffffffff);\n    const wh = Number((value >> _32n) & _u32_max);\n    const wl = Number(value & _u32_max);\n    const h = isLE ? 4 : 0;\n    const l = isLE ? 0 : 4;\n    view.setUint32(byteOffset + h, wh, isLE);\n    view.setUint32(byteOffset + l, wl, isLE);\n}\nexport function u64Lengths(ciphertext, AAD) {\n    const num = new Uint8Array(16);\n    const view = createView(num);\n    setBigUint64(view, 0, BigInt(AAD ? AAD.length : 0), true);\n    setBigUint64(view, 8, BigInt(ciphertext.length), true);\n    return num;\n}\n//# sourceMappingURL=utils.js.map"],"names":["isLE","Uint8Array","Uint32Array","buffer","Error","checkOpts","defaults","opts","Object","assign","equalBytes","a","b","length","diff","i","arr","byteOffset","Math","floor","byteLength","params","c"],"mappings":";uEAKY,MAKCA,EAAmE,KAA5D,IAAIC,WAAW,IAAIC,YAAY,CAAC,YAAaC,QAAQ,GACzE,IAAKH,EACD,MAAM,IAAII,MAAM,iEA4Hb,SAASC,UAAUC,EAAUC,GAChC,GAAY,MAARA,GAAgC,iBAATA,EACvB,MAAM,IAAIH,MAAM,2BAEpB,OADeI,OAAOC,OAAOH,EAAUC,EAE3C,qBAEO,SAASG,WAAWC,EAAGC,GAC1B,GAAID,EAAEE,SAAWD,EAAEC,OACf,OAAO,EACX,IAAIC,EAAO,EACX,IAAK,IAAIC,EAAI,EAAGA,EAAIJ,EAAEE,OAAQE,IAC1BD,GAAQH,EAAEI,GAAKH,EAAEG,GACrB,OAAgB,IAATD,CACX,6BAjJoBE,GAAQ,IAAId,YAAYc,EAAIb,OAAQa,EAAIC,WAAYC,KAAKC,MAAMH,EAAII,WAAa,uBAwJ1E,CAACC,EAAQC,KAC/Bd,OAAOC,OAAOa,EAAGD,GACVC","x_google_ignoreList":[0]}

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/utils.esm.js

@@ -0,0 +1,3 @@
+/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
+const u32=e=>new Uint32Array(e.buffer,e.byteOffset,Math.floor(e.byteLength/4)),e=68===new Uint8Array(new Uint32Array([287454020]).buffer)[0];if(!e)throw new Error("Non little-endian hardware is not supported");function checkOpts(e,t){if(null==t||"object"!=typeof t)throw new Error("options must be defined");return Object.assign(e,t)}function equalBytes(e,t){if(e.length!==t.length)return!1;let n=0;for(let r=0;r<e.length;r++)n|=e[r]^t[r];return 0===n}const wrapCipher=(e,t)=>(Object.assign(t,e),t);export{checkOpts,equalBytes,e as isLE,u32,wrapCipher};
+//# sourceMappingURL=utils.esm.js.map

package/dist/server/node_modules/.pnpm/@noble_ciphers@0.5.3/node_modules/@noble/ciphers/esm/utils.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+ciphers@0.5.3/node_modules/@noble/ciphers/esm/utils.js"],"sourcesContent":["/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */\nimport { bytes as abytes, isBytes } from './_assert.js';\n// Cast array to different type\nexport const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexport const u16 = (arr) => new Uint16Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 2));\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// big-endian hardware is rare. Just in case someone still decides to run ciphers:\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');\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}\nexport function hexToNumber(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    // Big Endian\n    return BigInt(hex === '' ? '0' : `0x${hex}`);\n}\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes) {\n    return hexToNumber(bytesToHex(bytes));\n}\nexport function numberToBytesBE(n, len) {\n    return hexToBytes(n.toString(16).padStart(len * 2, '0'));\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(`string expected, got ${typeof str}`);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * @example bytesToUtf8(new Uint8Array([97, 98, 99])) // 'abc'\n */\nexport function bytesToUtf8(bytes) {\n    return new TextDecoder().decode(bytes);\n}\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    else if (isBytes(data))\n        data = data.slice();\n    else\n        throw new Error(`Uint8Array expected, got ${typeof 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}\nexport function checkOpts(defaults, opts) {\n    if (opts == null || typeof opts !== 'object')\n        throw new Error('options must be defined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\n// Compares 2 u8a-s in kinda constant time\nexport function equalBytes(a, b) {\n    if (a.length !== b.length)\n        return false;\n    let diff = 0;\n    for (let i = 0; i < a.length; i++)\n        diff |= a[i] ^ b[i];\n    return diff === 0;\n}\n// For runtime check if class implements interface\nexport class Hash {\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nexport const wrapCipher = (params, c) => {\n    Object.assign(c, params);\n    return c;\n};\n// Polyfill for Safari 14\nexport function setBigUint64(view, byteOffset, value, isLE) {\n    if (typeof view.setBigUint64 === 'function')\n        return view.setBigUint64(byteOffset, value, isLE);\n    const _32n = BigInt(32);\n    const _u32_max = BigInt(0xffffffff);\n    const wh = Number((value >> _32n) & _u32_max);\n    const wl = Number(value & _u32_max);\n    const h = isLE ? 4 : 0;\n    const l = isLE ? 0 : 4;\n    view.setUint32(byteOffset + h, wh, isLE);\n    view.setUint32(byteOffset + l, wl, isLE);\n}\nexport function u64Lengths(ciphertext, AAD) {\n    const num = new Uint8Array(16);\n    const view = createView(num);\n    setBigUint64(view, 0, BigInt(AAD ? AAD.length : 0), true);\n    setBigUint64(view, 8, BigInt(ciphertext.length), true);\n    return num;\n}\n//# sourceMappingURL=utils.js.map"],"names":["u32","arr","Uint32Array","buffer","byteOffset","Math","floor","byteLength","isLE","Uint8Array","Error","checkOpts","defaults","opts","Object","assign","equalBytes","a","b","length","diff","i","wrapCipher","params","c"],"mappings":";AAKY,MAACA,IAAOC,GAAQ,IAAIC,YAAYD,EAAIE,OAAQF,EAAIG,WAAYC,KAAKC,MAAML,EAAIM,WAAa,IAKvFC,EAAmE,KAA5D,IAAIC,WAAW,IAAIP,YAAY,CAAC,YAAaC,QAAQ,GACzE,IAAKK,EACD,MAAM,IAAIE,MAAM,+CA4Hb,SAASC,UAAUC,EAAUC,GAChC,GAAY,MAARA,GAAgC,iBAATA,EACvB,MAAM,IAAIH,MAAM,2BAEpB,OADeI,OAAOC,OAAOH,EAAUC,EAE3C,CAEO,SAASG,WAAWC,EAAGC,GAC1B,GAAID,EAAEE,SAAWD,EAAEC,OACf,OAAO,EACX,IAAIC,EAAO,EACX,IAAK,IAAIC,EAAI,EAAGA,EAAIJ,EAAEE,OAAQE,IAC1BD,GAAQH,EAAEI,GAAKH,EAAEG,GACrB,OAAgB,IAATD,CACX,CAOY,MAACE,WAAa,CAACC,EAAQC,KAC/BV,OAAOC,OAAOS,EAAGD,GACVC","x_google_ignoreList":[0]}

package/dist/server/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/_shortw_utils.cjs.js

@@ -0,0 +1,4 @@
+"use strict";var e=require("../../../../../@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/hmac.cjs.js"),s=require("../../../../../@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/utils.cjs.js"),r=require("./abstract/weierstrass.cjs.js");
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function getHash(r){return{hash:r,hmac:(t,...a)=>e.hmac(r,t,s.concatBytes(...a)),randomBytes:s.randomBytes}}exports.createCurve=function createCurve(e,s){const create=s=>r.weierstrass({...e,...getHash(s)});return Object.freeze({...create(s),create:create})},exports.getHash=getHash;
+//# sourceMappingURL=_shortw_utils.cjs.js.map

package/dist/server/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/_shortw_utils.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_shortw_utils.cjs.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+curves@1.2.0/node_modules/@noble/curves/esm/_shortw_utils.js"],"sourcesContent":["/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { hmac } from '@noble/hashes/hmac';\nimport { concatBytes, randomBytes } from '@noble/hashes/utils';\nimport { weierstrass } from './abstract/weierstrass.js';\n// connects noble-curves to noble-hashes\nexport function getHash(hash) {\n    return {\n        hash,\n        hmac: (key, ...msgs) => hmac(hash, key, concatBytes(...msgs)),\n        randomBytes,\n    };\n}\nexport function createCurve(curveDef, defHash) {\n    const create = (hash) => weierstrass({ ...curveDef, ...getHash(hash) });\n    return Object.freeze({ ...create(defHash), create });\n}\n//# sourceMappingURL=_shortw_utils.js.map"],"names":["getHash","hash","hmac","key","msgs","concatBytes","randomBytes","createCurve","curveDef","defHash","create","weierstrass","Object","freeze"],"mappings":";;AAKO,SAASA,QAAQC,GACpB,MAAO,CACHA,OACAC,KAAM,CAACC,KAAQC,IAASF,EAAAA,KAAKD,EAAME,EAAKE,EAAAA,eAAeD,IAC/DE,YAAQA,EAAAA,YAER,qBACO,SAASC,YAAYC,EAAUC,GAClC,MAAMC,OAAUT,GAASU,cAAY,IAAKH,KAAaR,QAAQC,KAC/D,OAAOW,OAAOC,OAAO,IAAKH,OAAOD,GAAUC,eAC/C","x_google_ignoreList":[0]}

package/dist/server/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/_shortw_utils.esm.js

@@ -0,0 +1,4 @@
+import{hmac as e}from"../../../../../@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/hmac.esm.js";import{randomBytes as s,concatBytes as r}from"../../../../../@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/utils.esm.js";import{weierstrass as t}from"./abstract/weierstrass.esm.js";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function getHash(t){return{hash:t,hmac:(s,...o)=>e(t,s,r(...o)),randomBytes:s}}function createCurve(e,s){const create=s=>t({...e,...getHash(s)});return Object.freeze({...create(s),create:create})}export{createCurve,getHash};
+//# sourceMappingURL=_shortw_utils.esm.js.map

package/dist/server/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/_shortw_utils.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_shortw_utils.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+curves@1.2.0/node_modules/@noble/curves/esm/_shortw_utils.js"],"sourcesContent":["/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { hmac } from '@noble/hashes/hmac';\nimport { concatBytes, randomBytes } from '@noble/hashes/utils';\nimport { weierstrass } from './abstract/weierstrass.js';\n// connects noble-curves to noble-hashes\nexport function getHash(hash) {\n    return {\n        hash,\n        hmac: (key, ...msgs) => hmac(hash, key, concatBytes(...msgs)),\n        randomBytes,\n    };\n}\nexport function createCurve(curveDef, defHash) {\n    const create = (hash) => weierstrass({ ...curveDef, ...getHash(hash) });\n    return Object.freeze({ ...create(defHash), create });\n}\n//# sourceMappingURL=_shortw_utils.js.map"],"names":["getHash","hash","hmac","key","msgs","concatBytes","randomBytes","createCurve","curveDef","defHash","create","weierstrass","Object","freeze"],"mappings":";;AAKO,SAASA,QAAQC,GACpB,MAAO,CACHA,OACAC,KAAM,CAACC,KAAQC,IAASF,EAAKD,EAAME,EAAKE,KAAeD,IACvDE,cAER,CACO,SAASC,YAAYC,EAAUC,GAClC,MAAMC,OAAUT,GAASU,EAAY,IAAKH,KAAaR,QAAQC,KAC/D,OAAOW,OAAOC,OAAO,IAAKH,OAAOD,GAAUC,eAC/C","x_google_ignoreList":[0]}

package/dist/server/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/abstract/curve.cjs.js

@@ -0,0 +1,4 @@
+"use strict";var e=require("./modular.cjs.js"),t=require("./utils.cjs.js");
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const n=BigInt(0),i=BigInt(1);exports.validateBasic=function validateBasic(n){return e.validateField(n.Fp),t.validateObject(n,{n:"bigint",h:"bigint",Gx:"field",Gy:"field"},{nBitLength:"isSafeInteger",nByteLength:"isSafeInteger"}),Object.freeze({...e.nLength(n.n,n.nBitLength),...n,p:n.Fp.ORDER})},exports.wNAF=function wNAF(e,t){const constTimeNegate=(e,t)=>{const n=t.negate();return e?n:t},opts=e=>({windows:Math.ceil(t/e)+1,windowSize:2**(e-1)});return{constTimeNegate:constTimeNegate,unsafeLadder(t,r){let s=e.ZERO,o=t;for(;r>n;)r&i&&(s=s.add(o)),o=o.double(),r>>=i;return s},precomputeWindow(e,t){const{windows:n,windowSize:i}=opts(t),r=[];let s=e,o=s;for(let e=0;e<n;e++){o=s,r.push(o);for(let e=1;e<i;e++)o=o.add(s),r.push(o);s=o.double()}return r},wNAF(t,n,r){const{windows:s,windowSize:o}=opts(t);let d=e.ZERO,a=e.BASE;const c=BigInt(2**t-1),u=2**t,l=BigInt(t);for(let e=0;e<s;e++){const t=e*o;let s=Number(r&c);r>>=l,s>o&&(s-=u,r+=i);const w=t,g=t+Math.abs(s)-1,f=e%2!=0,h=s<0;0===s?a=a.add(constTimeNegate(f,n[w])):d=d.add(constTimeNegate(h,n[g]))}return{p:d,f:a}},wNAFCached(e,t,n,i){const r=e._WINDOW_SIZE||1;let s=t.get(e);return s||(s=this.precomputeWindow(e,r),1!==r&&t.set(e,i(s))),this.wNAF(r,s,n)}}};
+//# sourceMappingURL=curve.cjs.js.map

package/dist/server/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/abstract/curve.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve.cjs.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/@noble+curves@1.2.0/node_modules/@noble/curves/esm/abstract/curve.js"],"sourcesContent":["/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// Abelian group utilities\nimport { validateField, nLength } from './modular.js';\nimport { validateObject } from './utils.js';\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\n// Elliptic curve multiplication of Point by scalar. Fragile.\n// Scalars should always be less than curve order: this should be checked inside of a curve itself.\n// Creates precomputation tables for fast multiplication:\n// - private scalar is split by fixed size windows of W bits\n// - every window point is collected from window's table & added to accumulator\n// - since windows are different, same point inside tables won't be accessed more than once per calc\n// - each multiplication is 'Math.ceil(CURVE_ORDER / 𝑊) + 1' point additions (fixed for any scalar)\n// - +1 window is neccessary for wNAF\n// - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication\n// TODO: Research returning 2d JS array of windows, instead of a single window. This would allow\n// windows to be in different memory locations\nexport function wNAF(c, bits) {\n    const constTimeNegate = (condition, item) => {\n        const neg = item.negate();\n        return condition ? neg : item;\n    };\n    const opts = (W) => {\n        const windows = Math.ceil(bits / W) + 1; // +1, because\n        const windowSize = 2 ** (W - 1); // -1 because we skip zero\n        return { windows, windowSize };\n    };\n    return {\n        constTimeNegate,\n        // non-const time multiplication ladder\n        unsafeLadder(elm, n) {\n            let p = c.ZERO;\n            let d = elm;\n            while (n > _0n) {\n                if (n & _1n)\n                    p = p.add(d);\n                d = d.double();\n                n >>= _1n;\n            }\n            return p;\n        },\n        /**\n         * Creates a wNAF precomputation window. Used for caching.\n         * Default window size is set by `utils.precompute()` and is equal to 8.\n         * Number of precomputed points depends on the curve size:\n         * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:\n         * - 𝑊 is the window size\n         * - 𝑛 is the bitlength of the curve order.\n         * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.\n         * @returns precomputed point tables flattened to a single array\n         */\n        precomputeWindow(elm, W) {\n            const { windows, windowSize } = opts(W);\n            const points = [];\n            let p = elm;\n            let base = p;\n            for (let window = 0; window < windows; window++) {\n                base = p;\n                points.push(base);\n                // =1, because we skip zero\n                for (let i = 1; i < windowSize; i++) {\n                    base = base.add(p);\n                    points.push(base);\n                }\n                p = base.double();\n            }\n            return points;\n        },\n        /**\n         * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.\n         * @param W window size\n         * @param precomputes precomputed tables\n         * @param n scalar (we don't check here, but should be less than curve order)\n         * @returns real and fake (for const-time) points\n         */\n        wNAF(W, precomputes, n) {\n            // TODO: maybe check that scalar is less than group order? wNAF behavious is undefined otherwise\n            // But need to carefully remove other checks before wNAF. ORDER == bits here\n            const { windows, windowSize } = opts(W);\n            let p = c.ZERO;\n            let f = c.BASE;\n            const mask = BigInt(2 ** W - 1); // Create mask with W ones: 0b1111 for W=4 etc.\n            const maxNumber = 2 ** W;\n            const shiftBy = BigInt(W);\n            for (let window = 0; window < windows; window++) {\n                const offset = window * windowSize;\n                // Extract W bits.\n                let wbits = Number(n & mask);\n                // Shift number by W bits.\n                n >>= shiftBy;\n                // If the bits are bigger than max size, we'll split those.\n                // +224 => 256 - 32\n                if (wbits > windowSize) {\n                    wbits -= maxNumber;\n                    n += _1n;\n                }\n                // This code was first written with assumption that 'f' and 'p' will never be infinity point:\n                // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,\n                // there is negate now: it is possible that negated element from low value\n                // would be the same as high element, which will create carry into next window.\n                // It's not obvious how this can fail, but still worth investigating later.\n                // Check if we're onto Zero point.\n                // Add random point inside current window to f.\n                const offset1 = offset;\n                const offset2 = offset + Math.abs(wbits) - 1; // -1 because we skip zero\n                const cond1 = window % 2 !== 0;\n                const cond2 = wbits < 0;\n                if (wbits === 0) {\n                    // The most important part for const-time getPublicKey\n                    f = f.add(constTimeNegate(cond1, precomputes[offset1]));\n                }\n                else {\n                    p = p.add(constTimeNegate(cond2, precomputes[offset2]));\n                }\n            }\n            // JIT-compiler should not eliminate f here, since it will later be used in normalizeZ()\n            // Even if the variable is still unused, there are some checks which will\n            // throw an exception, so compiler needs to prove they won't happen, which is hard.\n            // At this point there is a way to F be infinity-point even if p is not,\n            // which makes it less const-time: around 1 bigint multiply.\n            return { p, f };\n        },\n        wNAFCached(P, precomputesMap, n, transform) {\n            // @ts-ignore\n            const W = P._WINDOW_SIZE || 1;\n            // Calculate precomputes on a first run, reuse them after\n            let comp = precomputesMap.get(P);\n            if (!comp) {\n                comp = this.precomputeWindow(P, W);\n                if (W !== 1) {\n                    precomputesMap.set(P, transform(comp));\n                }\n            }\n            return this.wNAF(W, comp, n);\n        },\n    };\n}\nexport function validateBasic(curve) {\n    validateField(curve.Fp);\n    validateObject(curve, {\n        n: 'bigint',\n        h: 'bigint',\n        Gx: 'field',\n        Gy: 'field',\n    }, {\n        nBitLength: 'isSafeInteger',\n        nByteLength: 'isSafeInteger',\n    });\n    // Set defaults\n    return Object.freeze({\n        ...nLength(curve.n, curve.nBitLength),\n        ...curve,\n        ...{ p: curve.Fp.ORDER },\n    });\n}\n//# sourceMappingURL=curve.js.map"],"names":["_0n","BigInt","_1n","validateBasic","curve","validateField","Fp","validateObject","n","h","Gx","Gy","nBitLength","nByteLength","Object","freeze","nLength","p","ORDER","wNAF","c","bits","constTimeNegate","condition","item","neg","negate","opts","W","windows","Math","ceil","windowSize","unsafeLadder","elm","ZERO","d","add","double","precomputeWindow","points","base","window","push","i","precomputes","f","BASE","mask","maxNumber","shiftBy","offset","wbits","Number","offset1","offset2","abs","cond1","cond2","wNAFCached","P","precomputesMap","transform","_WINDOW_SIZE","comp","get","this","set"],"mappings":";;AAIA,MAAMA,EAAMC,OAAO,GACbC,EAAMD,OAAO,yBAoIZ,SAASE,cAAcC,GAY1B,OAXAC,EAAAA,cAAcD,EAAME,IACpBC,EAAAA,eAAeH,EAAO,CAClBI,EAAG,SACHC,EAAG,SACHC,GAAI,QACJC,GAAI,SACL,CACCC,WAAY,gBACZC,YAAa,kBAGVC,OAAOC,OAAO,IACdC,EAAAA,QAAQZ,EAAMI,EAAGJ,EAAMQ,eACvBR,EACEa,EAAGb,EAAME,GAAGY,OAEzB,eAzIO,SAASC,KAAKC,EAAGC,GACpB,MAAMC,gBAAkB,CAACC,EAAWC,KAChC,MAAMC,EAAMD,EAAKE,SACjB,OAAOH,EAAYE,EAAMD,CAAI,EAE3BG,KAAQC,IAGH,CAAEC,QAFOC,KAAKC,KAAKV,EAAOO,GAAK,EAEpBI,WADC,IAAMJ,EAAI,KAGjC,MAAO,CACHN,gCAEA,YAAAW,CAAaC,EAAK1B,GACd,IAAIS,EAAIG,EAAEe,KACNC,EAAIF,EACR,KAAO1B,EAAIR,GACHQ,EAAIN,IACJe,EAAIA,EAAEoB,IAAID,IACdA,EAAIA,EAAEE,SACN9B,IAAMN,EAEV,OAAOe,CACX,EAWA,gBAAAsB,CAAiBL,EAAKN,GAClB,MAAMC,QAAEA,EAAOG,WAAEA,GAAeL,KAAKC,GAC/BY,EAAS,GACf,IAAIvB,EAAIiB,EACJO,EAAOxB,EACX,IAAK,IAAIyB,EAAS,EAAGA,EAASb,EAASa,IAAU,CAC7CD,EAAOxB,EACPuB,EAAOG,KAAKF,GAEZ,IAAK,IAAIG,EAAI,EAAGA,EAAIZ,EAAYY,IAC5BH,EAAOA,EAAKJ,IAAIpB,GAChBuB,EAAOG,KAAKF,GAEhBxB,EAAIwB,EAAKH,QACb,CACA,OAAOE,CACX,EAQA,IAAArB,CAAKS,EAAGiB,EAAarC,GAGjB,MAAMqB,QAAEA,EAAOG,WAAEA,GAAeL,KAAKC,GACrC,IAAIX,EAAIG,EAAEe,KACNW,EAAI1B,EAAE2B,KACV,MAAMC,EAAO/C,OAAO,GAAK2B,EAAI,GACvBqB,EAAY,GAAKrB,EACjBsB,EAAUjD,OAAO2B,GACvB,IAAK,IAAIc,EAAS,EAAGA,EAASb,EAASa,IAAU,CAC7C,MAAMS,EAAST,EAASV,EAExB,IAAIoB,EAAQC,OAAO7C,EAAIwC,GAEvBxC,IAAM0C,EAGFE,EAAQpB,IACRoB,GAASH,EACTzC,GAAKN,GAST,MAAMoD,EAAUH,EACVI,EAAUJ,EAASrB,KAAK0B,IAAIJ,GAAS,EACrCK,EAAQf,EAAS,GAAM,EACvBgB,EAAQN,EAAQ,EACR,IAAVA,EAEAN,EAAIA,EAAET,IAAIf,gBAAgBmC,EAAOZ,EAAYS,KAG7CrC,EAAIA,EAAEoB,IAAIf,gBAAgBoC,EAAOb,EAAYU,IAErD,CAMA,MAAO,CAAEtC,IAAG6B,IAChB,EACA,UAAAa,CAAWC,EAAGC,EAAgBrD,EAAGsD,GAE7B,MAAMlC,EAAIgC,EAAEG,cAAgB,EAE5B,IAAIC,EAAOH,EAAeI,IAAIL,GAO9B,OANKI,IACDA,EAAOE,KAAK3B,iBAAiBqB,EAAGhC,GACtB,IAANA,GACAiC,EAAeM,IAAIP,EAAGE,EAAUE,KAGjCE,KAAK/C,KAAKS,EAAGoC,EAAMxD,EAC9B,EAER","x_google_ignoreList":[0]}

package/dist/server/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/abstract/curve.esm.js

@@ -0,0 +1,4 @@
+import{validateField as t,nLength as e}from"./modular.esm.js";import{validateObject as n}from"./utils.esm.js";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const i=BigInt(0),o=BigInt(1);function wNAF(t,e){const constTimeNegate=(t,e)=>{const n=e.negate();return t?n:e},opts=t=>({windows:Math.ceil(e/t)+1,windowSize:2**(t-1)});return{constTimeNegate:constTimeNegate,unsafeLadder(e,n){let r=t.ZERO,s=e;for(;n>i;)n&o&&(r=r.add(s)),s=s.double(),n>>=o;return r},precomputeWindow(t,e){const{windows:n,windowSize:i}=opts(e),o=[];let r=t,s=r;for(let t=0;t<n;t++){s=r,o.push(s);for(let t=1;t<i;t++)s=s.add(r),o.push(s);r=s.double()}return o},wNAF(e,n,i){const{windows:r,windowSize:s}=opts(e);let d=t.ZERO,a=t.BASE;const c=BigInt(2**e-1),u=2**e,w=BigInt(e);for(let t=0;t<r;t++){const e=t*s;let r=Number(i&c);i>>=w,r>s&&(r-=u,i+=o);const l=e,f=e+Math.abs(r)-1,g=t%2!=0,p=r<0;0===r?a=a.add(constTimeNegate(g,n[l])):d=d.add(constTimeNegate(p,n[f]))}return{p:d,f:a}},wNAFCached(t,e,n,i){const o=t._WINDOW_SIZE||1;let r=e.get(t);return r||(r=this.precomputeWindow(t,o),1!==o&&e.set(t,i(r))),this.wNAF(o,r,n)}}}function validateBasic(i){return t(i.Fp),n(i,{n:"bigint",h:"bigint",Gx:"field",Gy:"field"},{nBitLength:"isSafeInteger",nByteLength:"isSafeInteger"}),Object.freeze({...e(i.n,i.nBitLength),...i,p:i.Fp.ORDER})}export{validateBasic,wNAF};
+//# sourceMappingURL=curve.esm.js.map