@ghostlytools/cli 1.0.0

package/dist/assets/nacl-fast-CDhNCYHs.js

@@ -0,0 +1,1512 @@
+//#region ../../node_modules/openpgp/dist/lightweight/nacl-fast.mjs
+/*! OpenPGP.js v6.3.2 - 2026-09-24 - this is LGPL licensed code, see LICENSE/our website https://openpgpjs.org/ for more information. */
+var globalThis$1 = typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+var crypto = typeof globalThis$1 === "object" && "crypto" in globalThis$1 ? globalThis$1.crypto : void 0;
+var nacl = {};
+var gf = function(init) {
+	var i, r = /* @__PURE__ */ new Float64Array(16);
+	if (init) for (i = 0; i < init.length; i++) r[i] = init[i];
+	return r;
+};
+var randombytes = function() {
+	throw new Error("no PRNG");
+};
+var _9 = /* @__PURE__ */ new Uint8Array(32);
+_9[0] = 9;
+var gf0 = gf();
+var gf1 = gf([1]);
+var _121665 = gf([56129, 1]);
+var D = gf([
+	30883,
+	4953,
+	19914,
+	30187,
+	55467,
+	16705,
+	2637,
+	112,
+	59544,
+	30585,
+	16505,
+	36039,
+	65139,
+	11119,
+	27886,
+	20995
+]);
+var D2 = gf([
+	61785,
+	9906,
+	39828,
+	60374,
+	45398,
+	33411,
+	5274,
+	224,
+	53552,
+	61171,
+	33010,
+	6542,
+	64743,
+	22239,
+	55772,
+	9222
+]);
+var X = gf([
+	54554,
+	36645,
+	11616,
+	51542,
+	42930,
+	38181,
+	51040,
+	26924,
+	56412,
+	64982,
+	57905,
+	49316,
+	21502,
+	52590,
+	14035,
+	8553
+]);
+var Y = gf([
+	26200,
+	26214,
+	26214,
+	26214,
+	26214,
+	26214,
+	26214,
+	26214,
+	26214,
+	26214,
+	26214,
+	26214,
+	26214,
+	26214,
+	26214,
+	26214
+]);
+var I = gf([
+	41136,
+	18958,
+	6951,
+	50414,
+	58488,
+	44335,
+	6150,
+	12099,
+	55207,
+	15867,
+	153,
+	11085,
+	57099,
+	20417,
+	9344,
+	11139
+]);
+function ts64(x, i, h, l) {
+	x[i] = h >> 24 & 255;
+	x[i + 1] = h >> 16 & 255;
+	x[i + 2] = h >> 8 & 255;
+	x[i + 3] = h & 255;
+	x[i + 4] = l >> 24 & 255;
+	x[i + 5] = l >> 16 & 255;
+	x[i + 6] = l >> 8 & 255;
+	x[i + 7] = l & 255;
+}
+function vn(x, xi, y, yi, n) {
+	var i, d = 0;
+	for (i = 0; i < n; i++) d |= x[xi + i] ^ y[yi + i];
+	return (1 & d - 1 >>> 8) - 1;
+}
+function crypto_verify_32(x, xi, y, yi) {
+	return vn(x, xi, y, yi, 32);
+}
+function set25519(r, a) {
+	var i = 0;
+	for (; i < 16; i++) r[i] = a[i] | 0;
+}
+function car25519(o) {
+	var i, v, c = 1;
+	for (i = 0; i < 16; i++) {
+		v = o[i] + c + 65535;
+		c = Math.floor(v / 65536);
+		o[i] = v - c * 65536;
+	}
+	o[0] += c - 1 + 37 * (c - 1);
+}
+function sel25519(p, q, b) {
+	var t, c = ~(b - 1);
+	for (var i = 0; i < 16; i++) {
+		t = c & (p[i] ^ q[i]);
+		p[i] ^= t;
+		q[i] ^= t;
+	}
+}
+function pack25519(o, n) {
+	var i, j, b;
+	var m = gf(), t = gf();
+	for (i = 0; i < 16; i++) t[i] = n[i];
+	car25519(t);
+	car25519(t);
+	car25519(t);
+	for (j = 0; j < 2; j++) {
+		m[0] = t[0] - 65517;
+		for (i = 1; i < 15; i++) {
+			m[i] = t[i] - 65535 - (m[i - 1] >> 16 & 1);
+			m[i - 1] &= 65535;
+		}
+		m[15] = t[15] - 32767 - (m[14] >> 16 & 1);
+		b = m[15] >> 16 & 1;
+		m[14] &= 65535;
+		sel25519(t, m, 1 - b);
+	}
+	for (i = 0; i < 16; i++) {
+		o[2 * i] = t[i] & 255;
+		o[2 * i + 1] = t[i] >> 8;
+	}
+}
+function neq25519(a, b) {
+	var c = /* @__PURE__ */ new Uint8Array(32), d = /* @__PURE__ */ new Uint8Array(32);
+	pack25519(c, a);
+	pack25519(d, b);
+	return crypto_verify_32(c, 0, d, 0);
+}
+function par25519(a) {
+	var d = /* @__PURE__ */ new Uint8Array(32);
+	pack25519(d, a);
+	return d[0] & 1;
+}
+function unpack25519(o, n) {
+	var i = 0;
+	for (; i < 16; i++) o[i] = n[2 * i] + (n[2 * i + 1] << 8);
+	o[15] &= 32767;
+}
+function A(o, a, b) {
+	for (var i = 0; i < 16; i++) o[i] = a[i] + b[i];
+}
+function Z(o, a, b) {
+	for (var i = 0; i < 16; i++) o[i] = a[i] - b[i];
+}
+function M(o, a, b) {
+	var v, c, t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0, t8 = 0, t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0, t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0, t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0, b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4], b5 = b[5], b6 = b[6], b7 = b[7], b8 = b[8], b9 = b[9], b10 = b[10], b11 = b[11], b12 = b[12], b13 = b[13], b14 = b[14], b15 = b[15];
+	v = a[0];
+	t0 += v * b0;
+	t1 += v * b1;
+	t2 += v * b2;
+	t3 += v * b3;
+	t4 += v * b4;
+	t5 += v * b5;
+	t6 += v * b6;
+	t7 += v * b7;
+	t8 += v * b8;
+	t9 += v * b9;
+	t10 += v * b10;
+	t11 += v * b11;
+	t12 += v * b12;
+	t13 += v * b13;
+	t14 += v * b14;
+	t15 += v * b15;
+	v = a[1];
+	t1 += v * b0;
+	t2 += v * b1;
+	t3 += v * b2;
+	t4 += v * b3;
+	t5 += v * b4;
+	t6 += v * b5;
+	t7 += v * b6;
+	t8 += v * b7;
+	t9 += v * b8;
+	t10 += v * b9;
+	t11 += v * b10;
+	t12 += v * b11;
+	t13 += v * b12;
+	t14 += v * b13;
+	t15 += v * b14;
+	t16 += v * b15;
+	v = a[2];
+	t2 += v * b0;
+	t3 += v * b1;
+	t4 += v * b2;
+	t5 += v * b3;
+	t6 += v * b4;
+	t7 += v * b5;
+	t8 += v * b6;
+	t9 += v * b7;
+	t10 += v * b8;
+	t11 += v * b9;
+	t12 += v * b10;
+	t13 += v * b11;
+	t14 += v * b12;
+	t15 += v * b13;
+	t16 += v * b14;
+	t17 += v * b15;
+	v = a[3];
+	t3 += v * b0;
+	t4 += v * b1;
+	t5 += v * b2;
+	t6 += v * b3;
+	t7 += v * b4;
+	t8 += v * b5;
+	t9 += v * b6;
+	t10 += v * b7;
+	t11 += v * b8;
+	t12 += v * b9;
+	t13 += v * b10;
+	t14 += v * b11;
+	t15 += v * b12;
+	t16 += v * b13;
+	t17 += v * b14;
+	t18 += v * b15;
+	v = a[4];
+	t4 += v * b0;
+	t5 += v * b1;
+	t6 += v * b2;
+	t7 += v * b3;
+	t8 += v * b4;
+	t9 += v * b5;
+	t10 += v * b6;
+	t11 += v * b7;
+	t12 += v * b8;
+	t13 += v * b9;
+	t14 += v * b10;
+	t15 += v * b11;
+	t16 += v * b12;
+	t17 += v * b13;
+	t18 += v * b14;
+	t19 += v * b15;
+	v = a[5];
+	t5 += v * b0;
+	t6 += v * b1;
+	t7 += v * b2;
+	t8 += v * b3;
+	t9 += v * b4;
+	t10 += v * b5;
+	t11 += v * b6;
+	t12 += v * b7;
+	t13 += v * b8;
+	t14 += v * b9;
+	t15 += v * b10;
+	t16 += v * b11;
+	t17 += v * b12;
+	t18 += v * b13;
+	t19 += v * b14;
+	t20 += v * b15;
+	v = a[6];
+	t6 += v * b0;
+	t7 += v * b1;
+	t8 += v * b2;
+	t9 += v * b3;
+	t10 += v * b4;
+	t11 += v * b5;
+	t12 += v * b6;
+	t13 += v * b7;
+	t14 += v * b8;
+	t15 += v * b9;
+	t16 += v * b10;
+	t17 += v * b11;
+	t18 += v * b12;
+	t19 += v * b13;
+	t20 += v * b14;
+	t21 += v * b15;
+	v = a[7];
+	t7 += v * b0;
+	t8 += v * b1;
+	t9 += v * b2;
+	t10 += v * b3;
+	t11 += v * b4;
+	t12 += v * b5;
+	t13 += v * b6;
+	t14 += v * b7;
+	t15 += v * b8;
+	t16 += v * b9;
+	t17 += v * b10;
+	t18 += v * b11;
+	t19 += v * b12;
+	t20 += v * b13;
+	t21 += v * b14;
+	t22 += v * b15;
+	v = a[8];
+	t8 += v * b0;
+	t9 += v * b1;
+	t10 += v * b2;
+	t11 += v * b3;
+	t12 += v * b4;
+	t13 += v * b5;
+	t14 += v * b6;
+	t15 += v * b7;
+	t16 += v * b8;
+	t17 += v * b9;
+	t18 += v * b10;
+	t19 += v * b11;
+	t20 += v * b12;
+	t21 += v * b13;
+	t22 += v * b14;
+	t23 += v * b15;
+	v = a[9];
+	t9 += v * b0;
+	t10 += v * b1;
+	t11 += v * b2;
+	t12 += v * b3;
+	t13 += v * b4;
+	t14 += v * b5;
+	t15 += v * b6;
+	t16 += v * b7;
+	t17 += v * b8;
+	t18 += v * b9;
+	t19 += v * b10;
+	t20 += v * b11;
+	t21 += v * b12;
+	t22 += v * b13;
+	t23 += v * b14;
+	t24 += v * b15;
+	v = a[10];
+	t10 += v * b0;
+	t11 += v * b1;
+	t12 += v * b2;
+	t13 += v * b3;
+	t14 += v * b4;
+	t15 += v * b5;
+	t16 += v * b6;
+	t17 += v * b7;
+	t18 += v * b8;
+	t19 += v * b9;
+	t20 += v * b10;
+	t21 += v * b11;
+	t22 += v * b12;
+	t23 += v * b13;
+	t24 += v * b14;
+	t25 += v * b15;
+	v = a[11];
+	t11 += v * b0;
+	t12 += v * b1;
+	t13 += v * b2;
+	t14 += v * b3;
+	t15 += v * b4;
+	t16 += v * b5;
+	t17 += v * b6;
+	t18 += v * b7;
+	t19 += v * b8;
+	t20 += v * b9;
+	t21 += v * b10;
+	t22 += v * b11;
+	t23 += v * b12;
+	t24 += v * b13;
+	t25 += v * b14;
+	t26 += v * b15;
+	v = a[12];
+	t12 += v * b0;
+	t13 += v * b1;
+	t14 += v * b2;
+	t15 += v * b3;
+	t16 += v * b4;
+	t17 += v * b5;
+	t18 += v * b6;
+	t19 += v * b7;
+	t20 += v * b8;
+	t21 += v * b9;
+	t22 += v * b10;
+	t23 += v * b11;
+	t24 += v * b12;
+	t25 += v * b13;
+	t26 += v * b14;
+	t27 += v * b15;
+	v = a[13];
+	t13 += v * b0;
+	t14 += v * b1;
+	t15 += v * b2;
+	t16 += v * b3;
+	t17 += v * b4;
+	t18 += v * b5;
+	t19 += v * b6;
+	t20 += v * b7;
+	t21 += v * b8;
+	t22 += v * b9;
+	t23 += v * b10;
+	t24 += v * b11;
+	t25 += v * b12;
+	t26 += v * b13;
+	t27 += v * b14;
+	t28 += v * b15;
+	v = a[14];
+	t14 += v * b0;
+	t15 += v * b1;
+	t16 += v * b2;
+	t17 += v * b3;
+	t18 += v * b4;
+	t19 += v * b5;
+	t20 += v * b6;
+	t21 += v * b7;
+	t22 += v * b8;
+	t23 += v * b9;
+	t24 += v * b10;
+	t25 += v * b11;
+	t26 += v * b12;
+	t27 += v * b13;
+	t28 += v * b14;
+	t29 += v * b15;
+	v = a[15];
+	t15 += v * b0;
+	t16 += v * b1;
+	t17 += v * b2;
+	t18 += v * b3;
+	t19 += v * b4;
+	t20 += v * b5;
+	t21 += v * b6;
+	t22 += v * b7;
+	t23 += v * b8;
+	t24 += v * b9;
+	t25 += v * b10;
+	t26 += v * b11;
+	t27 += v * b12;
+	t28 += v * b13;
+	t29 += v * b14;
+	t30 += v * b15;
+	t0 += 38 * t16;
+	t1 += 38 * t17;
+	t2 += 38 * t18;
+	t3 += 38 * t19;
+	t4 += 38 * t20;
+	t5 += 38 * t21;
+	t6 += 38 * t22;
+	t7 += 38 * t23;
+	t8 += 38 * t24;
+	t9 += 38 * t25;
+	t10 += 38 * t26;
+	t11 += 38 * t27;
+	t12 += 38 * t28;
+	t13 += 38 * t29;
+	t14 += 38 * t30;
+	c = 1;
+	v = t0 + c + 65535;
+	c = Math.floor(v / 65536);
+	t0 = v - c * 65536;
+	v = t1 + c + 65535;
+	c = Math.floor(v / 65536);
+	t1 = v - c * 65536;
+	v = t2 + c + 65535;
+	c = Math.floor(v / 65536);
+	t2 = v - c * 65536;
+	v = t3 + c + 65535;
+	c = Math.floor(v / 65536);
+	t3 = v - c * 65536;
+	v = t4 + c + 65535;
+	c = Math.floor(v / 65536);
+	t4 = v - c * 65536;
+	v = t5 + c + 65535;
+	c = Math.floor(v / 65536);
+	t5 = v - c * 65536;
+	v = t6 + c + 65535;
+	c = Math.floor(v / 65536);
+	t6 = v - c * 65536;
+	v = t7 + c + 65535;
+	c = Math.floor(v / 65536);
+	t7 = v - c * 65536;
+	v = t8 + c + 65535;
+	c = Math.floor(v / 65536);
+	t8 = v - c * 65536;
+	v = t9 + c + 65535;
+	c = Math.floor(v / 65536);
+	t9 = v - c * 65536;
+	v = t10 + c + 65535;
+	c = Math.floor(v / 65536);
+	t10 = v - c * 65536;
+	v = t11 + c + 65535;
+	c = Math.floor(v / 65536);
+	t11 = v - c * 65536;
+	v = t12 + c + 65535;
+	c = Math.floor(v / 65536);
+	t12 = v - c * 65536;
+	v = t13 + c + 65535;
+	c = Math.floor(v / 65536);
+	t13 = v - c * 65536;
+	v = t14 + c + 65535;
+	c = Math.floor(v / 65536);
+	t14 = v - c * 65536;
+	v = t15 + c + 65535;
+	c = Math.floor(v / 65536);
+	t15 = v - c * 65536;
+	t0 += c - 1 + 37 * (c - 1);
+	c = 1;
+	v = t0 + c + 65535;
+	c = Math.floor(v / 65536);
+	t0 = v - c * 65536;
+	v = t1 + c + 65535;
+	c = Math.floor(v / 65536);
+	t1 = v - c * 65536;
+	v = t2 + c + 65535;
+	c = Math.floor(v / 65536);
+	t2 = v - c * 65536;
+	v = t3 + c + 65535;
+	c = Math.floor(v / 65536);
+	t3 = v - c * 65536;
+	v = t4 + c + 65535;
+	c = Math.floor(v / 65536);
+	t4 = v - c * 65536;
+	v = t5 + c + 65535;
+	c = Math.floor(v / 65536);
+	t5 = v - c * 65536;
+	v = t6 + c + 65535;
+	c = Math.floor(v / 65536);
+	t6 = v - c * 65536;
+	v = t7 + c + 65535;
+	c = Math.floor(v / 65536);
+	t7 = v - c * 65536;
+	v = t8 + c + 65535;
+	c = Math.floor(v / 65536);
+	t8 = v - c * 65536;
+	v = t9 + c + 65535;
+	c = Math.floor(v / 65536);
+	t9 = v - c * 65536;
+	v = t10 + c + 65535;
+	c = Math.floor(v / 65536);
+	t10 = v - c * 65536;
+	v = t11 + c + 65535;
+	c = Math.floor(v / 65536);
+	t11 = v - c * 65536;
+	v = t12 + c + 65535;
+	c = Math.floor(v / 65536);
+	t12 = v - c * 65536;
+	v = t13 + c + 65535;
+	c = Math.floor(v / 65536);
+	t13 = v - c * 65536;
+	v = t14 + c + 65535;
+	c = Math.floor(v / 65536);
+	t14 = v - c * 65536;
+	v = t15 + c + 65535;
+	c = Math.floor(v / 65536);
+	t15 = v - c * 65536;
+	t0 += c - 1 + 37 * (c - 1);
+	o[0] = t0;
+	o[1] = t1;
+	o[2] = t2;
+	o[3] = t3;
+	o[4] = t4;
+	o[5] = t5;
+	o[6] = t6;
+	o[7] = t7;
+	o[8] = t8;
+	o[9] = t9;
+	o[10] = t10;
+	o[11] = t11;
+	o[12] = t12;
+	o[13] = t13;
+	o[14] = t14;
+	o[15] = t15;
+}
+function S(o, a) {
+	M(o, a, a);
+}
+function inv25519(o, i) {
+	var c = gf();
+	var a = 0;
+	for (; a < 16; a++) c[a] = i[a];
+	for (a = 253; a >= 0; a--) {
+		S(c, c);
+		if (a !== 2 && a !== 4) M(c, c, i);
+	}
+	for (a = 0; a < 16; a++) o[a] = c[a];
+}
+function pow2523(o, i) {
+	var c = gf();
+	var a = 0;
+	for (; a < 16; a++) c[a] = i[a];
+	for (a = 250; a >= 0; a--) {
+		S(c, c);
+		if (a !== 1) M(c, c, i);
+	}
+	for (a = 0; a < 16; a++) o[a] = c[a];
+}
+function crypto_scalarmult(q, n, p) {
+	var z = /* @__PURE__ */ new Uint8Array(32);
+	var x = /* @__PURE__ */ new Float64Array(80), r, i;
+	var a = gf(), b = gf(), c = gf(), d = gf(), e = gf(), f = gf();
+	for (i = 0; i < 31; i++) z[i] = n[i];
+	z[31] = n[31] & 127 | 64;
+	z[0] &= 248;
+	unpack25519(x, p);
+	for (i = 0; i < 16; i++) {
+		b[i] = x[i];
+		d[i] = a[i] = c[i] = 0;
+	}
+	a[0] = d[0] = 1;
+	for (i = 254; i >= 0; --i) {
+		r = z[i >>> 3] >>> (i & 7) & 1;
+		sel25519(a, b, r);
+		sel25519(c, d, r);
+		A(e, a, c);
+		Z(a, a, c);
+		A(c, b, d);
+		Z(b, b, d);
+		S(d, e);
+		S(f, a);
+		M(a, c, a);
+		M(c, b, e);
+		A(e, a, c);
+		Z(a, a, c);
+		S(b, a);
+		Z(c, d, f);
+		M(a, c, _121665);
+		A(a, a, d);
+		M(c, c, a);
+		M(a, d, f);
+		M(d, b, x);
+		S(b, e);
+		sel25519(a, b, r);
+		sel25519(c, d, r);
+	}
+	for (i = 0; i < 16; i++) {
+		x[i + 16] = a[i];
+		x[i + 32] = c[i];
+		x[i + 48] = b[i];
+		x[i + 64] = d[i];
+	}
+	var x32 = x.subarray(32);
+	var x16 = x.subarray(16);
+	inv25519(x32, x32);
+	M(x16, x16, x32);
+	pack25519(q, x16);
+	return 0;
+}
+function crypto_scalarmult_base(q, n) {
+	return crypto_scalarmult(q, n, _9);
+}
+function crypto_box_keypair(y, x) {
+	randombytes(x, 32);
+	return crypto_scalarmult_base(y, x);
+}
+var K = [
+	1116352408,
+	3609767458,
+	1899447441,
+	602891725,
+	3049323471,
+	3964484399,
+	3921009573,
+	2173295548,
+	961987163,
+	4081628472,
+	1508970993,
+	3053834265,
+	2453635748,
+	2937671579,
+	2870763221,
+	3664609560,
+	3624381080,
+	2734883394,
+	310598401,
+	1164996542,
+	607225278,
+	1323610764,
+	1426881987,
+	3590304994,
+	1925078388,
+	4068182383,
+	2162078206,
+	991336113,
+	2614888103,
+	633803317,
+	3248222580,
+	3479774868,
+	3835390401,
+	2666613458,
+	4022224774,
+	944711139,
+	264347078,
+	2341262773,
+	604807628,
+	2007800933,
+	770255983,
+	1495990901,
+	1249150122,
+	1856431235,
+	1555081692,
+	3175218132,
+	1996064986,
+	2198950837,
+	2554220882,
+	3999719339,
+	2821834349,
+	766784016,
+	2952996808,
+	2566594879,
+	3210313671,
+	3203337956,
+	3336571891,
+	1034457026,
+	3584528711,
+	2466948901,
+	113926993,
+	3758326383,
+	338241895,
+	168717936,
+	666307205,
+	1188179964,
+	773529912,
+	1546045734,
+	1294757372,
+	1522805485,
+	1396182291,
+	2643833823,
+	1695183700,
+	2343527390,
+	1986661051,
+	1014477480,
+	2177026350,
+	1206759142,
+	2456956037,
+	344077627,
+	2730485921,
+	1290863460,
+	2820302411,
+	3158454273,
+	3259730800,
+	3505952657,
+	3345764771,
+	106217008,
+	3516065817,
+	3606008344,
+	3600352804,
+	1432725776,
+	4094571909,
+	1467031594,
+	275423344,
+	851169720,
+	430227734,
+	3100823752,
+	506948616,
+	1363258195,
+	659060556,
+	3750685593,
+	883997877,
+	3785050280,
+	958139571,
+	3318307427,
+	1322822218,
+	3812723403,
+	1537002063,
+	2003034995,
+	1747873779,
+	3602036899,
+	1955562222,
+	1575990012,
+	2024104815,
+	1125592928,
+	2227730452,
+	2716904306,
+	2361852424,
+	442776044,
+	2428436474,
+	593698344,
+	2756734187,
+	3733110249,
+	3204031479,
+	2999351573,
+	3329325298,
+	3815920427,
+	3391569614,
+	3928383900,
+	3515267271,
+	566280711,
+	3940187606,
+	3454069534,
+	4118630271,
+	4000239992,
+	116418474,
+	1914138554,
+	174292421,
+	2731055270,
+	289380356,
+	3203993006,
+	460393269,
+	320620315,
+	685471733,
+	587496836,
+	852142971,
+	1086792851,
+	1017036298,
+	365543100,
+	1126000580,
+	2618297676,
+	1288033470,
+	3409855158,
+	1501505948,
+	4234509866,
+	1607167915,
+	987167468,
+	1816402316,
+	1246189591
+];
+function crypto_hashblocks_hl(hh, hl, m, n) {
+	var wh = /* @__PURE__ */ new Int32Array(16), wl = /* @__PURE__ */ new Int32Array(16), bh0, bh1, bh2, bh3, bh4, bh5, bh6, bh7, bl0, bl1, bl2, bl3, bl4, bl5, bl6, bl7, th, tl, i, j, h, l, a, b, c, d;
+	var ah0 = hh[0], ah1 = hh[1], ah2 = hh[2], ah3 = hh[3], ah4 = hh[4], ah5 = hh[5], ah6 = hh[6], ah7 = hh[7], al0 = hl[0], al1 = hl[1], al2 = hl[2], al3 = hl[3], al4 = hl[4], al5 = hl[5], al6 = hl[6], al7 = hl[7];
+	var pos = 0;
+	while (n >= 128) {
+		for (i = 0; i < 16; i++) {
+			j = 8 * i + pos;
+			wh[i] = m[j + 0] << 24 | m[j + 1] << 16 | m[j + 2] << 8 | m[j + 3];
+			wl[i] = m[j + 4] << 24 | m[j + 5] << 16 | m[j + 6] << 8 | m[j + 7];
+		}
+		for (i = 0; i < 80; i++) {
+			bh0 = ah0;
+			bh1 = ah1;
+			bh2 = ah2;
+			bh3 = ah3;
+			bh4 = ah4;
+			bh5 = ah5;
+			bh6 = ah6;
+			bh7 = ah7;
+			bl0 = al0;
+			bl1 = al1;
+			bl2 = al2;
+			bl3 = al3;
+			bl4 = al4;
+			bl5 = al5;
+			bl6 = al6;
+			bl7 = al7;
+			h = ah7;
+			l = al7;
+			a = l & 65535;
+			b = l >>> 16;
+			c = h & 65535;
+			d = h >>> 16;
+			h = (ah4 >>> 14 | al4 << 18) ^ (ah4 >>> 18 | al4 << 14) ^ (al4 >>> 9 | ah4 << 23);
+			l = (al4 >>> 14 | ah4 << 18) ^ (al4 >>> 18 | ah4 << 14) ^ (ah4 >>> 9 | al4 << 23);
+			a += l & 65535;
+			b += l >>> 16;
+			c += h & 65535;
+			d += h >>> 16;
+			h = ah4 & ah5 ^ ~ah4 & ah6;
+			l = al4 & al5 ^ ~al4 & al6;
+			a += l & 65535;
+			b += l >>> 16;
+			c += h & 65535;
+			d += h >>> 16;
+			h = K[i * 2];
+			l = K[i * 2 + 1];
+			a += l & 65535;
+			b += l >>> 16;
+			c += h & 65535;
+			d += h >>> 16;
+			h = wh[i % 16];
+			l = wl[i % 16];
+			a += l & 65535;
+			b += l >>> 16;
+			c += h & 65535;
+			d += h >>> 16;
+			b += a >>> 16;
+			c += b >>> 16;
+			d += c >>> 16;
+			th = c & 65535 | d << 16;
+			tl = a & 65535 | b << 16;
+			h = th;
+			l = tl;
+			a = l & 65535;
+			b = l >>> 16;
+			c = h & 65535;
+			d = h >>> 16;
+			h = (ah0 >>> 28 | al0 << 4) ^ (al0 >>> 2 | ah0 << 30) ^ (al0 >>> 7 | ah0 << 25);
+			l = (al0 >>> 28 | ah0 << 4) ^ (ah0 >>> 2 | al0 << 30) ^ (ah0 >>> 7 | al0 << 25);
+			a += l & 65535;
+			b += l >>> 16;
+			c += h & 65535;
+			d += h >>> 16;
+			h = ah0 & ah1 ^ ah0 & ah2 ^ ah1 & ah2;
+			l = al0 & al1 ^ al0 & al2 ^ al1 & al2;
+			a += l & 65535;
+			b += l >>> 16;
+			c += h & 65535;
+			d += h >>> 16;
+			b += a >>> 16;
+			c += b >>> 16;
+			d += c >>> 16;
+			bh7 = c & 65535 | d << 16;
+			bl7 = a & 65535 | b << 16;
+			h = bh3;
+			l = bl3;
+			a = l & 65535;
+			b = l >>> 16;
+			c = h & 65535;
+			d = h >>> 16;
+			h = th;
+			l = tl;
+			a += l & 65535;
+			b += l >>> 16;
+			c += h & 65535;
+			d += h >>> 16;
+			b += a >>> 16;
+			c += b >>> 16;
+			d += c >>> 16;
+			bh3 = c & 65535 | d << 16;
+			bl3 = a & 65535 | b << 16;
+			ah1 = bh0;
+			ah2 = bh1;
+			ah3 = bh2;
+			ah4 = bh3;
+			ah5 = bh4;
+			ah6 = bh5;
+			ah7 = bh6;
+			ah0 = bh7;
+			al1 = bl0;
+			al2 = bl1;
+			al3 = bl2;
+			al4 = bl3;
+			al5 = bl4;
+			al6 = bl5;
+			al7 = bl6;
+			al0 = bl7;
+			if (i % 16 === 15) for (j = 0; j < 16; j++) {
+				h = wh[j];
+				l = wl[j];
+				a = l & 65535;
+				b = l >>> 16;
+				c = h & 65535;
+				d = h >>> 16;
+				h = wh[(j + 9) % 16];
+				l = wl[(j + 9) % 16];
+				a += l & 65535;
+				b += l >>> 16;
+				c += h & 65535;
+				d += h >>> 16;
+				th = wh[(j + 1) % 16];
+				tl = wl[(j + 1) % 16];
+				h = (th >>> 1 | tl << 31) ^ (th >>> 8 | tl << 24) ^ th >>> 7;
+				l = (tl >>> 1 | th << 31) ^ (tl >>> 8 | th << 24) ^ (tl >>> 7 | th << 25);
+				a += l & 65535;
+				b += l >>> 16;
+				c += h & 65535;
+				d += h >>> 16;
+				th = wh[(j + 14) % 16];
+				tl = wl[(j + 14) % 16];
+				h = (th >>> 19 | tl << 13) ^ (tl >>> 29 | th << 3) ^ th >>> 6;
+				l = (tl >>> 19 | th << 13) ^ (th >>> 29 | tl << 3) ^ (tl >>> 6 | th << 26);
+				a += l & 65535;
+				b += l >>> 16;
+				c += h & 65535;
+				d += h >>> 16;
+				b += a >>> 16;
+				c += b >>> 16;
+				d += c >>> 16;
+				wh[j] = c & 65535 | d << 16;
+				wl[j] = a & 65535 | b << 16;
+			}
+		}
+		h = ah0;
+		l = al0;
+		a = l & 65535;
+		b = l >>> 16;
+		c = h & 65535;
+		d = h >>> 16;
+		h = hh[0];
+		l = hl[0];
+		a += l & 65535;
+		b += l >>> 16;
+		c += h & 65535;
+		d += h >>> 16;
+		b += a >>> 16;
+		c += b >>> 16;
+		d += c >>> 16;
+		hh[0] = ah0 = c & 65535 | d << 16;
+		hl[0] = al0 = a & 65535 | b << 16;
+		h = ah1;
+		l = al1;
+		a = l & 65535;
+		b = l >>> 16;
+		c = h & 65535;
+		d = h >>> 16;
+		h = hh[1];
+		l = hl[1];
+		a += l & 65535;
+		b += l >>> 16;
+		c += h & 65535;
+		d += h >>> 16;
+		b += a >>> 16;
+		c += b >>> 16;
+		d += c >>> 16;
+		hh[1] = ah1 = c & 65535 | d << 16;
+		hl[1] = al1 = a & 65535 | b << 16;
+		h = ah2;
+		l = al2;
+		a = l & 65535;
+		b = l >>> 16;
+		c = h & 65535;
+		d = h >>> 16;
+		h = hh[2];
+		l = hl[2];
+		a += l & 65535;
+		b += l >>> 16;
+		c += h & 65535;
+		d += h >>> 16;
+		b += a >>> 16;
+		c += b >>> 16;
+		d += c >>> 16;
+		hh[2] = ah2 = c & 65535 | d << 16;
+		hl[2] = al2 = a & 65535 | b << 16;
+		h = ah3;
+		l = al3;
+		a = l & 65535;
+		b = l >>> 16;
+		c = h & 65535;
+		d = h >>> 16;
+		h = hh[3];
+		l = hl[3];
+		a += l & 65535;
+		b += l >>> 16;
+		c += h & 65535;
+		d += h >>> 16;
+		b += a >>> 16;
+		c += b >>> 16;
+		d += c >>> 16;
+		hh[3] = ah3 = c & 65535 | d << 16;
+		hl[3] = al3 = a & 65535 | b << 16;
+		h = ah4;
+		l = al4;
+		a = l & 65535;
+		b = l >>> 16;
+		c = h & 65535;
+		d = h >>> 16;
+		h = hh[4];
+		l = hl[4];
+		a += l & 65535;
+		b += l >>> 16;
+		c += h & 65535;
+		d += h >>> 16;
+		b += a >>> 16;
+		c += b >>> 16;
+		d += c >>> 16;
+		hh[4] = ah4 = c & 65535 | d << 16;
+		hl[4] = al4 = a & 65535 | b << 16;
+		h = ah5;
+		l = al5;
+		a = l & 65535;
+		b = l >>> 16;
+		c = h & 65535;
+		d = h >>> 16;
+		h = hh[5];
+		l = hl[5];
+		a += l & 65535;
+		b += l >>> 16;
+		c += h & 65535;
+		d += h >>> 16;
+		b += a >>> 16;
+		c += b >>> 16;
+		d += c >>> 16;
+		hh[5] = ah5 = c & 65535 | d << 16;
+		hl[5] = al5 = a & 65535 | b << 16;
+		h = ah6;
+		l = al6;
+		a = l & 65535;
+		b = l >>> 16;
+		c = h & 65535;
+		d = h >>> 16;
+		h = hh[6];
+		l = hl[6];
+		a += l & 65535;
+		b += l >>> 16;
+		c += h & 65535;
+		d += h >>> 16;
+		b += a >>> 16;
+		c += b >>> 16;
+		d += c >>> 16;
+		hh[6] = ah6 = c & 65535 | d << 16;
+		hl[6] = al6 = a & 65535 | b << 16;
+		h = ah7;
+		l = al7;
+		a = l & 65535;
+		b = l >>> 16;
+		c = h & 65535;
+		d = h >>> 16;
+		h = hh[7];
+		l = hl[7];
+		a += l & 65535;
+		b += l >>> 16;
+		c += h & 65535;
+		d += h >>> 16;
+		b += a >>> 16;
+		c += b >>> 16;
+		d += c >>> 16;
+		hh[7] = ah7 = c & 65535 | d << 16;
+		hl[7] = al7 = a & 65535 | b << 16;
+		pos += 128;
+		n -= 128;
+	}
+	return n;
+}
+function crypto_hash(out, m, n) {
+	var hh = /* @__PURE__ */ new Int32Array(8), hl = /* @__PURE__ */ new Int32Array(8), x = /* @__PURE__ */ new Uint8Array(256), i, b = n;
+	hh[0] = 1779033703;
+	hh[1] = 3144134277;
+	hh[2] = 1013904242;
+	hh[3] = 2773480762;
+	hh[4] = 1359893119;
+	hh[5] = 2600822924;
+	hh[6] = 528734635;
+	hh[7] = 1541459225;
+	hl[0] = 4089235720;
+	hl[1] = 2227873595;
+	hl[2] = 4271175723;
+	hl[3] = 1595750129;
+	hl[4] = 2917565137;
+	hl[5] = 725511199;
+	hl[6] = 4215389547;
+	hl[7] = 327033209;
+	crypto_hashblocks_hl(hh, hl, m, n);
+	n %= 128;
+	for (i = 0; i < n; i++) x[i] = m[b - n + i];
+	x[n] = 128;
+	n = 256 - 128 * (n < 112 ? 1 : 0);
+	x[n - 9] = 0;
+	ts64(x, n - 8, b / 536870912 | 0, b << 3);
+	crypto_hashblocks_hl(hh, hl, x, n);
+	for (i = 0; i < 8; i++) ts64(out, 8 * i, hh[i], hl[i]);
+	return 0;
+}
+function add(p, q) {
+	var a = gf(), b = gf(), c = gf(), d = gf(), e = gf(), f = gf(), g = gf(), h = gf(), t = gf();
+	Z(a, p[1], p[0]);
+	Z(t, q[1], q[0]);
+	M(a, a, t);
+	A(b, p[0], p[1]);
+	A(t, q[0], q[1]);
+	M(b, b, t);
+	M(c, p[3], q[3]);
+	M(c, c, D2);
+	M(d, p[2], q[2]);
+	A(d, d, d);
+	Z(e, b, a);
+	Z(f, d, c);
+	A(g, d, c);
+	A(h, b, a);
+	M(p[0], e, f);
+	M(p[1], h, g);
+	M(p[2], g, f);
+	M(p[3], e, h);
+}
+function cswap(p, q, b) {
+	var i = 0;
+	for (; i < 4; i++) sel25519(p[i], q[i], b);
+}
+function pack(r, p) {
+	var tx = gf(), ty = gf(), zi = gf();
+	inv25519(zi, p[2]);
+	M(tx, p[0], zi);
+	M(ty, p[1], zi);
+	pack25519(r, ty);
+	r[31] ^= par25519(tx) << 7;
+}
+function scalarmult(p, q, s) {
+	var b, i;
+	set25519(p[0], gf0);
+	set25519(p[1], gf1);
+	set25519(p[2], gf1);
+	set25519(p[3], gf0);
+	for (i = 255; i >= 0; --i) {
+		b = s[i / 8 | 0] >> (i & 7) & 1;
+		cswap(p, q, b);
+		add(q, p);
+		add(p, p);
+		cswap(p, q, b);
+	}
+}
+function scalarbase(p, s) {
+	var q = [
+		gf(),
+		gf(),
+		gf(),
+		gf()
+	];
+	set25519(q[0], X);
+	set25519(q[1], Y);
+	set25519(q[2], gf1);
+	M(q[3], X, Y);
+	scalarmult(p, q, s);
+}
+function crypto_sign_keypair(pk, sk, seeded) {
+	var d = /* @__PURE__ */ new Uint8Array(64);
+	var p = [
+		gf(),
+		gf(),
+		gf(),
+		gf()
+	];
+	var i;
+	if (!seeded) randombytes(sk, 32);
+	crypto_hash(d, sk, 32);
+	d[0] &= 248;
+	d[31] &= 127;
+	d[31] |= 64;
+	scalarbase(p, d);
+	pack(pk, p);
+	for (i = 0; i < 32; i++) sk[i + 32] = pk[i];
+	return 0;
+}
+var L = new Float64Array([
+	237,
+	211,
+	245,
+	92,
+	26,
+	99,
+	18,
+	88,
+	214,
+	156,
+	247,
+	162,
+	222,
+	249,
+	222,
+	20,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	16
+]);
+function modL(r, x) {
+	var carry, i = 63, j, k;
+	for (; i >= 32; --i) {
+		carry = 0;
+		for (j = i - 32, k = i - 12; j < k; ++j) {
+			x[j] += carry - 16 * x[i] * L[j - (i - 32)];
+			carry = Math.floor((x[j] + 128) / 256);
+			x[j] -= carry * 256;
+		}
+		x[j] += carry;
+		x[i] = 0;
+	}
+	carry = 0;
+	for (j = 0; j < 32; j++) {
+		x[j] += carry - (x[31] >> 4) * L[j];
+		carry = x[j] >> 8;
+		x[j] &= 255;
+	}
+	for (j = 0; j < 32; j++) x[j] -= carry * L[j];
+	for (i = 0; i < 32; i++) {
+		x[i + 1] += x[i] >> 8;
+		r[i] = x[i] & 255;
+	}
+}
+function reduce(r) {
+	var x = /* @__PURE__ */ new Float64Array(64), i = 0;
+	for (; i < 64; i++) x[i] = r[i];
+	for (i = 0; i < 64; i++) r[i] = 0;
+	modL(r, x);
+}
+function crypto_sign(sm, m, n, sk) {
+	var d = /* @__PURE__ */ new Uint8Array(64), h = /* @__PURE__ */ new Uint8Array(64), r = /* @__PURE__ */ new Uint8Array(64);
+	var i, j, x = /* @__PURE__ */ new Float64Array(64);
+	var p = [
+		gf(),
+		gf(),
+		gf(),
+		gf()
+	];
+	crypto_hash(d, sk, 32);
+	d[0] &= 248;
+	d[31] &= 127;
+	d[31] |= 64;
+	var smlen = n + 64;
+	for (i = 0; i < n; i++) sm[64 + i] = m[i];
+	for (i = 0; i < 32; i++) sm[32 + i] = d[32 + i];
+	crypto_hash(r, sm.subarray(32), n + 32);
+	reduce(r);
+	scalarbase(p, r);
+	pack(sm, p);
+	for (i = 32; i < 64; i++) sm[i] = sk[i];
+	crypto_hash(h, sm, n + 64);
+	reduce(h);
+	for (i = 0; i < 64; i++) x[i] = 0;
+	for (i = 0; i < 32; i++) x[i] = r[i];
+	for (i = 0; i < 32; i++) for (j = 0; j < 32; j++) x[i + j] += h[i] * d[j];
+	modL(sm.subarray(32), x);
+	return smlen;
+}
+function unpackneg(r, p) {
+	var t = gf(), chk = gf(), num = gf(), den = gf(), den2 = gf(), den4 = gf(), den6 = gf();
+	set25519(r[2], gf1);
+	unpack25519(r[1], p);
+	S(num, r[1]);
+	M(den, num, D);
+	Z(num, num, r[2]);
+	A(den, r[2], den);
+	S(den2, den);
+	S(den4, den2);
+	M(den6, den4, den2);
+	M(t, den6, num);
+	M(t, t, den);
+	pow2523(t, t);
+	M(t, t, num);
+	M(t, t, den);
+	M(t, t, den);
+	M(r[0], t, den);
+	S(chk, r[0]);
+	M(chk, chk, den);
+	if (neq25519(chk, num)) M(r[0], r[0], I);
+	S(chk, r[0]);
+	M(chk, chk, den);
+	if (neq25519(chk, num)) return -1;
+	if (par25519(r[0]) === p[31] >> 7) Z(r[0], gf0, r[0]);
+	M(r[3], r[0], r[1]);
+	return 0;
+}
+function crypto_sign_open(m, sm, n, pk) {
+	var i;
+	var t = /* @__PURE__ */ new Uint8Array(32), h = /* @__PURE__ */ new Uint8Array(64);
+	var p = [
+		gf(),
+		gf(),
+		gf(),
+		gf()
+	], q = [
+		gf(),
+		gf(),
+		gf(),
+		gf()
+	];
+	if (n < 64) return -1;
+	if (unpackneg(q, pk)) return -1;
+	for (i = 0; i < n; i++) m[i] = sm[i];
+	for (i = 0; i < 32; i++) m[i + 32] = pk[i];
+	crypto_hash(h, m, n);
+	reduce(h);
+	scalarmult(p, q, h);
+	scalarbase(q, sm.subarray(32));
+	add(p, q);
+	pack(t, p);
+	n -= 64;
+	if (crypto_verify_32(sm, 0, t, 0)) {
+		for (i = 0; i < n; i++) m[i] = 0;
+		return -1;
+	}
+	for (i = 0; i < n; i++) m[i] = sm[i + 64];
+	return n;
+}
+var crypto_scalarmult_BYTES = 32;
+var crypto_scalarmult_SCALARBYTES = 32;
+var crypto_box_PUBLICKEYBYTES = 32;
+var crypto_box_SECRETKEYBYTES = 32;
+var crypto_sign_BYTES = 64;
+var crypto_sign_PUBLICKEYBYTES = 32;
+var crypto_sign_SECRETKEYBYTES = 64;
+var crypto_sign_SEEDBYTES = 32;
+function checkArrayTypes() {
+	for (var i = 0; i < arguments.length; i++) if (!(arguments[i] instanceof Uint8Array)) throw new TypeError("unexpected type, use Uint8Array");
+}
+function cleanup(arr) {
+	for (var i = 0; i < arr.length; i++) arr[i] = 0;
+}
+nacl.scalarMult = function(n, p) {
+	checkArrayTypes(n, p);
+	if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error("bad n size");
+	if (p.length !== crypto_scalarmult_BYTES) throw new Error("bad p size");
+	var q = new Uint8Array(crypto_scalarmult_BYTES);
+	crypto_scalarmult(q, n, p);
+	return q;
+};
+nacl.box = {};
+nacl.box.keyPair = function() {
+	var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);
+	var sk = new Uint8Array(crypto_box_SECRETKEYBYTES);
+	crypto_box_keypair(pk, sk);
+	return {
+		publicKey: pk,
+		secretKey: sk
+	};
+};
+nacl.box.keyPair.fromSecretKey = function(secretKey) {
+	checkArrayTypes(secretKey);
+	if (secretKey.length !== crypto_box_SECRETKEYBYTES) throw new Error("bad secret key size");
+	var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);
+	crypto_scalarmult_base(pk, secretKey);
+	return {
+		publicKey: pk,
+		secretKey: new Uint8Array(secretKey)
+	};
+};
+nacl.sign = function(msg, secretKey) {
+	checkArrayTypes(msg, secretKey);
+	if (secretKey.length !== crypto_sign_SECRETKEYBYTES) throw new Error("bad secret key size");
+	var signedMsg = new Uint8Array(crypto_sign_BYTES + msg.length);
+	crypto_sign(signedMsg, msg, msg.length, secretKey);
+	return signedMsg;
+};
+nacl.sign.detached = function(msg, secretKey) {
+	var signedMsg = nacl.sign(msg, secretKey);
+	var sig = new Uint8Array(crypto_sign_BYTES);
+	for (var i = 0; i < sig.length; i++) sig[i] = signedMsg[i];
+	return sig;
+};
+nacl.sign.detached.verify = function(msg, sig, publicKey) {
+	checkArrayTypes(msg, sig, publicKey);
+	if (sig.length !== crypto_sign_BYTES) throw new Error("bad signature size");
+	if (publicKey.length !== crypto_sign_PUBLICKEYBYTES) throw new Error("bad public key size");
+	var sm = new Uint8Array(crypto_sign_BYTES + msg.length);
+	var m = new Uint8Array(crypto_sign_BYTES + msg.length);
+	var i = 0;
+	for (; i < crypto_sign_BYTES; i++) sm[i] = sig[i];
+	for (i = 0; i < msg.length; i++) sm[i + crypto_sign_BYTES] = msg[i];
+	return crypto_sign_open(m, sm, sm.length, publicKey) >= 0;
+};
+nacl.sign.keyPair = function() {
+	var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
+	var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
+	crypto_sign_keypair(pk, sk);
+	return {
+		publicKey: pk,
+		secretKey: sk
+	};
+};
+nacl.sign.keyPair.fromSecretKey = function(secretKey) {
+	checkArrayTypes(secretKey);
+	if (secretKey.length !== crypto_sign_SECRETKEYBYTES) throw new Error("bad secret key size");
+	var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
+	for (var i = 0; i < pk.length; i++) pk[i] = secretKey[32 + i];
+	return {
+		publicKey: pk,
+		secretKey: new Uint8Array(secretKey)
+	};
+};
+nacl.sign.keyPair.fromSeed = function(seed) {
+	checkArrayTypes(seed);
+	if (seed.length !== crypto_sign_SEEDBYTES) throw new Error("bad seed size");
+	var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
+	var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
+	for (var i = 0; i < 32; i++) sk[i] = seed[i];
+	crypto_sign_keypair(pk, sk, true);
+	return {
+		publicKey: pk,
+		secretKey: sk
+	};
+};
+nacl.setPRNG = function(fn) {
+	randombytes = fn;
+};
+(function() {
+	if (crypto && crypto.getRandomValues) {
+		var QUOTA = 65536;
+		nacl.setPRNG(function(x, n) {
+			var i, v = new Uint8Array(n);
+			for (i = 0; i < n; i += QUOTA) crypto.getRandomValues(v.subarray(i, i + Math.min(n - i, QUOTA)));
+			for (i = 0; i < n; i++) x[i] = v[i];
+			cleanup(v);
+		});
+	}
+})();
+//#endregion
+export { nacl as default };
+
+//# sourceMappingURL=nacl-fast-CDhNCYHs.js.map