@blamejs/core 0.16.30 → 0.16.32

package/lib/vendor/noble-ciphers.cjs

@@ -1,7 +1,798 @@
 // XChaCha20-Poly1305 — vendored from @noble/ciphers v2.2.0 by Paul Miller
 // License: MIT — https://github.com/paulmillr/noble-ciphers
 // Bundled with esbuild. Exports: xchacha20poly1305
-var st=Object.defineProperty;var Ut=Object.getOwnPropertyDescriptor;var At=Object.getOwnPropertyNames;var Tt=Object.prototype.hasOwnProperty;var _t=(e,t)=>{for(var i in t)st(e,i,{get:t[i],enumerable:!0})},Ot=(e,t,i,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let s of At(t))!Tt.call(e,s)&&s!==i&&st(e,s,{get:()=>t[s],enumerable:!(n=Ut(t,s))||n.enumerable});return e};var Rt=e=>Ot(st({},"__esModule",{value:!0}),e);var Vt={};_t(Vt,{xchacha20poly1305:()=>Bt});module.exports=Rt(Vt);function Ct(e){return e instanceof Uint8Array||ArrayBuffer.isView(e)&&e.constructor.name==="Uint8Array"&&"BYTES_PER_ELEMENT"in e&&e.BYTES_PER_ELEMENT===1}function ft(e){if(typeof e!="boolean")throw new TypeError(`boolean expected, not ${e}`)}function tt(e){if(typeof e!="number")throw new TypeError("number expected, got "+typeof e);if(!Number.isSafeInteger(e)||e<0)throw new RangeError("positive integer expected, got "+e)}function j(e,t,i=""){let n=Ct(e),s=e?.length,o=t!==void 0;if(!n||o&&s!==t){let f=i&&`"${i}" `,r=o?` of length ${t}`:"",c=n?`length=${s}`:`type=${typeof e}`,u=f+"expected Uint8Array"+r+", got "+c;throw n?new RangeError(u):new TypeError(u)}return e}function it(e,t=!0){if(e.destroyed)throw new Error("Hash instance has been destroyed");if(t&&e.finished)throw new Error("Hash#digest() has already been called")}function at(e,t,i=!1){j(e,void 0,"output");let n=t.outputLen;if(e.length<n)throw new RangeError("digestInto() expects output buffer of length at least "+n);if(i&&!et(e))throw new Error("invalid output, must be aligned")}function q(e){return new Uint32Array(e.buffer,e.byteOffset,Math.floor(e.byteLength/4))}function V(...e){for(let t=0;t<e.length;t++)e[t].fill(0)}function It(e){return new DataView(e.buffer,e.byteOffset,e.byteLength)}var W=new Uint8Array(new Uint32Array([287454020]).buffer)[0]===68,lt=e=>e<<24&4278190080|e<<8&16711680|e>>>8&65280|e>>>24&255,k=W?e=>e:e=>lt(e)>>>0,St=e=>{for(let t=0;t<e.length;t++)e[t]=lt(e[t]);return e},F=W?e=>e:St;function ut(e,t){if(t==null||typeof t!="object")throw new Error("options must be defined");return Object.assign(e,t)}function pt(e,t){if(e.length!==t.length)return!1;let i=0;for(let n=0;n<e.length;n++)i|=e[n]^t[n];return i===0}function yt(e,t,i){let n=t,s=i||(()=>[]),o=(r,c)=>n(c,...s(r)).update(r).digest(),f=n(new Uint8Array(e),...s(new Uint8Array(0)));return o.outputLen=f.outputLen,o.blockLen=f.blockLen,o.create=(r,...c)=>n(r,...c),o}var gt=(e,t)=>{function i(n,...s){if(j(n,void 0,"key"),e.nonceLength!==void 0){let l=s[0];j(l,e.varSizeNonce?void 0:e.nonceLength,"nonce")}let o=e.tagLength;o&&s[1]!==void 0&&j(s[1],void 0,"AAD");let f=t(n,...s),r=(l,y)=>{if(y!==void 0){if(l!==2)throw new Error("cipher output not supported");j(y,void 0,"output")}},c=!1;return{encrypt(l,y){if(c)throw new Error("cannot encrypt() twice with same key + nonce");return c=!0,j(l),r(f.encrypt.length,y),f.encrypt(l,y)},decrypt(l,y){if(j(l),o&&l.length<o)throw new Error('"ciphertext" expected length bigger than tagLength='+o);return r(f.decrypt.length,y),f.decrypt(l,y)}}}return Object.assign(i,e),i};function rt(e,t,i=!0){if(t===void 0)return new Uint8Array(e);if(j(t,void 0,"output"),t.length!==e)throw new Error('"output" expected Uint8Array of length '+e+", got: "+t.length);if(i&&!et(t))throw new Error("invalid output, must be aligned");return t}function xt(e,t,i){tt(e),tt(t),ft(i);let n=new Uint8Array(16),s=It(n);return s.setBigUint64(0,BigInt(t),i),s.setBigUint64(8,BigInt(e),i),n}function et(e){return e.byteOffset%4===0}function nt(e){return Uint8Array.from(j(e))}var wt=e=>Uint8Array.from(e.split(""),t=>t.charCodeAt(0)),vt=F(q(wt("expand 16-byte k"))),Nt=F(q(wt("expand 32-byte k")));function h(e,t){return e<<t|e>>>32-t}var ot=64,Mt=16,ct=2**32-1,dt=Uint32Array.of();function jt(e,t,i,n,s,o,f,r){let c=s.length,u=new Uint8Array(ot),l=q(u),y=W&&et(s)&&et(o),b=y?q(s):dt,w=y?q(o):dt;if(!W){for(let g=0;g<c;f++){if(e(t,i,n,l,f,r),F(l),f>=ct)throw new Error("arx: counter overflow");let x=Math.min(ot,c-g);for(let p=0,d;p<x;p++)d=g+p,o[d]=s[d]^u[p];g+=x}return}for(let g=0;g<c;f++){if(e(t,i,n,l,f,r),f>=ct)throw new Error("arx: counter overflow");let x=Math.min(ot,c-g);if(y&&x===ot){let p=g/4;if(g%4!==0)throw new Error("arx: invalid block position");for(let d=0,L;d<Mt;d++)L=p+d,w[L]=b[L]^l[d];g+=ot;continue}for(let p=0,d;p<x;p++)d=g+p,o[d]=s[d]^u[p];g+=x}}function bt(e,t){let{allowShortKeys:i,extendNonceFn:n,counterLength:s,counterRight:o,rounds:f}=ut({allowShortKeys:!1,counterLength:8,counterRight:!1,rounds:20},t);if(typeof e!="function")throw new Error("core must be a function");return tt(s),tt(f),ft(o),ft(i),(r,c,u,l,y=0)=>{j(r,void 0,"key"),j(c,void 0,"nonce"),j(u,void 0,"data");let b=u.length;if(l=rt(b,l,!1),tt(y),y<0||y>=ct)throw new Error("arx: counter overflow");let w=[],g=r.length,x,p;if(g===32)w.push(x=nt(r)),p=Nt;else if(g===16&&i)x=new Uint8Array(32),x.set(r),x.set(r,16),p=vt,w.push(x);else throw j(r,32,"arx key"),new Error("invalid key size");(!W||!et(c))&&w.push(c=nt(c));let d=q(x);if(n){if(c.length!==24)throw new Error("arx: extended nonce must be 24 bytes");let M=c.subarray(0,16);if(W)n(p,d,q(M),d);else{let $=F(Uint32Array.from(p));n($,d,q(M),d),V($),F(d)}c=c.subarray(16)}else W||F(d);let L=16-s;if(L!==c.length)throw new Error(`arx: nonce must be ${L} or 16 bytes`);if(L!==12){let M=new Uint8Array(12);M.set(c,o?0:12-c.length),c=M,w.push(c)}let v=F(q(c));try{return jt(e,p,d,v,u,l,y,f),l}finally{V(...w)}}}function P(e,t){return e[t++]&255|(e[t++]&255)<<8}var ht=class{blockLen=16;outputLen=16;buffer=new Uint8Array(16);r=new Uint16Array(10);h=new Uint16Array(10);pad=new Uint16Array(8);pos=0;finished=!1;destroyed=!1;constructor(t){t=nt(j(t,32,"key"));let i=P(t,0),n=P(t,2),s=P(t,4),o=P(t,6),f=P(t,8),r=P(t,10),c=P(t,12),u=P(t,14);this.r[0]=i&8191,this.r[1]=(i>>>13|n<<3)&8191,this.r[2]=(n>>>10|s<<6)&7939,this.r[3]=(s>>>7|o<<9)&8191,this.r[4]=(o>>>4|f<<12)&255,this.r[5]=f>>>1&8190,this.r[6]=(f>>>14|r<<2)&8191,this.r[7]=(r>>>11|c<<5)&8065,this.r[8]=(c>>>8|u<<8)&8191,this.r[9]=u>>>5&127;for(let l=0;l<8;l++)this.pad[l]=P(t,16+2*l)}process(t,i,n=!1){let s=n?0:2048,{h:o,r:f}=this,r=f[0],c=f[1],u=f[2],l=f[3],y=f[4],b=f[5],w=f[6],g=f[7],x=f[8],p=f[9],d=P(t,i+0),L=P(t,i+2),v=P(t,i+4),M=P(t,i+6),$=P(t,i+8),z=P(t,i+10),H=P(t,i+12),K=P(t,i+14),m=o[0]+(d&8191),E=o[1]+((d>>>13|L<<3)&8191),B=o[2]+((L>>>10|v<<6)&8191),U=o[3]+((v>>>7|M<<9)&8191),A=o[4]+((M>>>4|$<<12)&8191),T=o[5]+($>>>1&8191),_=o[6]+(($>>>14|z<<2)&8191),O=o[7]+((z>>>11|H<<5)&8191),R=o[8]+((H>>>8|K<<8)&8191),C=o[9]+(K>>>5|s),a=0,S=a+m*r+E*(5*p)+B*(5*x)+U*(5*g)+A*(5*w);a=S>>>13,S&=8191,S+=T*(5*b)+_*(5*y)+O*(5*l)+R*(5*u)+C*(5*c),a+=S>>>13,S&=8191;let N=a+m*c+E*r+B*(5*p)+U*(5*x)+A*(5*g);a=N>>>13,N&=8191,N+=T*(5*w)+_*(5*b)+O*(5*y)+R*(5*l)+C*(5*u),a+=N>>>13,N&=8191;let I=a+m*u+E*c+B*r+U*(5*p)+A*(5*x);a=I>>>13,I&=8191,I+=T*(5*g)+_*(5*w)+O*(5*b)+R*(5*y)+C*(5*l),a+=I>>>13,I&=8191;let Y=a+m*l+E*u+B*c+U*r+A*(5*p);a=Y>>>13,Y&=8191,Y+=T*(5*x)+_*(5*g)+O*(5*w)+R*(5*b)+C*(5*y),a+=Y>>>13,Y&=8191;let Z=a+m*y+E*l+B*u+U*c+A*r;a=Z>>>13,Z&=8191,Z+=T*(5*p)+_*(5*x)+O*(5*g)+R*(5*w)+C*(5*b),a+=Z>>>13,Z&=8191;let G=a+m*b+E*y+B*l+U*u+A*c;a=G>>>13,G&=8191,G+=T*r+_*(5*p)+O*(5*x)+R*(5*g)+C*(5*w),a+=G>>>13,G&=8191;let Q=a+m*w+E*b+B*y+U*l+A*u;a=Q>>>13,Q&=8191,Q+=T*c+_*r+O*(5*p)+R*(5*x)+C*(5*g),a+=Q>>>13,Q&=8191;let J=a+m*g+E*w+B*b+U*y+A*l;a=J>>>13,J&=8191,J+=T*u+_*c+O*r+R*(5*p)+C*(5*x),a+=J>>>13,J&=8191;let X=a+m*x+E*g+B*w+U*b+A*y;a=X>>>13,X&=8191,X+=T*l+_*u+O*c+R*r+C*(5*p),a+=X>>>13,X&=8191;let D=a+m*p+E*x+B*g+U*w+A*b;a=D>>>13,D&=8191,D+=T*y+_*l+O*u+R*c+C*r,a+=D>>>13,D&=8191,a=(a<<2)+a|0,a=a+S|0,S=a&8191,a=a>>>13,N+=a,o[0]=S,o[1]=N,o[2]=I,o[3]=Y,o[4]=Z,o[5]=G,o[6]=Q,o[7]=J,o[8]=X,o[9]=D}finalize(){let{h:t,pad:i}=this,n=new Uint16Array(10),s=t[1]>>>13;t[1]&=8191;for(let r=2;r<10;r++)t[r]+=s,s=t[r]>>>13,t[r]&=8191;t[0]+=s*5,s=t[0]>>>13,t[0]&=8191,t[1]+=s,s=t[1]>>>13,t[1]&=8191,t[2]+=s,n[0]=t[0]+5,s=n[0]>>>13,n[0]&=8191;for(let r=1;r<10;r++)n[r]=t[r]+s,s=n[r]>>>13,n[r]&=8191;n[9]-=8192;let o=(s^1)-1;for(let r=0;r<10;r++)n[r]&=o;o=~o;for(let r=0;r<10;r++)t[r]=t[r]&o|n[r];t[0]=(t[0]|t[1]<<13)&65535,t[1]=(t[1]>>>3|t[2]<<10)&65535,t[2]=(t[2]>>>6|t[3]<<7)&65535,t[3]=(t[3]>>>9|t[4]<<4)&65535,t[4]=(t[4]>>>12|t[5]<<1|t[6]<<14)&65535,t[5]=(t[6]>>>2|t[7]<<11)&65535,t[6]=(t[7]>>>5|t[8]<<8)&65535,t[7]=(t[8]>>>8|t[9]<<5)&65535;let f=t[0]+i[0];t[0]=f&65535;for(let r=1;r<8;r++)f=(t[r]+i[r]|0)+(f>>>16)|0,t[r]=f&65535;V(n)}update(t){it(this),j(t),t=nt(t);let{buffer:i,blockLen:n}=this,s=t.length;for(let o=0;o<s;){let f=Math.min(n-this.pos,s-o);if(f===n){for(;n<=s-o;o+=n)this.process(t,o);continue}i.set(t.subarray(o,o+f),this.pos),this.pos+=f,o+=f,this.pos===n&&(this.process(i,0,!1),this.pos=0)}return this}destroy(){this.destroyed=!0,V(this.h,this.r,this.buffer,this.pad)}digestInto(t){it(this),at(t,this),this.finished=!0;let{buffer:i,h:n}=this,{pos:s}=this;if(s){for(i[s++]=1;s<16;s++)i[s]=0;this.process(i,0,!0)}this.finalize();let o=0;for(let f=0;f<8;f++)t[o++]=n[f]>>>0,t[o++]=n[f]>>>8}digest(){let{buffer:t,outputLen:i}=this;this.digestInto(t);let n=t.slice(0,i);return this.destroy(),n}},Lt=yt(32,e=>new ht(e));function kt(e,t,i,n,s,o=20){let f=e[0],r=e[1],c=e[2],u=e[3],l=t[0],y=t[1],b=t[2],w=t[3],g=t[4],x=t[5],p=t[6],d=t[7],L=s,v=i[0],M=i[1],$=i[2],z=f,H=r,K=c,m=u,E=l,B=y,U=b,A=w,T=g,_=x,O=p,R=d,C=L,a=v,S=M,N=$;for(let Y=0;Y<o;Y+=2)z=z+E|0,C=h(C^z,16),T=T+C|0,E=h(E^T,12),z=z+E|0,C=h(C^z,8),T=T+C|0,E=h(E^T,7),H=H+B|0,a=h(a^H,16),_=_+a|0,B=h(B^_,12),H=H+B|0,a=h(a^H,8),_=_+a|0,B=h(B^_,7),K=K+U|0,S=h(S^K,16),O=O+S|0,U=h(U^O,12),K=K+U|0,S=h(S^K,8),O=O+S|0,U=h(U^O,7),m=m+A|0,N=h(N^m,16),R=R+N|0,A=h(A^R,12),m=m+A|0,N=h(N^m,8),R=R+N|0,A=h(A^R,7),z=z+B|0,N=h(N^z,16),O=O+N|0,B=h(B^O,12),z=z+B|0,N=h(N^z,8),O=O+N|0,B=h(B^O,7),H=H+U|0,C=h(C^H,16),R=R+C|0,U=h(U^R,12),H=H+U|0,C=h(C^H,8),R=R+C|0,U=h(U^R,7),K=K+A|0,a=h(a^K,16),T=T+a|0,A=h(A^T,12),K=K+A|0,a=h(a^K,8),T=T+a|0,A=h(A^T,7),m=m+E|0,S=h(S^m,16),_=_+S|0,E=h(E^_,12),m=m+E|0,S=h(S^m,8),_=_+S|0,E=h(E^_,7);let I=0;n[I++]=f+z|0,n[I++]=r+H|0,n[I++]=c+K|0,n[I++]=u+m|0,n[I++]=l+E|0,n[I++]=y+B|0,n[I++]=b+U|0,n[I++]=w+A|0,n[I++]=g+T|0,n[I++]=x+_|0,n[I++]=p+O|0,n[I++]=d+R|0,n[I++]=L+C|0,n[I++]=v+a|0,n[I++]=M+S|0,n[I++]=$+N|0}function Pt(e,t,i,n){let s=k(e[0]),o=k(e[1]),f=k(e[2]),r=k(e[3]),c=k(t[0]),u=k(t[1]),l=k(t[2]),y=k(t[3]),b=k(t[4]),w=k(t[5]),g=k(t[6]),x=k(t[7]),p=k(i[0]),d=k(i[1]),L=k(i[2]),v=k(i[3]);for(let $=0;$<20;$+=2)s=s+c|0,p=h(p^s,16),b=b+p|0,c=h(c^b,12),s=s+c|0,p=h(p^s,8),b=b+p|0,c=h(c^b,7),o=o+u|0,d=h(d^o,16),w=w+d|0,u=h(u^w,12),o=o+u|0,d=h(d^o,8),w=w+d|0,u=h(u^w,7),f=f+l|0,L=h(L^f,16),g=g+L|0,l=h(l^g,12),f=f+l|0,L=h(L^f,8),g=g+L|0,l=h(l^g,7),r=r+y|0,v=h(v^r,16),x=x+v|0,y=h(y^x,12),r=r+y|0,v=h(v^r,8),x=x+v|0,y=h(y^x,7),s=s+u|0,v=h(v^s,16),g=g+v|0,u=h(u^g,12),s=s+u|0,v=h(v^s,8),g=g+v|0,u=h(u^g,7),o=o+l|0,p=h(p^o,16),x=x+p|0,l=h(l^x,12),o=o+l|0,p=h(p^o,8),x=x+p|0,l=h(l^x,7),f=f+y|0,d=h(d^f,16),b=b+d|0,y=h(y^b,12),f=f+y|0,d=h(d^f,8),b=b+d|0,y=h(y^b,7),r=r+c|0,L=h(L^r,16),w=w+L|0,c=h(c^w,12),r=r+c|0,L=h(L^r,8),w=w+L|0,c=h(c^w,7);let M=0;n[M++]=s,n[M++]=o,n[M++]=f,n[M++]=r,n[M++]=p,n[M++]=d,n[M++]=L,n[M++]=v,F(n)}var zt=bt(kt,{counterRight:!1,counterLength:8,extendNonceFn:Pt,allowShortKeys:!1});var Ht=new Uint8Array(16),mt=(e,t)=>{e.update(t);let i=t.length%16;i&&e.update(Ht.subarray(i))},Kt=new Uint8Array(32);function Et(e,t,i,n,s){s!==void 0&&j(s,void 0,"AAD");let o=e(t,i,Kt),f=xt(n.length,s?s.length:0,!0),r=Lt.create(o);s&&mt(r,s),mt(r,n),r.update(f);let c=r.digest();return V(o,f),c}var $t=e=>(t,i,n)=>({encrypt(o,f){let r=o.length;f=rt(r+16,f,!1),f.set(o);let c=f.subarray(0,-16);e(t,i,c,c,1);let u=Et(e,t,i,c,n);return f.set(u,r),V(u),f},decrypt(o,f){f=rt(o.length-16,f,!1);let r=o.subarray(0,-16),c=o.subarray(-16),u=Et(e,t,i,r,n);if(!pt(c,u))throw V(u),new Error("invalid tag");return f.set(o.subarray(0,-16)),e(t,i,f,f,1),V(u),f}});var Bt=gt({blockSize:64,nonceLength:24,tagLength:16},$t(zt));0&&(module.exports={xchacha20poly1305});
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// _entry.mjs
+var entry_exports = {};
+__export(entry_exports, {
+  xchacha20poly1305: () => xchacha20poly1305
+});
+module.exports = __toCommonJS(entry_exports);
+
+// node_modules/@noble/ciphers/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+function abool(b) {
+  if (typeof b !== "boolean")
+    throw new TypeError(`boolean expected, not ${b}`);
+}
+function anumber(n) {
+  if (typeof n !== "number")
+    throw new TypeError("number expected, got " + typeof n);
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new RangeError("positive integer expected, got " + n);
+}
+function abytes(value, length, title = "") {
+  const bytes = isBytes(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    const message = prefix + "expected Uint8Array" + ofLen + ", got " + got;
+    if (!bytes)
+      throw new TypeError(message);
+    throw new RangeError(message);
+  }
+  return value;
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance, onlyAligned = false) {
+  abytes(out, void 0, "output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new RangeError("digestInto() expects output buffer of length at least " + min);
+  }
+  if (onlyAligned && !isAligned32(out))
+    throw new Error("invalid output, must be aligned");
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+var byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+var swap8IfBE = isLE ? (n) => n : (n) => byteSwap(n) >>> 0;
+var byteSwap32 = (arr) => {
+  for (let i = 0; i < arr.length; i++)
+    arr[i] = byteSwap(arr[i]);
+  return arr;
+};
+var swap32IfBE = isLE ? (u) => u : byteSwap32;
+function checkOpts(defaults, opts) {
+  if (opts == null || typeof opts !== "object")
+    throw new Error("options must be defined");
+  const merged = Object.assign(defaults, opts);
+  return merged;
+}
+function equalBytes(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++)
+    diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+function wrapMacConstructor(keyLen, macCons, fromMsg) {
+  const mac = macCons;
+  const getArgs = fromMsg || (() => []);
+  const macC = (msg, key) => mac(key, ...getArgs(msg)).update(msg).digest();
+  const tmp = mac(new Uint8Array(keyLen), ...getArgs(new Uint8Array(0)));
+  macC.outputLen = tmp.outputLen;
+  macC.blockLen = tmp.blockLen;
+  macC.create = (key, ...args) => mac(key, ...args);
+  return macC;
+}
+var wrapCipher = /* @__NO_SIDE_EFFECTS__ */ (params, constructor) => {
+  function wrappedCipher(key, ...args) {
+    abytes(key, void 0, "key");
+    if (params.nonceLength !== void 0) {
+      const nonce = args[0];
+      abytes(nonce, params.varSizeNonce ? void 0 : params.nonceLength, "nonce");
+    }
+    const tagl = params.tagLength;
+    if (tagl && args[1] !== void 0)
+      abytes(args[1], void 0, "AAD");
+    const cipher = constructor(key, ...args);
+    const checkOutput = (fnLength, output) => {
+      if (output !== void 0) {
+        if (fnLength !== 2)
+          throw new Error("cipher output not supported");
+        abytes(output, void 0, "output");
+      }
+    };
+    let called = false;
+    const wrCipher = {
+      encrypt(data, output) {
+        if (called)
+          throw new Error("cannot encrypt() twice with same key + nonce");
+        called = true;
+        abytes(data);
+        checkOutput(cipher.encrypt.length, output);
+        return cipher.encrypt(data, output);
+      },
+      decrypt(data, output) {
+        abytes(data);
+        if (tagl && data.length < tagl)
+          throw new Error('"ciphertext" expected length bigger than tagLength=' + tagl);
+        checkOutput(cipher.decrypt.length, output);
+        return cipher.decrypt(data, output);
+      }
+    };
+    return wrCipher;
+  }
+  Object.assign(wrappedCipher, params);
+  return wrappedCipher;
+};
+function getOutput(expectedLength, out, onlyAligned = true) {
+  if (out === void 0)
+    return new Uint8Array(expectedLength);
+  abytes(out, void 0, "output");
+  if (out.length !== expectedLength)
+    throw new Error('"output" expected Uint8Array of length ' + expectedLength + ", got: " + out.length);
+  if (onlyAligned && !isAligned32(out))
+    throw new Error("invalid output, must be aligned");
+  return out;
+}
+function u64Lengths(dataLength, aadLength, isLE2) {
+  anumber(dataLength);
+  anumber(aadLength);
+  abool(isLE2);
+  const num = new Uint8Array(16);
+  const view = createView(num);
+  view.setBigUint64(0, BigInt(aadLength), isLE2);
+  view.setBigUint64(8, BigInt(dataLength), isLE2);
+  return num;
+}
+function isAligned32(bytes) {
+  return bytes.byteOffset % 4 === 0;
+}
+function copyBytes(bytes) {
+  return Uint8Array.from(abytes(bytes));
+}
+
+// node_modules/@noble/ciphers/_arx.js
+var encodeStr = (str) => Uint8Array.from(str.split(""), (c) => c.charCodeAt(0));
+var sigma16_32 = /* @__PURE__ */ (() => swap32IfBE(u32(encodeStr("expand 16-byte k"))))();
+var sigma32_32 = /* @__PURE__ */ (() => swap32IfBE(u32(encodeStr("expand 32-byte k"))))();
+function rotl(a, b) {
+  return a << b | a >>> 32 - b;
+}
+var BLOCK_LEN = 64;
+var BLOCK_LEN32 = 16;
+var MAX_COUNTER = /* @__PURE__ */ (() => 2 ** 32 - 1)();
+var U32_EMPTY = /* @__PURE__ */ Uint32Array.of();
+function runCipher(core, sigma, key, nonce, data, output, counter, rounds) {
+  const len = data.length;
+  const block = new Uint8Array(BLOCK_LEN);
+  const b32 = u32(block);
+  const isAligned = isLE && isAligned32(data) && isAligned32(output);
+  const d32 = isAligned ? u32(data) : U32_EMPTY;
+  const o32 = isAligned ? u32(output) : U32_EMPTY;
+  if (!isLE) {
+    for (let pos = 0; pos < len; counter++) {
+      core(sigma, key, nonce, b32, counter, rounds);
+      swap32IfBE(b32);
+      if (counter >= MAX_COUNTER)
+        throw new Error("arx: counter overflow");
+      const take = Math.min(BLOCK_LEN, len - pos);
+      for (let j = 0, posj; j < take; j++) {
+        posj = pos + j;
+        output[posj] = data[posj] ^ block[j];
+      }
+      pos += take;
+    }
+    return;
+  }
+  for (let pos = 0; pos < len; counter++) {
+    core(sigma, key, nonce, b32, counter, rounds);
+    if (counter >= MAX_COUNTER)
+      throw new Error("arx: counter overflow");
+    const take = Math.min(BLOCK_LEN, len - pos);
+    if (isAligned && take === BLOCK_LEN) {
+      const pos32 = pos / 4;
+      if (pos % 4 !== 0)
+        throw new Error("arx: invalid block position");
+      for (let j = 0, posj; j < BLOCK_LEN32; j++) {
+        posj = pos32 + j;
+        o32[posj] = d32[posj] ^ b32[j];
+      }
+      pos += BLOCK_LEN;
+      continue;
+    }
+    for (let j = 0, posj; j < take; j++) {
+      posj = pos + j;
+      output[posj] = data[posj] ^ block[j];
+    }
+    pos += take;
+  }
+}
+function createCipher(core, opts) {
+  const { allowShortKeys, extendNonceFn, counterLength, counterRight, rounds } = checkOpts({ allowShortKeys: false, counterLength: 8, counterRight: false, rounds: 20 }, opts);
+  if (typeof core !== "function")
+    throw new Error("core must be a function");
+  anumber(counterLength);
+  anumber(rounds);
+  abool(counterRight);
+  abool(allowShortKeys);
+  return (key, nonce, data, output, counter = 0) => {
+    abytes(key, void 0, "key");
+    abytes(nonce, void 0, "nonce");
+    abytes(data, void 0, "data");
+    const len = data.length;
+    output = getOutput(len, output, false);
+    anumber(counter);
+    if (counter < 0 || counter >= MAX_COUNTER)
+      throw new Error("arx: counter overflow");
+    const toClean = [];
+    let l = key.length;
+    let k;
+    let sigma;
+    if (l === 32) {
+      toClean.push(k = copyBytes(key));
+      sigma = sigma32_32;
+    } else if (l === 16 && allowShortKeys) {
+      k = new Uint8Array(32);
+      k.set(key);
+      k.set(key, 16);
+      sigma = sigma16_32;
+      toClean.push(k);
+    } else {
+      abytes(key, 32, "arx key");
+      throw new Error("invalid key size");
+    }
+    if (!isLE || !isAligned32(nonce))
+      toClean.push(nonce = copyBytes(nonce));
+    let k32 = u32(k);
+    if (extendNonceFn) {
+      if (nonce.length !== 24)
+        throw new Error(`arx: extended nonce must be 24 bytes`);
+      const n16 = nonce.subarray(0, 16);
+      if (isLE)
+        extendNonceFn(sigma, k32, u32(n16), k32);
+      else {
+        const sigmaRaw = swap32IfBE(Uint32Array.from(sigma));
+        extendNonceFn(sigmaRaw, k32, u32(n16), k32);
+        clean(sigmaRaw);
+        swap32IfBE(k32);
+      }
+      nonce = nonce.subarray(16);
+    } else if (!isLE)
+      swap32IfBE(k32);
+    const nonceNcLen = 16 - counterLength;
+    if (nonceNcLen !== nonce.length)
+      throw new Error(`arx: nonce must be ${nonceNcLen} or 16 bytes`);
+    if (nonceNcLen !== 12) {
+      const nc = new Uint8Array(12);
+      nc.set(nonce, counterRight ? 0 : 12 - nonce.length);
+      nonce = nc;
+      toClean.push(nonce);
+    }
+    const n32 = swap32IfBE(u32(nonce));
+    try {
+      runCipher(core, sigma, k32, n32, data, output, counter, rounds);
+      return output;
+    } finally {
+      clean(...toClean);
+    }
+  };
+}
+
+// node_modules/@noble/ciphers/_poly1305.js
+function u8to16(a, i) {
+  return a[i++] & 255 | (a[i++] & 255) << 8;
+}
+var Poly1305 = class {
+  blockLen = 16;
+  outputLen = 16;
+  buffer = new Uint8Array(16);
+  r = new Uint16Array(10);
+  // Allocating 1 array with .subarray() here is slower than 3
+  h = new Uint16Array(10);
+  pad = new Uint16Array(8);
+  pos = 0;
+  finished = false;
+  destroyed = false;
+  // Can be speed-up using BigUint64Array, at the cost of complexity
+  constructor(key) {
+    key = copyBytes(abytes(key, 32, "key"));
+    const t0 = u8to16(key, 0);
+    const t1 = u8to16(key, 2);
+    const t2 = u8to16(key, 4);
+    const t3 = u8to16(key, 6);
+    const t4 = u8to16(key, 8);
+    const t5 = u8to16(key, 10);
+    const t6 = u8to16(key, 12);
+    const t7 = u8to16(key, 14);
+    this.r[0] = t0 & 8191;
+    this.r[1] = (t0 >>> 13 | t1 << 3) & 8191;
+    this.r[2] = (t1 >>> 10 | t2 << 6) & 7939;
+    this.r[3] = (t2 >>> 7 | t3 << 9) & 8191;
+    this.r[4] = (t3 >>> 4 | t4 << 12) & 255;
+    this.r[5] = t4 >>> 1 & 8190;
+    this.r[6] = (t4 >>> 14 | t5 << 2) & 8191;
+    this.r[7] = (t5 >>> 11 | t6 << 5) & 8065;
+    this.r[8] = (t6 >>> 8 | t7 << 8) & 8191;
+    this.r[9] = t7 >>> 5 & 127;
+    for (let i = 0; i < 8; i++)
+      this.pad[i] = u8to16(key, 16 + 2 * i);
+  }
+  process(data, offset, isLast = false) {
+    const hibit = isLast ? 0 : 1 << 11;
+    const { h, r } = this;
+    const r0 = r[0];
+    const r1 = r[1];
+    const r2 = r[2];
+    const r3 = r[3];
+    const r4 = r[4];
+    const r5 = r[5];
+    const r6 = r[6];
+    const r7 = r[7];
+    const r8 = r[8];
+    const r9 = r[9];
+    const t0 = u8to16(data, offset + 0);
+    const t1 = u8to16(data, offset + 2);
+    const t2 = u8to16(data, offset + 4);
+    const t3 = u8to16(data, offset + 6);
+    const t4 = u8to16(data, offset + 8);
+    const t5 = u8to16(data, offset + 10);
+    const t6 = u8to16(data, offset + 12);
+    const t7 = u8to16(data, offset + 14);
+    let h0 = h[0] + (t0 & 8191);
+    let h1 = h[1] + ((t0 >>> 13 | t1 << 3) & 8191);
+    let h2 = h[2] + ((t1 >>> 10 | t2 << 6) & 8191);
+    let h3 = h[3] + ((t2 >>> 7 | t3 << 9) & 8191);
+    let h4 = h[4] + ((t3 >>> 4 | t4 << 12) & 8191);
+    let h5 = h[5] + (t4 >>> 1 & 8191);
+    let h6 = h[6] + ((t4 >>> 14 | t5 << 2) & 8191);
+    let h7 = h[7] + ((t5 >>> 11 | t6 << 5) & 8191);
+    let h8 = h[8] + ((t6 >>> 8 | t7 << 8) & 8191);
+    let h9 = h[9] + (t7 >>> 5 | hibit);
+    let c = 0;
+    let d0 = c + h0 * r0 + h1 * (5 * r9) + h2 * (5 * r8) + h3 * (5 * r7) + h4 * (5 * r6);
+    c = d0 >>> 13;
+    d0 &= 8191;
+    d0 += h5 * (5 * r5) + h6 * (5 * r4) + h7 * (5 * r3) + h8 * (5 * r2) + h9 * (5 * r1);
+    c += d0 >>> 13;
+    d0 &= 8191;
+    let d1 = c + h0 * r1 + h1 * r0 + h2 * (5 * r9) + h3 * (5 * r8) + h4 * (5 * r7);
+    c = d1 >>> 13;
+    d1 &= 8191;
+    d1 += h5 * (5 * r6) + h6 * (5 * r5) + h7 * (5 * r4) + h8 * (5 * r3) + h9 * (5 * r2);
+    c += d1 >>> 13;
+    d1 &= 8191;
+    let d2 = c + h0 * r2 + h1 * r1 + h2 * r0 + h3 * (5 * r9) + h4 * (5 * r8);
+    c = d2 >>> 13;
+    d2 &= 8191;
+    d2 += h5 * (5 * r7) + h6 * (5 * r6) + h7 * (5 * r5) + h8 * (5 * r4) + h9 * (5 * r3);
+    c += d2 >>> 13;
+    d2 &= 8191;
+    let d3 = c + h0 * r3 + h1 * r2 + h2 * r1 + h3 * r0 + h4 * (5 * r9);
+    c = d3 >>> 13;
+    d3 &= 8191;
+    d3 += h5 * (5 * r8) + h6 * (5 * r7) + h7 * (5 * r6) + h8 * (5 * r5) + h9 * (5 * r4);
+    c += d3 >>> 13;
+    d3 &= 8191;
+    let d4 = c + h0 * r4 + h1 * r3 + h2 * r2 + h3 * r1 + h4 * r0;
+    c = d4 >>> 13;
+    d4 &= 8191;
+    d4 += h5 * (5 * r9) + h6 * (5 * r8) + h7 * (5 * r7) + h8 * (5 * r6) + h9 * (5 * r5);
+    c += d4 >>> 13;
+    d4 &= 8191;
+    let d5 = c + h0 * r5 + h1 * r4 + h2 * r3 + h3 * r2 + h4 * r1;
+    c = d5 >>> 13;
+    d5 &= 8191;
+    d5 += h5 * r0 + h6 * (5 * r9) + h7 * (5 * r8) + h8 * (5 * r7) + h9 * (5 * r6);
+    c += d5 >>> 13;
+    d5 &= 8191;
+    let d6 = c + h0 * r6 + h1 * r5 + h2 * r4 + h3 * r3 + h4 * r2;
+    c = d6 >>> 13;
+    d6 &= 8191;
+    d6 += h5 * r1 + h6 * r0 + h7 * (5 * r9) + h8 * (5 * r8) + h9 * (5 * r7);
+    c += d6 >>> 13;
+    d6 &= 8191;
+    let d7 = c + h0 * r7 + h1 * r6 + h2 * r5 + h3 * r4 + h4 * r3;
+    c = d7 >>> 13;
+    d7 &= 8191;
+    d7 += h5 * r2 + h6 * r1 + h7 * r0 + h8 * (5 * r9) + h9 * (5 * r8);
+    c += d7 >>> 13;
+    d7 &= 8191;
+    let d8 = c + h0 * r8 + h1 * r7 + h2 * r6 + h3 * r5 + h4 * r4;
+    c = d8 >>> 13;
+    d8 &= 8191;
+    d8 += h5 * r3 + h6 * r2 + h7 * r1 + h8 * r0 + h9 * (5 * r9);
+    c += d8 >>> 13;
+    d8 &= 8191;
+    let d9 = c + h0 * r9 + h1 * r8 + h2 * r7 + h3 * r6 + h4 * r5;
+    c = d9 >>> 13;
+    d9 &= 8191;
+    d9 += h5 * r4 + h6 * r3 + h7 * r2 + h8 * r1 + h9 * r0;
+    c += d9 >>> 13;
+    d9 &= 8191;
+    c = (c << 2) + c | 0;
+    c = c + d0 | 0;
+    d0 = c & 8191;
+    c = c >>> 13;
+    d1 += c;
+    h[0] = d0;
+    h[1] = d1;
+    h[2] = d2;
+    h[3] = d3;
+    h[4] = d4;
+    h[5] = d5;
+    h[6] = d6;
+    h[7] = d7;
+    h[8] = d8;
+    h[9] = d9;
+  }
+  finalize() {
+    const { h, pad } = this;
+    const g = new Uint16Array(10);
+    let c = h[1] >>> 13;
+    h[1] &= 8191;
+    for (let i = 2; i < 10; i++) {
+      h[i] += c;
+      c = h[i] >>> 13;
+      h[i] &= 8191;
+    }
+    h[0] += c * 5;
+    c = h[0] >>> 13;
+    h[0] &= 8191;
+    h[1] += c;
+    c = h[1] >>> 13;
+    h[1] &= 8191;
+    h[2] += c;
+    g[0] = h[0] + 5;
+    c = g[0] >>> 13;
+    g[0] &= 8191;
+    for (let i = 1; i < 10; i++) {
+      g[i] = h[i] + c;
+      c = g[i] >>> 13;
+      g[i] &= 8191;
+    }
+    g[9] -= 1 << 13;
+    let mask = (c ^ 1) - 1;
+    for (let i = 0; i < 10; i++)
+      g[i] &= mask;
+    mask = ~mask;
+    for (let i = 0; i < 10; i++)
+      h[i] = h[i] & mask | g[i];
+    h[0] = (h[0] | h[1] << 13) & 65535;
+    h[1] = (h[1] >>> 3 | h[2] << 10) & 65535;
+    h[2] = (h[2] >>> 6 | h[3] << 7) & 65535;
+    h[3] = (h[3] >>> 9 | h[4] << 4) & 65535;
+    h[4] = (h[4] >>> 12 | h[5] << 1 | h[6] << 14) & 65535;
+    h[5] = (h[6] >>> 2 | h[7] << 11) & 65535;
+    h[6] = (h[7] >>> 5 | h[8] << 8) & 65535;
+    h[7] = (h[8] >>> 8 | h[9] << 5) & 65535;
+    let f = h[0] + pad[0];
+    h[0] = f & 65535;
+    for (let i = 1; i < 8; i++) {
+      f = (h[i] + pad[i] | 0) + (f >>> 16) | 0;
+      h[i] = f & 65535;
+    }
+    clean(g);
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    data = copyBytes(data);
+    const { buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(data, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(buffer, 0, false);
+        this.pos = 0;
+      }
+    }
+    return this;
+  }
+  destroy() {
+    this.destroyed = true;
+    clean(this.h, this.r, this.buffer, this.pad);
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, h } = this;
+    let { pos } = this;
+    if (pos) {
+      buffer[pos++] = 1;
+      for (; pos < 16; pos++)
+        buffer[pos] = 0;
+      this.process(buffer, 0, true);
+    }
+    this.finalize();
+    let opos = 0;
+    for (let i = 0; i < 8; i++) {
+      out[opos++] = h[i] >>> 0;
+      out[opos++] = h[i] >>> 8;
+    }
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+};
+var poly1305 = /* @__PURE__ */ wrapMacConstructor(32, (key) => new Poly1305(key));
+
+// node_modules/@noble/ciphers/chacha.js
+function chachaCore(s, k, n, out, cnt, rounds = 20) {
+  let y00 = s[0], y01 = s[1], y02 = s[2], y03 = s[3], y04 = k[0], y05 = k[1], y06 = k[2], y07 = k[3], y08 = k[4], y09 = k[5], y10 = k[6], y11 = k[7], y12 = cnt, y13 = n[0], y14 = n[1], y15 = n[2];
+  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;
+  for (let r = 0; r < rounds; r += 2) {
+    x00 = x00 + x04 | 0;
+    x12 = rotl(x12 ^ x00, 16);
+    x08 = x08 + x12 | 0;
+    x04 = rotl(x04 ^ x08, 12);
+    x00 = x00 + x04 | 0;
+    x12 = rotl(x12 ^ x00, 8);
+    x08 = x08 + x12 | 0;
+    x04 = rotl(x04 ^ x08, 7);
+    x01 = x01 + x05 | 0;
+    x13 = rotl(x13 ^ x01, 16);
+    x09 = x09 + x13 | 0;
+    x05 = rotl(x05 ^ x09, 12);
+    x01 = x01 + x05 | 0;
+    x13 = rotl(x13 ^ x01, 8);
+    x09 = x09 + x13 | 0;
+    x05 = rotl(x05 ^ x09, 7);
+    x02 = x02 + x06 | 0;
+    x14 = rotl(x14 ^ x02, 16);
+    x10 = x10 + x14 | 0;
+    x06 = rotl(x06 ^ x10, 12);
+    x02 = x02 + x06 | 0;
+    x14 = rotl(x14 ^ x02, 8);
+    x10 = x10 + x14 | 0;
+    x06 = rotl(x06 ^ x10, 7);
+    x03 = x03 + x07 | 0;
+    x15 = rotl(x15 ^ x03, 16);
+    x11 = x11 + x15 | 0;
+    x07 = rotl(x07 ^ x11, 12);
+    x03 = x03 + x07 | 0;
+    x15 = rotl(x15 ^ x03, 8);
+    x11 = x11 + x15 | 0;
+    x07 = rotl(x07 ^ x11, 7);
+    x00 = x00 + x05 | 0;
+    x15 = rotl(x15 ^ x00, 16);
+    x10 = x10 + x15 | 0;
+    x05 = rotl(x05 ^ x10, 12);
+    x00 = x00 + x05 | 0;
+    x15 = rotl(x15 ^ x00, 8);
+    x10 = x10 + x15 | 0;
+    x05 = rotl(x05 ^ x10, 7);
+    x01 = x01 + x06 | 0;
+    x12 = rotl(x12 ^ x01, 16);
+    x11 = x11 + x12 | 0;
+    x06 = rotl(x06 ^ x11, 12);
+    x01 = x01 + x06 | 0;
+    x12 = rotl(x12 ^ x01, 8);
+    x11 = x11 + x12 | 0;
+    x06 = rotl(x06 ^ x11, 7);
+    x02 = x02 + x07 | 0;
+    x13 = rotl(x13 ^ x02, 16);
+    x08 = x08 + x13 | 0;
+    x07 = rotl(x07 ^ x08, 12);
+    x02 = x02 + x07 | 0;
+    x13 = rotl(x13 ^ x02, 8);
+    x08 = x08 + x13 | 0;
+    x07 = rotl(x07 ^ x08, 7);
+    x03 = x03 + x04 | 0;
+    x14 = rotl(x14 ^ x03, 16);
+    x09 = x09 + x14 | 0;
+    x04 = rotl(x04 ^ x09, 12);
+    x03 = x03 + x04 | 0;
+    x14 = rotl(x14 ^ x03, 8);
+    x09 = x09 + x14 | 0;
+    x04 = rotl(x04 ^ x09, 7);
+  }
+  let oi = 0;
+  out[oi++] = y00 + x00 | 0;
+  out[oi++] = y01 + x01 | 0;
+  out[oi++] = y02 + x02 | 0;
+  out[oi++] = y03 + x03 | 0;
+  out[oi++] = y04 + x04 | 0;
+  out[oi++] = y05 + x05 | 0;
+  out[oi++] = y06 + x06 | 0;
+  out[oi++] = y07 + x07 | 0;
+  out[oi++] = y08 + x08 | 0;
+  out[oi++] = y09 + x09 | 0;
+  out[oi++] = y10 + x10 | 0;
+  out[oi++] = y11 + x11 | 0;
+  out[oi++] = y12 + x12 | 0;
+  out[oi++] = y13 + x13 | 0;
+  out[oi++] = y14 + x14 | 0;
+  out[oi++] = y15 + x15 | 0;
+}
+function hchacha(s, k, i, out) {
+  let x00 = swap8IfBE(s[0]), x01 = swap8IfBE(s[1]), x02 = swap8IfBE(s[2]), x03 = swap8IfBE(s[3]), x04 = swap8IfBE(k[0]), x05 = swap8IfBE(k[1]), x06 = swap8IfBE(k[2]), x07 = swap8IfBE(k[3]), x08 = swap8IfBE(k[4]), x09 = swap8IfBE(k[5]), x10 = swap8IfBE(k[6]), x11 = swap8IfBE(k[7]), x12 = swap8IfBE(i[0]), x13 = swap8IfBE(i[1]), x14 = swap8IfBE(i[2]), x15 = swap8IfBE(i[3]);
+  for (let r = 0; r < 20; r += 2) {
+    x00 = x00 + x04 | 0;
+    x12 = rotl(x12 ^ x00, 16);
+    x08 = x08 + x12 | 0;
+    x04 = rotl(x04 ^ x08, 12);
+    x00 = x00 + x04 | 0;
+    x12 = rotl(x12 ^ x00, 8);
+    x08 = x08 + x12 | 0;
+    x04 = rotl(x04 ^ x08, 7);
+    x01 = x01 + x05 | 0;
+    x13 = rotl(x13 ^ x01, 16);
+    x09 = x09 + x13 | 0;
+    x05 = rotl(x05 ^ x09, 12);
+    x01 = x01 + x05 | 0;
+    x13 = rotl(x13 ^ x01, 8);
+    x09 = x09 + x13 | 0;
+    x05 = rotl(x05 ^ x09, 7);
+    x02 = x02 + x06 | 0;
+    x14 = rotl(x14 ^ x02, 16);
+    x10 = x10 + x14 | 0;
+    x06 = rotl(x06 ^ x10, 12);
+    x02 = x02 + x06 | 0;
+    x14 = rotl(x14 ^ x02, 8);
+    x10 = x10 + x14 | 0;
+    x06 = rotl(x06 ^ x10, 7);
+    x03 = x03 + x07 | 0;
+    x15 = rotl(x15 ^ x03, 16);
+    x11 = x11 + x15 | 0;
+    x07 = rotl(x07 ^ x11, 12);
+    x03 = x03 + x07 | 0;
+    x15 = rotl(x15 ^ x03, 8);
+    x11 = x11 + x15 | 0;
+    x07 = rotl(x07 ^ x11, 7);
+    x00 = x00 + x05 | 0;
+    x15 = rotl(x15 ^ x00, 16);
+    x10 = x10 + x15 | 0;
+    x05 = rotl(x05 ^ x10, 12);
+    x00 = x00 + x05 | 0;
+    x15 = rotl(x15 ^ x00, 8);
+    x10 = x10 + x15 | 0;
+    x05 = rotl(x05 ^ x10, 7);
+    x01 = x01 + x06 | 0;
+    x12 = rotl(x12 ^ x01, 16);
+    x11 = x11 + x12 | 0;
+    x06 = rotl(x06 ^ x11, 12);
+    x01 = x01 + x06 | 0;
+    x12 = rotl(x12 ^ x01, 8);
+    x11 = x11 + x12 | 0;
+    x06 = rotl(x06 ^ x11, 7);
+    x02 = x02 + x07 | 0;
+    x13 = rotl(x13 ^ x02, 16);
+    x08 = x08 + x13 | 0;
+    x07 = rotl(x07 ^ x08, 12);
+    x02 = x02 + x07 | 0;
+    x13 = rotl(x13 ^ x02, 8);
+    x08 = x08 + x13 | 0;
+    x07 = rotl(x07 ^ x08, 7);
+    x03 = x03 + x04 | 0;
+    x14 = rotl(x14 ^ x03, 16);
+    x09 = x09 + x14 | 0;
+    x04 = rotl(x04 ^ x09, 12);
+    x03 = x03 + x04 | 0;
+    x14 = rotl(x14 ^ x03, 8);
+    x09 = x09 + x14 | 0;
+    x04 = rotl(x04 ^ x09, 7);
+  }
+  let oi = 0;
+  out[oi++] = x00;
+  out[oi++] = x01;
+  out[oi++] = x02;
+  out[oi++] = x03;
+  out[oi++] = x12;
+  out[oi++] = x13;
+  out[oi++] = x14;
+  out[oi++] = x15;
+  swap32IfBE(out);
+}
+var xchacha20 = /* @__PURE__ */ createCipher(chachaCore, {
+  counterRight: false,
+  counterLength: 8,
+  extendNonceFn: hchacha,
+  allowShortKeys: false
+});
+var ZEROS16 = /* @__PURE__ */ new Uint8Array(16);
+var updatePadded = (h, msg) => {
+  h.update(msg);
+  const leftover = msg.length % 16;
+  if (leftover)
+    h.update(ZEROS16.subarray(leftover));
+};
+var ZEROS32 = /* @__PURE__ */ new Uint8Array(32);
+function computeTag(fn, key, nonce, ciphertext, AAD) {
+  if (AAD !== void 0)
+    abytes(AAD, void 0, "AAD");
+  const authKey = fn(key, nonce, ZEROS32);
+  const lengths = u64Lengths(ciphertext.length, AAD ? AAD.length : 0, true);
+  const h = poly1305.create(authKey);
+  if (AAD)
+    updatePadded(h, AAD);
+  updatePadded(h, ciphertext);
+  h.update(lengths);
+  const res = h.digest();
+  clean(authKey, lengths);
+  return res;
+}
+var _poly1305_aead = (xorStream) => (key, nonce, AAD) => {
+  const tagLength = 16;
+  return {
+    encrypt(plaintext, output) {
+      const plength = plaintext.length;
+      output = getOutput(plength + tagLength, output, false);
+      output.set(plaintext);
+      const oPlain = output.subarray(0, -tagLength);
+      xorStream(key, nonce, oPlain, oPlain, 1);
+      const tag = computeTag(xorStream, key, nonce, oPlain, AAD);
+      output.set(tag, plength);
+      clean(tag);
+      return output;
+    },
+    decrypt(ciphertext, output) {
+      output = getOutput(ciphertext.length - tagLength, output, false);
+      const data = ciphertext.subarray(0, -tagLength);
+      const passedTag = ciphertext.subarray(-tagLength);
+      const tag = computeTag(xorStream, key, nonce, data, AAD);
+      if (!equalBytes(passedTag, tag)) {
+        clean(tag);
+        throw new Error("invalid tag");
+      }
+      output.set(ciphertext.subarray(0, -tagLength));
+      xorStream(key, nonce, output, output, 1);
+      clean(tag);
+      return output;
+    }
+  };
+};
+var xchacha20poly1305 = /* @__PURE__ */ wrapCipher(
+  { blockSize: 64, nonceLength: 24, tagLength: 16 },
+  /* @__PURE__ */ _poly1305_aead(xchacha20)
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  xchacha20poly1305
+});
 /*! Bundled license information:
 
 @noble/ciphers/utils.js: