glow.ts 1.1.2 → 1.1.4

package/dist/glow.es.js

@@ -1,993 +1,722 @@
-import { secretbox as k, box as f, randomBytes as K, hash as C } from "tweetnacl";
-import { Mutex as R } from "async-mutex";
-class o {
-  static toBase64(e) {
-    return typeof btoa < "u" ? btoa(this.decode_latin1(e)) : Buffer.from(this.decode_latin1(e), "latin1").toString("base64");
-  }
-  static fromBase64(e) {
-    return typeof btoa < "u" ? this.encode_latin1(atob(e)) : this.encode_latin1(Buffer.from(e, "base64").toString("latin1"));
-  }
-  static encode_latin1(e) {
-    const t = new Uint8Array(e.length);
-    for (let s = 0; s < e.length; s++) {
-      const n = e.charCodeAt(s);
-      if ((n & 255) !== n) throw { message: "Cannot encode string in Latin1", str: e };
-      t[s] = n & 255;
-    }
-    return t;
-  }
-  static decode_latin1(e) {
-    const t = [];
-    for (let s = 0; s < e.length; s++)
-      t.push(String.fromCharCode(e[s]));
-    return t.join("");
-  }
-  static toObject(e) {
-    return Array.from(e).reduce(
-      (t, [s, n]) => Object.assign(t, { [s]: n }),
-      {}
-    );
-  }
-}
-class B {
-  constructor() {
-    this.crypto_secretbox_KEYBYTES = k.keyLength, this.crypto_box_NONCEBYTES = f.nonceLength;
-  }
-  async crypto_secretbox_random_nonce() {
-    return K(k.nonceLength);
-  }
-  async crypto_secretbox(e, t, s) {
-    return k(e, t, s);
-  }
-  async crypto_secretbox_open(e, t, s) {
-    return k.open(e, t, s);
-  }
-  async crypto_box(e, t, s, n) {
-    return f(e, t, s, n);
-  }
-  async crypto_box_open(e, t, s, n) {
-    return f.open(e, t, s, n);
-  }
-  async crypto_box_random_nonce() {
-    return K(f.nonceLength);
-  }
-  async crypto_box_keypair() {
-    const e = f.keyPair();
-    return {
-      boxPk: e.publicKey,
-      boxSk: e.secretKey
-    };
-  }
-  async crypto_box_keypair_from_raw_sk(e) {
-    const t = f.keyPair.fromSecretKey(e);
-    return {
-      boxPk: t.publicKey,
-      boxSk: t.secretKey
-    };
-  }
-  async crypto_box_keypair_from_seed(e) {
-    return this.crypto_box_keypair_from_raw_sk(C(e).subarray(0, f.secretKeyLength));
-  }
-  async crypto_hash_sha256(e) {
-    const t = globalThis.crypto;
-    if (!t || !t.subtle)
-      throw new Error("Web Crypto API is not available. Please use a modern browser or Node.js 16+.");
-    const s = await t.subtle.digest("SHA-256", e);
-    return new Uint8Array(s);
-  }
-  async random_bytes(e) {
-    return K(e);
-  }
-  // Helper methods are based on `js-nacl` implementations
-  // https://github.com/tonyg/js-nacl/blob/cc70775cfc9d68a04905ca65c7f179b33a18066e/nacl_cooked.js
-  async encode_latin1(e) {
-    return o.encode_latin1(e);
-  }
-  async decode_latin1(e) {
-    return o.decode_latin1(e);
-  }
-  async encode_utf8(e) {
-    return this.encode_latin1(unescape(encodeURIComponent(e)));
-  }
-  async decode_utf8(e) {
-    return decodeURIComponent(escape(await this.decode_latin1(e)));
-  }
-  async to_hex(e) {
-    const t = [];
-    for (let s = 0; s < e.length; s++) {
-      const n = "0123456789abcdef";
-      t.push(n[e[s] >> 4 & 15]), t.push(n[e[s] & 15]);
-    }
-    return t.join("");
-  }
-  async from_hex(e) {
-    const t = new Uint8Array(e.length / 2);
-    for (let s = 0; s < e.length / 2; s++)
-      t[s] = parseInt(e.substr(2 * s, 2), 16);
-    return t;
-  }
-  /**
-   * h2(m) = sha256(sha256(64x0 + m))
-   * Zero out initial sha256 block, and double hash 0-padded message
-   * http://cs.nyu.edu/~dodis/ps/h-of-h.pdf
-   */
-  async h2(e) {
-    e instanceof Uint8Array || (e = await this.encode_latin1(e));
-    const t = 64, s = new Uint8Array(t + e.length);
-    return s.fill(0), s.set(e, t), this.crypto_hash_sha256(await this.crypto_hash_sha256(s));
-  }
-}
-class h {
-  constructor() {
-  }
-  static setDefaultInstance() {
-    return this.setInstance(new B());
-  }
-  static setInstance(e) {
-    if (this.driverInstance)
-      throw new Error("[NaCl] NaCl driver has been already set, it is supposed to be set only once");
-    return this.driverInstance = e, !0;
-  }
-  static getInstance() {
-    if (!this.driverInstance)
-      throw new Error("[NaCl] NaCl instance is not yet set");
-    return this.driverInstance;
-  }
-}
-class w {
-  constructor(e) {
-    if (this.keys = e, typeof e == "string") {
-      const { boxPk: t, boxSk: s } = JSON.parse(e);
-      this.keyPair = {
-        boxPk: o.fromBase64(t),
-        boxSk: o.fromBase64(s)
-      };
-    } else
-      this.keyPair = e;
-  }
-  static isEqual(e, t) {
-    return e.toString() === t.toString();
-  }
-  toString() {
-    return JSON.stringify({
-      boxPk: this.publicKey,
-      boxSk: this.privateKey
-    });
-  }
-  get publicKey() {
-    return o.toBase64(this.keyPair.boxPk);
-  }
-  get privateKey() {
-    return o.toBase64(this.keyPair.boxSk);
-  }
-}
-const v = 30 * 1e3, u = {
-  NONCE_TAG: "__nc",
-  SKEY_TAG: "storage_key",
-  STORAGE_ROOT: ".v1.stor.vlt12",
-  // Relay tokens, keys and hashes are 32 bytes
-  RELAY_TOKEN_LEN: 32,
-  // 5 min - Token expiration on the server side, matched with config.x.relay.token_timeout on Zax server
-  RELAY_TOKEN_TIMEOUT: 5 * 60 * 1e3 - v,
-  // 20 min - Session expiration on the server side, matched with config.x.relay.session_timeout on Zax server
-  RELAY_SESSION_TIMEOUT: 20 * 60 * 1e3 - v,
-  // 5 sec - Ajax request timeout
-  RELAY_AJAX_TIMEOUT: 5 * 1e3
+import { box as e, hash as t, randomBytes as n, secretbox as r } from "tweetnacl";
+import { Mutex as i } from "async-mutex";
+//#region src/utils/utils.ts
+var a = class {
+	static toBase64(e) {
+		return typeof btoa < "u" ? btoa(this.decode_latin1(e)) : Buffer.from(this.decode_latin1(e), "latin1").toString("base64");
+	}
+	static fromBase64(e) {
+		return typeof btoa < "u" ? this.encode_latin1(atob(e)) : this.encode_latin1(Buffer.from(e, "base64").toString("latin1"));
+	}
+	static encode_latin1(e) {
+		let t = new Uint8Array(e.length);
+		for (let n = 0; n < e.length; n++) {
+			let r = e.charCodeAt(n);
+			if ((r & 255) !== r) throw {
+				message: "Cannot encode string in Latin1",
+				str: e
+			};
+			t[n] = r & 255;
+		}
+		return t;
+	}
+	static decode_latin1(e) {
+		let t = [];
+		for (let n = 0; n < e.length; n++) t.push(String.fromCharCode(e[n]));
+		return t.join("");
+	}
+	static toObject(e) {
+		return Array.from(e).reduce((e, [t, n]) => Object.assign(e, { [t]: n }), {});
+	}
+}, o = class {
+	constructor() {
+		this.crypto_secretbox_KEYBYTES = r.keyLength, this.crypto_box_NONCEBYTES = e.nonceLength;
+	}
+	async crypto_secretbox_random_nonce() {
+		return n(r.nonceLength);
+	}
+	async crypto_secretbox(e, t, n) {
+		return r(e, t, n);
+	}
+	async crypto_secretbox_open(e, t, n) {
+		return r.open(e, t, n);
+	}
+	async crypto_box(t, n, r, i) {
+		return e(t, n, r, i);
+	}
+	async crypto_box_open(t, n, r, i) {
+		return e.open(t, n, r, i);
+	}
+	async crypto_box_random_nonce() {
+		return n(e.nonceLength);
+	}
+	async crypto_box_keypair() {
+		let t = e.keyPair();
+		return {
+			boxPk: t.publicKey,
+			boxSk: t.secretKey
+		};
+	}
+	async crypto_box_keypair_from_raw_sk(t) {
+		let n = e.keyPair.fromSecretKey(t);
+		return {
+			boxPk: n.publicKey,
+			boxSk: n.secretKey
+		};
+	}
+	async crypto_box_keypair_from_seed(n) {
+		return this.crypto_box_keypair_from_raw_sk(t(n).subarray(0, e.secretKeyLength));
+	}
+	async crypto_hash_sha256(e) {
+		let t = globalThis.crypto;
+		if (!t || !t.subtle) throw Error("Web Crypto API is not available. Please use a modern browser or Node.js 16+.");
+		let n = await t.subtle.digest("SHA-256", e);
+		return new Uint8Array(n);
+	}
+	async random_bytes(e) {
+		return n(e);
+	}
+	async encode_latin1(e) {
+		return a.encode_latin1(e);
+	}
+	async decode_latin1(e) {
+		return a.decode_latin1(e);
+	}
+	async encode_utf8(e) {
+		return this.encode_latin1(unescape(encodeURIComponent(e)));
+	}
+	async decode_utf8(e) {
+		return decodeURIComponent(escape(await this.decode_latin1(e)));
+	}
+	async to_hex(e) {
+		let t = [];
+		for (let n = 0; n < e.length; n++) {
+			let r = "0123456789abcdef";
+			t.push(r[e[n] >> 4 & 15]), t.push(r[e[n] & 15]);
+		}
+		return t.join("");
+	}
+	async from_hex(e) {
+		let t = new Uint8Array(e.length / 2);
+		for (let n = 0; n < e.length / 2; n++) t[n] = parseInt(e.substr(2 * n, 2), 16);
+		return t;
+	}
+	async h2(e) {
+		e instanceof Uint8Array || (e = await this.encode_latin1(e));
+		let t = new Uint8Array(64 + e.length);
+		return t.fill(0), t.set(e, 64), this.crypto_hash_sha256(await this.crypto_hash_sha256(t));
+	}
+}, s = class {
+	constructor() {}
+	static setDefaultInstance() {
+		return this.setInstance(new o());
+	}
+	static setInstance(e) {
+		if (this.driverInstance) throw Error("[NaCl] NaCl driver has been already set, it is supposed to be set only once");
+		return this.driverInstance = e, !0;
+	}
+	static getInstance() {
+		if (!this.driverInstance) throw Error("[NaCl] NaCl instance is not yet set");
+		return this.driverInstance;
+	}
+}, c = class {
+	constructor(e) {
+		if (this.keys = e, typeof e == "string") {
+			let { boxPk: t, boxSk: n } = JSON.parse(e);
+			this.keyPair = {
+				boxPk: a.fromBase64(t),
+				boxSk: a.fromBase64(n)
+			};
+		} else this.keyPair = e;
+	}
+	static isEqual(e, t) {
+		return e.toString() === t.toString();
+	}
+	toString() {
+		return JSON.stringify({
+			boxPk: this.publicKey,
+			boxSk: this.privateKey
+		});
+	}
+	get publicKey() {
+		return a.toBase64(this.keyPair.boxPk);
+	}
+	get privateKey() {
+		return a.toBase64(this.keyPair.boxSk);
+	}
+}, l = 30 * 1e3, u = {
+	NONCE_TAG: "__nc",
+	SKEY_TAG: "storage_key",
+	STORAGE_ROOT: ".v1.stor.vlt12",
+	RELAY_TOKEN_LEN: 32,
+	RELAY_TOKEN_TIMEOUT: 300 * 1e3 - l,
+	RELAY_SESSION_TIMEOUT: 1200 * 1e3 - l,
+	RELAY_AJAX_TIMEOUT: 5 * 1e3
+}, d = class {
+	constructor(e = "storage.") {
+		this.rootTag = `__glow.${e}`;
+	}
+	async get(e) {
+		return (await this.getMultiple([e]))[0];
+	}
+	async getMultiple(e) {
+		return e.map((e) => localStorage.getItem(this.tag(e)) || null);
+	}
+	async set(e, t) {
+		return this.setMultiple({ [e]: t });
+	}
+	async setMultiple(e) {
+		for (let t in e) {
+			let n = e[t];
+			n !== null && localStorage.setItem(this.tag(t), n);
+		}
+	}
+	async remove(e) {
+		this.removeMultiple([e]);
+	}
+	async removeMultiple(e) {
+		e.forEach((e) => localStorage.removeItem(this.tag(e)));
+	}
+	tag(e) {
+		return `${this.rootTag}.${e}`;
+	}
+}, f = class e {
+	constructor(e, t) {
+		let n = s.getInstance();
+		this.nacl = n, this.driver = e, this.id = t ? `.${t}${u.STORAGE_ROOT}` : u.STORAGE_ROOT;
+	}
+	static async new(t) {
+		let n = this.getStorageDriver(), r = new e(n, t), i = r.addPrefix(u.SKEY_TAG), o = await n.get(i);
+		if (o) {
+			let { key: e } = JSON.parse(o);
+			r.storageKey = a.fromBase64(e);
+		} else r.storageKey = await r.nacl.random_bytes(r.nacl.crypto_secretbox_KEYBYTES), await n.set(i, JSON.stringify({ key: a.toBase64(r.storageKey) }));
+		return r;
+	}
+	static getStorageDriver() {
+		if (this.storageDriver) return this.storageDriver;
+		throw Error("[CryptoStorage] StorageDriver instance is not yet set");
+	}
+	static setDefaultStorageDriver() {
+		return this.setStorageDriver(new d());
+	}
+	static setStorageDriver(e) {
+		if (this.storageDriver) throw Error("[CryptoStorage] StorageDriver has been already set, it is supposed to be set only once");
+		return this.storageDriver = e, !0;
+	}
+	async save(e, t) {
+		if (!this.driver) throw Error("[CryptoStorage] Storage driver is not set");
+		if (!this.storageKey) throw Error("[CryptoStorage] Storage key is not set");
+		let n = JSON.stringify(t), r = await this.nacl.encode_utf8(n), i = await this.nacl.crypto_secretbox_random_nonce(), o = await this.nacl.crypto_secretbox(r, i, this.storageKey);
+		return await this.driver.setMultiple({
+			[this.addPrefix(e)]: a.toBase64(o),
+			[this.addNonceTag(e)]: a.toBase64(i)
+		}), !0;
+	}
+	async get(e) {
+		if (!this.driver) throw Error("[CryptoStorage] Storage driver is not set");
+		if (!this.storageKey) throw Error("[CryptoStorage] Storage key is not set");
+		let [t, n] = await this.driver.getMultiple([this.addPrefix(e), this.addNonceTag(e)]);
+		if (!t || !n) return null;
+		let r = a.fromBase64(t), i = a.fromBase64(n), o = await this.nacl.crypto_secretbox_open(r, i, this.storageKey);
+		if (o) {
+			let e = await this.nacl.decode_utf8(o);
+			return JSON.parse(e);
+		} else throw Error("[CryptoStorage] crypto_secretbox_open: decryption error");
+	}
+	async remove(e) {
+		if (!this.driver) throw Error("[CryptoStorage] Storage driver is not set");
+		return await this.driver.removeMultiple([this.addPrefix(e), this.addNonceTag(e)]), !0;
+	}
+	async selfDestruct() {
+		if (!this.driver) throw Error("[CryptoStorage] Storage driver is not set");
+		await this.driver.remove(this.addPrefix(u.SKEY_TAG));
+	}
+	addPrefix(e) {
+		return this.id ? e + this.id : e;
+	}
+	addNonceTag(e) {
+		return this.addPrefix(`${u.NONCE_TAG}.${e}`);
+	}
+}, p = "__::commKey::__", m = class e {
+	static {
+		this.commKeyTag = "comm_key";
+	}
+	static {
+		this.guestRegistryTag = "guest_registry";
+	}
+	constructor(e, t, n) {
+		this.guestKeys = /* @__PURE__ */ new Map(), this.nacl = e, this.storage = t, this.commKey = n;
+	}
+	static async new(t) {
+		let n = s.getInstance(), r = await f.new(t), i = new e(n, r, await e.getCommKeyOrCreate(n, r));
+		return await i.loadGuestKeys(), i;
+	}
+	static async fromBackup(t, n) {
+		let r = JSON.parse(n), i = a.fromBase64(r[p]), o = await e.new(t);
+		await o.setCommFromSecKey(i);
+		for (let [e, t] of Object.entries(r)) e !== p && await o.addGuest(e, t);
+		return o;
+	}
+	getNumberOfGuests() {
+		return this.guestKeys.size;
+	}
+	get guests() {
+		return this.guestKeys;
+	}
+	getPubCommKey() {
+		return this.commKey.publicKey;
+	}
+	getPrivateCommKey() {
+		return this.commKey.privateKey;
+	}
+	async getHpk() {
+		let e = await this.nacl.h2(a.fromBase64(this.commKey.publicKey));
+		return a.toBase64(e);
+	}
+	getTagByHpk(e) {
+		for (let [t, n] of this.guestKeys) if (n.hpk === e) return t;
+		return null;
+	}
+	getGuestKey(e) {
+		let t = this.guestKeys.get(e);
+		return t ? t.pk : null;
+	}
+	async backup() {
+		let e = { [p]: this.commKey.privateKey };
+		if (this.getNumberOfGuests() > 0) for (let [t, n] of this.guestKeys) t && n && (e[t] = n.pk);
+		return JSON.stringify(e);
+	}
+	async setCommFromSeed(t) {
+		this.commKey = new c(await this.nacl.crypto_box_keypair_from_seed(t)), await this.storage.save(e.commKeyTag, this.commKey.toString());
+	}
+	async setCommFromSecKey(t) {
+		this.commKey = new c(await this.nacl.crypto_box_keypair_from_raw_sk(t)), await this.storage.save(e.commKeyTag, this.commKey.toString());
+	}
+	async addGuest(e, t) {
+		let n = a.toBase64(await this.nacl.h2(a.fromBase64(t)));
+		return this.guestKeys.set(e, {
+			pk: t,
+			hpk: n
+		}), await this.saveGuests(), n;
+	}
+	async removeGuest(e) {
+		return this.guestKeys.has(e) && (this.guestKeys.delete(e), await this.saveGuests()), !0;
+	}
+	async loadGuestKeys() {
+		let t = await this.storage.get(e.guestRegistryTag);
+		if (t) if (typeof t == "object") this.guestKeys = new Map(Object.entries(t));
+		else throw Error("[Keyring] Guest keys is not an object");
+	}
+	async saveGuests() {
+		await this.storage.save(e.guestRegistryTag, a.toObject(this.guestKeys.entries()));
+	}
+	static async getCommKeyOrCreate(t, n) {
+		let r = await n.get(e.commKeyTag);
+		if (r && typeof r == "string") return new c(r);
+		{
+			let r = new c(await t.crypto_box_keypair());
+			return await n.save(e.commKeyTag, r.toString()), r;
+		}
+	}
+	async selfDestruct() {
+		await this.storage.remove(e.guestRegistryTag), await this.storage.remove(e.commKeyTag), await this.storage.selfDestruct();
+	}
+}, h = class e {
+	constructor() {}
+	static async encodeMessage(e, t, n, r) {
+		let i = s.getInstance(), o = await this.makeNonce(r), c = await i.crypto_box(e, o, t, n);
+		return {
+			nonce: a.toBase64(o),
+			ctext: a.toBase64(c)
+		};
+	}
+	static async decodeMessage(e, t, n, r) {
+		let i = s.getInstance(), a = await i.crypto_box_open(t, e, n, r);
+		return a && await i.decode_utf8(a);
+	}
+	static async encodeMessageSymmetric(t, n) {
+		let r = s.getInstance(), i = await e.makeNonce(), o = await r.crypto_secretbox(t, i, n);
+		return {
+			nonce: a.toBase64(i),
+			ctext: a.toBase64(o)
+		};
+	}
+	static async decodeMessageSymmetric(e, t, n) {
+		return await s.getInstance().crypto_secretbox_open(a.fromBase64(t), a.fromBase64(e), n);
+	}
+	static async makeNonce(e) {
+		let t = s.getInstance(), n = await t.crypto_box_random_nonce(), r;
+		if (n.length !== t.crypto_box_NONCEBYTES) throw Error("[Mailbox] Wrong crypto_box nonce length");
+		r = 8;
+		let i = this.itoa(Math.floor(Date.now() / 1e3));
+		if (e && (r += 4), n.fill(0, 0, r), n.set(i, 8 - i.length), e) {
+			let t = this.itoa(e);
+			n.set(t, 12 - t.length);
+		}
+		return n;
+	}
+	static itoa(e) {
+		let t = e.toString(16);
+		t = t.length & 1 ? `0${t}` : t;
+		let n = t.length / 2, r = new Uint8Array(n);
+		for (let e = 0, n = 0; n < t.length; n += 2, e++) r[e] = parseInt(t[n] + t[n + 1], 16);
+		return r;
+	}
+}, g = /* @__PURE__ */ function(e) {
+	return e.count = "count", e.upload = "upload", e.download = "download", e.messageStatus = "messageStatus", e.delete = "delete", e.startFileUpload = "startFileUpload", e.uploadFileChunk = "uploadFileChunk", e.downloadFileChunk = "downloadFileChunk", e.fileStatus = "fileStatus", e.deleteFile = "deleteFile", e;
+}({}), _ = /* @__PURE__ */ function(e) {
+	return e.message = "message", e.file = "file", e.plain = "plain", e;
+}({}), v = class extends Error {
+	constructor(e) {
+		super(`GlowNetworkError status: ${e}`), this.status = e, this.name = "GlowNetworkError";
+	}
+}, y = class {
+	constructor(e) {
+		this.url = e, this.difficulty = 0, this.nacl = s.getInstance();
+	}
+	get isConnected() {
+		return !!(this.sessionKeys && this.publicKey);
+	}
+	async openConnection() {
+		this.sessionKeys = new c(await this.nacl.crypto_box_keypair()), this.clientToken = await this.nacl.random_bytes(u.RELAY_TOKEN_LEN);
+		let e = await this.fetchRelayToken();
+		return this.publicKey = await this.fetchRelayPublicKey(e), {
+			h2Signature: await this.getSignature(e, this.sessionKeys),
+			relayPublicKey: this.publicKey
+		};
+	}
+	async fetchRelayToken() {
+		if (!this.clientToken) throw Error("[Relay] clientToken is required please openConnection first");
+		let e = await this.httpCall("start_session", a.toBase64(this.clientToken));
+		this.scheduleTokenExpiration();
+		let [t, n] = this.parseResponse("start_session", e);
+		return this.difficulty = parseInt(n, 10), this.difficulty > 10 && console.log(`[Relay] ${this.url} requested difficulty ${this.difficulty}. Session handshake may take longer.`), a.fromBase64(t);
+	}
+	async fetchRelayPublicKey(e) {
+		if (!this.clientToken) throw Error("[Relay] clientToken is required please openConnection first");
+		let t = a.toBase64(await this.nacl.h2(this.clientToken)), n = new Uint8Array([...this.clientToken, ...e]), r;
+		r = this.difficulty === 0 ? await this.nacl.h2(n) : await this.ensureNonceDifficulty(n);
+		let i = await this.httpCall("verify_session", t, a.toBase64(r));
+		return a.fromBase64(i);
+	}
+	async prove(e) {
+		if (!this.clientToken) throw Error("[Relay] clientToken is required please openConnection first");
+		if (!this.sessionKeys) throw Error("[Relay] No session key found, open the connection first");
+		let t = a.toBase64(await this.nacl.h2(this.clientToken)), n = await this.httpCall("prove", t, this.sessionKeys.publicKey, e.nonce, e.ctext);
+		return this.scheduleSessionExpiration(), n;
+	}
+	async encodeMessage(e) {
+		if (!this.publicKey) throw Error("[Relay] No relay public key found, open the connection first");
+		if (!this.sessionKeys) throw Error("[Relay] No session key found, open the connection first");
+		return await h.encodeMessage(await this.nacl.encode_utf8(e), this.publicKey, a.fromBase64(this.sessionKeys?.privateKey));
+	}
+	async decodeMessage(e, t) {
+		let n = this.publicKey;
+		if (!n) throw Error("[Relay] No relay public key found, open the connection first");
+		if (!this.sessionKeys) throw Error("[Relay] No session key found, open the connection first");
+		let r = await h.decodeMessage(a.fromBase64(e), a.fromBase64(t), n, a.fromBase64(this.sessionKeys.privateKey));
+		if (r === null) throw Error("[Relay] failed to decode message");
+		return JSON.parse(r);
+	}
+	async runCmd(e, t, n, r) {
+		if (!Object.keys(g).includes(e)) throw Error(`[Relay] ${this.url} doesn't support command ${e}`);
+		let i = [
+			t,
+			n.nonce,
+			n.ctext
+		];
+		r && i.push(r);
+		let a = await this.httpCall("command", ...i);
+		return this.parseResponse(e, a);
+	}
+	async getSignature(e, t) {
+		if (!this.clientToken) throw Error("[Relay] clientToken is required please openConnection first");
+		let n = a.fromBase64(t.publicKey), r = new Uint8Array([
+			...n,
+			...e,
+			...this.clientToken
+		]);
+		return await this.nacl.h2(r);
+	}
+	async httpCall(e, ...t) {
+		let n = new AbortController(), r = setTimeout(() => n.abort(), u.RELAY_AJAX_TIMEOUT), i = {
+			method: "POST",
+			headers: {
+				Accept: "text/plain",
+				"Content-Type": "text/plain"
+			},
+			body: t.join("\r\n"),
+			signal: n.signal
+		};
+		try {
+			let t = await fetch(`${this.url}/${e}`, i);
+			if (!t.ok) throw t.status === 401 && (this.clearSession(), this.clearToken()), new v(t.status);
+			return await t.text();
+		} catch (e) {
+			throw e instanceof Error && e.name === "AbortError" ? new v(408) : e instanceof v ? e : e instanceof TypeError ? new v(0) : e;
+		} finally {
+			clearTimeout(r);
+		}
+	}
+	parseResponse(e, t) {
+		let n = t.split("\r\n");
+		if (!t || !this.validateResponse(e, n.length)) throw console.log(n), Error(`[Relay] ${this.url} - ${e}: Bad response`);
+		return n;
+	}
+	validateResponse(e, t) {
+		switch (e) {
+			case g.upload:
+			case g.messageStatus:
+			case g.delete: return t === 1;
+			case g.downloadFileChunk: return t === 3;
+			default: return t === 2;
+		}
+	}
+	scheduleTokenExpiration() {
+		this.tokenExpirationTimeoutHandle && clearTimeout(this.tokenExpirationTimeoutHandle), this.tokenExpirationTimeoutHandle = setTimeout(() => this.clearToken(), u.RELAY_TOKEN_TIMEOUT);
+	}
+	clearToken() {
+		this.tokenExpirationTimeoutHandle && clearTimeout(this.tokenExpirationTimeoutHandle), this.clientToken && delete this.clientToken;
+	}
+	scheduleSessionExpiration() {
+		this.sessionExpirationTimeoutHandle && clearTimeout(this.sessionExpirationTimeoutHandle), this.sessionExpirationTimeoutHandle = setTimeout(() => {
+			this.clearSession();
+		}, u.RELAY_SESSION_TIMEOUT);
+	}
+	clearSession() {
+		this.sessionExpirationTimeoutHandle && clearTimeout(this.sessionExpirationTimeoutHandle), this.sessionKeys && delete this.sessionKeys;
+	}
+	async ensureNonceDifficulty(e) {
+		let t, n;
+		do
+			t = await this.nacl.random_bytes(32), n = await this.nacl.h2(new Uint8Array([...e, ...t]));
+		while (!this.arrayZeroBits(n));
+		return t;
+	}
+	arrayZeroBits(e) {
+		let t, n = this.difficulty;
+		for (let r = 0; r <= 1 + this.difficulty / 8; r++) {
+			if (t = e[r], n <= 0) return !0;
+			if (n > 8) {
+				if (n -= 8, t > 0) return !1;
+			} else return this.firstZeroBits(t, n);
+		}
+		return !1;
+	}
+	firstZeroBits(e, t) {
+		return e === e >> t << t;
+	}
+}, b = class {
+	constructor() {
+		this.relays = {};
+	}
+	getInstance(e) {
+		let t = this.relays[e];
+		return t ||= this.relays[e] = new y(e), t;
+	}
+}, x = class e {
+	constructor(e, t, n) {
+		this.relayFactory = new b(), this.relayConnectionMutexes = /* @__PURE__ */ new Map(), this.nacl = e, this.keyRing = t, this.identity = n;
+	}
+	static async new(t) {
+		return new e(s.getInstance(), await m.new(t), t);
+	}
+	static async fromSeed(e, t) {
+		let n = await this.new(e);
+		return t instanceof Uint8Array || (t = a.encode_latin1(t)), await n.keyRing.setCommFromSeed(t), n;
+	}
+	static async fromSecKey(e, t) {
+		let n = await this.new(e);
+		return t instanceof Uint8Array || (t = a.fromBase64(t)), await n.keyRing.setCommFromSecKey(t), n;
+	}
+	static async fromBackup(t, n) {
+		return new e(s.getInstance(), await m.fromBackup(t, n), t);
+	}
+	async upload(e, t, n, r = !0) {
+		let i = await this.prepareRelay(e), o = this.getGuestKey(t), s = r ? await this.encodeMessage(t, n) : n, c = a.toBase64(await this.nacl.h2(a.fromBase64(o))), [l] = await this.runRelayCommand(i, g.upload, {
+			to: c,
+			payload: s
+		});
+		return l;
+	}
+	async download(e) {
+		let t = await this.prepareRelay(e), n = await this.runRelayCommand(t, g.download), r = await this.decryptResponse(t, n), i = [];
+		for (let e of r) {
+			let t = this.keyRing.getTagByHpk(e.from);
+			if (!t) i.push(await this.parsePlainMessage(e));
+			else if (e.kind === "message") i.push(await this.parseTextMessage(e, t));
+			else if (e.kind === "file") i.push(await this.parseFileMessage(e, t));
+			else throw Error("[Mailbox] download - Unknown message type");
+		}
+		return i;
+	}
+	async parsePlainMessage({ data: e, time: t, from: n, nonce: r }) {
+		return {
+			data: e,
+			time: t,
+			from: n,
+			nonce: r,
+			kind: _.plain
+		};
+	}
+	async parseFileMessage(e, t) {
+		let { nonce: n, ctext: r, uploadID: i } = JSON.parse(e.data), a = await this.decodeMessage(t, n, r);
+		if (a === null) throw Error("[Mailbox] Failed to decode file message");
+		return {
+			data: JSON.parse(a),
+			time: e.time,
+			senderTag: t,
+			uploadID: i,
+			nonce: n,
+			kind: _.file
+		};
+	}
+	async parseTextMessage(e, t) {
+		let n = await this.decodeMessage(t, e.nonce, e.data);
+		return n ||= e.data, {
+			data: n,
+			time: e.time,
+			senderTag: t,
+			nonce: e.nonce,
+			kind: _.message
+		};
+	}
+	async count(e) {
+		let t = await this.prepareRelay(e), n = await this.runRelayCommand(t, g.count);
+		return await this.decryptResponse(t, n);
+	}
+	async delete(e, t) {
+		let n = await this.prepareRelay(e), [r] = await this.runRelayCommand(n, g.delete, { payload: t });
+		return parseInt(r, 10);
+	}
+	async messageStatus(e, t) {
+		let n = await this.prepareRelay(e), [r] = await this.runRelayCommand(n, g.messageStatus, { token: t });
+		return parseInt(r, 10);
+	}
+	async startFileUpload(e, t, n) {
+		let r = await this.prepareRelay(e), i = this.getGuestKey(t), o = a.toBase64(await this.nacl.h2(a.fromBase64(i))), s = await this.nacl.random_bytes(this.nacl.crypto_secretbox_KEYBYTES);
+		n.skey = a.toBase64(s);
+		let c = await this.encodeMessage(t, JSON.stringify(n)), l = await this.runRelayCommand(r, g.startFileUpload, {
+			to: o,
+			file_size: n.orig_size,
+			metadata: c
+		}), u = await this.decryptResponse(r, l);
+		return u.skey = s, u;
+	}
+	async uploadFileChunk(e, t, n, r, i, a) {
+		let o = await this.prepareRelay(e), s = await h.encodeMessageSymmetric(n, a), c = await this.runRelayCommand(o, g.uploadFileChunk, {
+			uploadID: t,
+			part: r,
+			last_chunk: i - 1 === r,
+			nonce: s.nonce
+		}, s.ctext);
+		return await this.decryptResponse(o, c);
+	}
+	async getFileStatus(e, t) {
+		let n = await this.prepareRelay(e), r = await this.runRelayCommand(n, g.fileStatus, { uploadID: t });
+		return await this.decryptResponse(n, r);
+	}
+	async getFileMetadata(e, t) {
+		return (await this.download(e)).filter((e) => e.kind === "file").find((e) => e.uploadID === t)?.data;
+	}
+	async downloadFileChunk(e, t, n, r) {
+		r instanceof Uint8Array || (r = a.fromBase64(r));
+		let i = await this.prepareRelay(e), [o, s, c] = await this.runRelayCommand(i, g.downloadFileChunk, {
+			uploadID: t,
+			part: n
+		}), l = await i.decodeMessage(o, s);
+		return await h.decodeMessageSymmetric(l.nonce, c, r);
+	}
+	async deleteFile(e, t) {
+		let n = await this.prepareRelay(e), r = await this.runRelayCommand(n, g.deleteFile, { uploadID: t });
+		return await this.decryptResponse(n, r);
+	}
+	async connectToRelay(e) {
+		let t = this.relayFactory.getInstance(e), n = await t.openConnection(), r = await this.encryptSignature(n), i = await t.prove(await t.encodeMessage(JSON.stringify({
+			pub_key: this.keyRing.getPubCommKey(),
+			nonce: r.nonce,
+			ctext: r.ctext
+		})));
+		return parseInt(i, 10);
+	}
+	clearSession(e) {
+		let t = this.relayFactory.getInstance(e);
+		t.clearToken(), t.clearSession();
+	}
+	async encryptSignature(e) {
+		let t = a.fromBase64(this.keyRing.getPrivateCommKey());
+		return await h.encodeMessage(e.h2Signature, e.relayPublicKey, t);
+	}
+	async prepareRelay(e) {
+		let t = this.relayFactory.getInstance(e);
+		return await this.getRelayConnectionMutex(e).runExclusive(async () => {
+			t.isConnected || await this.connectToRelay(e);
+		}), t;
+	}
+	async runRelayCommand(e, t, n, r) {
+		n = {
+			cmd: t,
+			...n
+		};
+		let i = await this.keyRing.getHpk(), a = await e.encodeMessage(JSON.stringify(n));
+		return await e.runCmd(t, i, a, r);
+	}
+	async decryptResponse(e, t) {
+		let [n, r] = t;
+		return await e.decodeMessage(n, r);
+	}
+	async encodeMessage(e, t) {
+		let n = this.getGuestKey(e), r = this.keyRing.getPrivateCommKey();
+		return await h.encodeMessage(await this.nacl.encode_utf8(t), a.fromBase64(n), a.fromBase64(r));
+	}
+	async decodeMessage(e, t, n) {
+		let r = this.getGuestKey(e), i = this.keyRing.getPrivateCommKey(), o;
+		try {
+			o = a.fromBase64(n);
+		} catch {
+			return null;
+		}
+		return await h.decodeMessage(a.fromBase64(t), o, a.fromBase64(r), a.fromBase64(i));
+	}
+	getGuestKey(e) {
+		let t = this.keyRing.getGuestKey(e);
+		if (!t) throw Error(`[Mailbox] Unknown guest ${e}`);
+		return t;
+	}
+	async selfDestruct() {
+		await this.keyRing.selfDestruct();
+	}
+	getRelayConnectionMutex(e) {
+		return this.relayConnectionMutexes.has(e) || this.relayConnectionMutexes.set(e, new i()), this.relayConnectionMutexes.get(e);
+	}
+}, S = class {
+	constructor() {
+		this.storage = {};
+	}
+	async get(e) {
+		return (await this.getMultiple([e]))[0];
+	}
+	async getMultiple(e) {
+		return e.map((e) => this.storage[e]);
+	}
+	set(e, t) {
+		return this.setMultiple({ [e]: t });
+	}
+	async setMultiple(e) {
+		for (let t in e) this.storage[t] = e[t];
+	}
+	remove(e) {
+		return this.removeMultiple([e]);
+	}
+	async removeMultiple(e) {
+		e.forEach((e) => delete this.storage[e]);
+	}
+	reset() {
+		this.storage = {};
+	}
 };
-class M {
-  constructor(e = "storage.") {
-    this.rootTag = `__glow.${e}`;
-  }
-  async get(e) {
-    return (await this.getMultiple([e]))[0];
-  }
-  async getMultiple(e) {
-    return e.map((t) => localStorage.getItem(this.tag(t)) || null);
-  }
-  async set(e, t) {
-    return this.setMultiple({ [e]: t });
-  }
-  async setMultiple(e) {
-    for (const t in e) {
-      const s = e[t];
-      s !== null && localStorage.setItem(this.tag(t), s);
-    }
-  }
-  async remove(e) {
-    this.removeMultiple([e]);
-  }
-  async removeMultiple(e) {
-    e.forEach((t) => localStorage.removeItem(this.tag(t)));
-  }
-  tag(e) {
-    return `${this.rootTag}.${e}`;
-  }
-}
-class E {
-  constructor(e, t) {
-    const s = h.getInstance();
-    this.nacl = s, this.driver = e, this.id = t ? `.${t}${u.STORAGE_ROOT}` : u.STORAGE_ROOT;
-  }
-  static async new(e) {
-    const t = this.getStorageDriver(), s = new E(t, e), n = s.addPrefix(u.SKEY_TAG), r = await t.get(n);
-    if (r) {
-      const { key: a } = JSON.parse(r);
-      s.storageKey = o.fromBase64(a);
-    } else
-      s.storageKey = await s.nacl.random_bytes(s.nacl.crypto_secretbox_KEYBYTES), await t.set(n, JSON.stringify({ key: o.toBase64(s.storageKey) }));
-    return s;
-  }
-  static getStorageDriver() {
-    if (this.storageDriver)
-      return this.storageDriver;
-    throw new Error("[CryptoStorage] StorageDriver instance is not yet set");
-  }
-  static setDefaultStorageDriver() {
-    return this.setStorageDriver(new M());
-  }
-  static setStorageDriver(e) {
-    if (this.storageDriver)
-      throw new Error("[CryptoStorage] StorageDriver has been already set, it is supposed to be set only once");
-    return this.storageDriver = e, !0;
-  }
-  async save(e, t) {
-    if (!this.driver)
-      throw new Error("[CryptoStorage] Storage driver is not set");
-    if (!this.storageKey)
-      throw new Error("[CryptoStorage] Storage key is not set");
-    const s = JSON.stringify(t), n = await this.nacl.encode_utf8(s), r = await this.nacl.crypto_secretbox_random_nonce(), a = await this.nacl.crypto_secretbox(n, r, this.storageKey);
-    return await this.driver.setMultiple({
-      [this.addPrefix(e)]: o.toBase64(a),
-      [this.addNonceTag(e)]: o.toBase64(r)
-    }), !0;
-  }
-  async get(e) {
-    if (!this.driver)
-      throw new Error("[CryptoStorage] Storage driver is not set");
-    if (!this.storageKey)
-      throw new Error("[CryptoStorage] Storage key is not set");
-    const [t, s] = await this.driver.getMultiple([this.addPrefix(e), this.addNonceTag(e)]);
-    if (!t || !s)
-      return null;
-    const n = o.fromBase64(t), r = o.fromBase64(s), a = await this.nacl.crypto_secretbox_open(n, r, this.storageKey);
-    if (a) {
-      const c = await this.nacl.decode_utf8(a);
-      return JSON.parse(c);
-    } else
-      throw new Error("[CryptoStorage] crypto_secretbox_open: decryption error");
-  }
-  async remove(e) {
-    if (!this.driver)
-      throw new Error("[CryptoStorage] Storage driver is not set");
-    return await this.driver.removeMultiple([this.addPrefix(e), this.addNonceTag(e)]), !0;
-  }
-  async selfDestruct() {
-    if (!this.driver)
-      throw new Error("[CryptoStorage] Storage driver is not set");
-    await this.driver.remove(this.addPrefix(u.SKEY_TAG));
-  }
-  // Keys are tagged in the storage with a versioned prefix
-  addPrefix(e) {
-    return this.id ? e + this.id : e;
-  }
-  addNonceTag(e) {
-    return this.addPrefix(`${u.NONCE_TAG}.${e}`);
-  }
-}
-const T = "__::commKey::__", y = class y {
-  constructor(e, t, s) {
-    this.guestKeys = /* @__PURE__ */ new Map(), this.nacl = e, this.storage = t, this.commKey = s;
-  }
-  static async new(e) {
-    const t = h.getInstance(), s = await E.new(e), n = await y.getCommKeyOrCreate(t, s), r = new y(t, s, n);
-    return await r.loadGuestKeys(), r;
-  }
-  static async fromBackup(e, t) {
-    const s = JSON.parse(t), n = o.fromBase64(s[T]), r = await y.new(e);
-    await r.setCommFromSecKey(n);
-    for (const [a, c] of Object.entries(s))
-      a !== T && await r.addGuest(a, c);
-    return r;
-  }
-  getNumberOfGuests() {
-    return this.guestKeys.size;
-  }
-  get guests() {
-    return this.guestKeys;
-  }
-  /**
-   * Returns public identity, which is the default communication key.
-   * Correspondents can know it, whereas Relays do not need it (other than
-   * temporarily for internal use during the ownership proof)
-   */
-  getPubCommKey() {
-    return this.commKey.publicKey;
-  }
-  getPrivateCommKey() {
-    return this.commKey.privateKey;
-  }
-  /**
-   * Returns HPK (hash of the public key) of the mailbox. This is what Zax relays
-   * uses as the universal address of the mailbox
-   */
-  async getHpk() {
-    const e = await this.nacl.h2(o.fromBase64(this.commKey.publicKey));
-    return o.toBase64(e);
-  }
-  getTagByHpk(e) {
-    for (const [t, s] of this.guestKeys)
-      if (s.hpk === e)
-        return t;
-    return null;
-  }
-  getGuestKey(e) {
-    const t = this.guestKeys.get(e);
-    return t ? t.pk : null;
-  }
-  // Backups
-  async backup() {
-    const e = {
-      [T]: this.commKey.privateKey
-    };
-    if (this.getNumberOfGuests() > 0)
-      for (const [t, s] of this.guestKeys)
-        t && s && (e[t] = s.pk);
-    return JSON.stringify(e);
-  }
-  async setCommFromSeed(e) {
-    this.commKey = new w(await this.nacl.crypto_box_keypair_from_seed(e)), await this.storage.save(y.commKeyTag, this.commKey.toString());
-  }
-  async setCommFromSecKey(e) {
-    this.commKey = new w(await this.nacl.crypto_box_keypair_from_raw_sk(e)), await this.storage.save(y.commKeyTag, this.commKey.toString());
-  }
-  async addGuest(e, t) {
-    const s = o.toBase64(await this.nacl.h2(o.fromBase64(t)));
-    return this.guestKeys.set(e, {
-      pk: t,
-      hpk: s
-    }), await this.saveGuests(), s;
-  }
-  async removeGuest(e) {
-    return this.guestKeys.has(e) && (this.guestKeys.delete(e), await this.saveGuests()), !0;
-  }
-  async loadGuestKeys() {
-    const e = await this.storage.get(y.guestRegistryTag);
-    if (e)
-      if (typeof e == "object")
-        this.guestKeys = new Map(Object.entries(e));
-      else
-        throw new Error("[Keyring] Guest keys is not an object");
-    else return;
-  }
-  async saveGuests() {
-    await this.storage.save(y.guestRegistryTag, o.toObject(this.guestKeys.entries()));
-  }
-  static async getCommKeyOrCreate(e, t) {
-    const s = await t.get(y.commKeyTag);
-    if (s && typeof s == "string")
-      return new w(s);
-    {
-      const n = await e.crypto_box_keypair(), r = new w(n);
-      return await t.save(y.commKeyTag, r.toString()), r;
-    }
-  }
-  async selfDestruct() {
-    await this.storage.remove(y.guestRegistryTag), await this.storage.remove(y.commKeyTag), await this.storage.selfDestruct();
-  }
-};
-y.commKeyTag = "comm_key", y.guestRegistryTag = "guest_registry";
-let S = y;
-class p {
-  constructor() {
-  }
-  /**
-   * Encodes a binary message with `cryptobox`
-   */
-  static async encodeMessage(e, t, s, n) {
-    const r = h.getInstance(), a = await this.makeNonce(n), c = await r.crypto_box(e, a, t, s);
-    return {
-      nonce: o.toBase64(a),
-      ctext: o.toBase64(c)
-    };
-  }
-  /**
-   * Decodes a binary message with `cryptobox_open`
-   * @returns null if failed to decode
-   */
-  static async decodeMessage(e, t, s, n) {
-    const r = h.getInstance(), a = await r.crypto_box_open(t, e, s, n);
-    return a && await r.decode_utf8(a);
-  }
-  /**
-   * Encodes a binary message with `secretbox` (used for file chunk encryption)
-   */
-  static async encodeMessageSymmetric(e, t) {
-    const s = h.getInstance(), n = await p.makeNonce(), r = await s.crypto_secretbox(e, n, t);
-    return {
-      nonce: o.toBase64(n),
-      ctext: o.toBase64(r)
-    };
-  }
-  /**
-   * Decodes a binary message with `secretbox_open` (used for file chunk decryption)
-   */
-  static async decodeMessageSymmetric(e, t, s) {
-    return await h.getInstance().crypto_secretbox_open(o.fromBase64(t), o.fromBase64(e), s);
-  }
-  // ---------- Nonce helper ----------
-  /**
-   * Makes a timestamp nonce that a relay expects for any crypto operations.
-   * Timestamp is the first 8 bytes, the rest is random, unless custom `data`
-   * is specified. `data` will be packed as next 4 bytes after timestamp.
-   */
-  static async makeNonce(e) {
-    const t = h.getInstance(), s = await t.crypto_box_random_nonce();
-    let n;
-    if (s.length !== t.crypto_box_NONCEBYTES)
-      throw new Error("[Mailbox] Wrong crypto_box nonce length");
-    n = 8;
-    const r = this.itoa(Math.floor(Date.now() / 1e3));
-    if (e && (n += 4), s.fill(0, 0, n), s.set(r, 8 - r.length), e) {
-      const a = this.itoa(e);
-      s.set(a, 12 - a.length);
-    }
-    return s;
-  }
-  /**
-   * Splits an integer into an array of bytes
-   */
-  static itoa(e) {
-    let t = e.toString(16);
-    t = t.length & 1 ? `0${t}` : t;
-    const s = t.length / 2, n = new Uint8Array(s);
-    for (let r = 0, a = 0; a < t.length; a += 2, r++)
-      n[r] = parseInt(t[a] + t[a + 1], 16);
-    return n;
-  }
-}
-var l = /* @__PURE__ */ ((i) => (i.count = "count", i.upload = "upload", i.download = "download", i.messageStatus = "messageStatus", i.delete = "delete", i.startFileUpload = "startFileUpload", i.uploadFileChunk = "uploadFileChunk", i.downloadFileChunk = "downloadFileChunk", i.fileStatus = "fileStatus", i.deleteFile = "deleteFile", i))(l || {}), b = /* @__PURE__ */ ((i) => (i.message = "message", i.file = "file", i.plain = "plain", i))(b || {});
-class _ extends Error {
-  constructor(e) {
-    super(`GlowNetworkError status: ${e}`), this.status = e, this.name = "GlowNetworkError";
-  }
-}
-class N {
-  constructor(e) {
-    this.url = e, this.difficulty = 0, this.nacl = h.getInstance();
-  }
-  get isConnected() {
-    return !!(this.sessionKeys && this.publicKey);
-  }
-  // ---------- Connection initialization ----------
-  /**
-   * Exchanges tokens with a relay and gets a temp session key for this relay.
-   * Returns h₂(signature) and a relay public key
-   */
-  async openConnection() {
-    this.sessionKeys = new w(await this.nacl.crypto_box_keypair()), this.clientToken = await this.nacl.random_bytes(u.RELAY_TOKEN_LEN);
-    const e = await this.fetchRelayToken();
-    return this.publicKey = await this.fetchRelayPublicKey(e), {
-      h2Signature: await this.getSignature(e, this.sessionKeys),
-      relayPublicKey: this.publicKey
-    };
-  }
-  /**
-   * Sends a client token to a relay and saves a relay token
-   */
-  async fetchRelayToken() {
-    if (!this.clientToken)
-      throw new Error("[Relay] clientToken is required please openConnection first");
-    const e = await this.httpCall("start_session", o.toBase64(this.clientToken));
-    this.scheduleTokenExpiration();
-    const [t, s] = this.parseResponse("start_session", e);
-    return this.difficulty = parseInt(s, 10), this.difficulty > 10 && console.log(`[Relay] ${this.url} requested difficulty ${this.difficulty}. Session handshake may take longer.`), o.fromBase64(t);
-  }
-  /**
-   * Completes the handshake and saves a relay pubic key
-   */
-  async fetchRelayPublicKey(e) {
-    if (!this.clientToken)
-      throw new Error("[Relay] clientToken is required please openConnection first");
-    const t = o.toBase64(await this.nacl.h2(this.clientToken)), s = new Uint8Array([...this.clientToken, ...e]);
-    let n;
-    this.difficulty === 0 ? n = await this.nacl.h2(s) : n = await this.ensureNonceDifficulty(s);
-    const r = await this.httpCall("verify_session", t, o.toBase64(n));
-    return o.fromBase64(r);
-  }
-  /**
-   * Attaches a mailbox and fetches number of messages
-   */
-  async prove(e) {
-    if (!this.clientToken)
-      throw new Error("[Relay] clientToken is required please openConnection first");
-    if (!this.sessionKeys)
-      throw new Error("[Relay] No session key found, open the connection first");
-    const t = o.toBase64(await this.nacl.h2(this.clientToken)), s = await this.httpCall(
-      "prove",
-      t,
-      this.sessionKeys.publicKey,
-      e.nonce,
-      e.ctext
-    );
-    return this.scheduleSessionExpiration(), s;
-  }
-  async encodeMessage(e) {
-    if (!this.publicKey)
-      throw new Error("[Relay] No relay public key found, open the connection first");
-    if (!this.sessionKeys)
-      throw new Error("[Relay] No session key found, open the connection first");
-    return await p.encodeMessage(
-      await this.nacl.encode_utf8(e),
-      this.publicKey,
-      o.fromBase64(this.sessionKeys?.privateKey)
-    );
-  }
-  async decodeMessage(e, t) {
-    const s = this.publicKey;
-    if (!s)
-      throw new Error("[Relay] No relay public key found, open the connection first");
-    if (!this.sessionKeys)
-      throw new Error("[Relay] No session key found, open the connection first");
-    const n = await p.decodeMessage(
-      o.fromBase64(e),
-      o.fromBase64(t),
-      s,
-      o.fromBase64(this.sessionKeys.privateKey)
-    );
-    if (n === null)
-      throw new Error("[Relay] failed to decode message");
-    return JSON.parse(n);
-  }
-  // ---------- Low-level server request handling ----------
-  /**
-   * Executes a message/file command on a relay, parses and validates the response
-   */
-  async runCmd(e, t, s, n) {
-    if (!Object.keys(l).includes(e))
-      throw new Error(`[Relay] ${this.url} doesn't support command ${e}`);
-    const r = [t, s.nonce, s.ctext];
-    n && r.push(n);
-    const a = await this.httpCall("command", ...r);
-    return this.parseResponse(e, a);
-  }
-  async getSignature(e, t) {
-    if (!this.clientToken)
-      throw new Error("[Relay] clientToken is required please openConnection first");
-    const s = o.fromBase64(t.publicKey), n = new Uint8Array([...s, ...e, ...this.clientToken]);
-    return await this.nacl.h2(n);
-  }
-  /**
-   * Executes a call to a relay and return raw string response
-   */
-  // TODO: extract fetching into separate function
-  async httpCall(e, ...t) {
-    const s = new AbortController(), n = setTimeout(() => s.abort(), u.RELAY_AJAX_TIMEOUT), r = {
-      method: "POST",
-      headers: {
-        Accept: "text/plain",
-        "Content-Type": "text/plain"
-      },
-      body: t.join(`\r
-`),
-      signal: s.signal
-    };
-    try {
-      const a = await fetch(`${this.url}/${e}`, r);
-      if (!a.ok)
-        throw a.status === 401 && (this.clearSession(), this.clearToken()), new _(a.status);
-      return await a.text();
-    } catch (a) {
-      throw a instanceof Error && a.name === "AbortError" ? new _(408) : a instanceof _ ? a : a instanceof TypeError ? new _(0) : a;
-    } finally {
-      clearTimeout(n);
-    }
-  }
-  /**
-   * Parses relay response and throws an error if its format is unexpected
-   */
-  parseResponse(e, t) {
-    const s = t.split(`\r
-`);
-    if (!t || !this.validateResponse(e, s.length))
-      throw console.log(s), new Error(`[Relay] ${this.url} - ${e}: Bad response`);
-    return s;
-  }
-  /**
-   * Compares the expected number of lines in response with what was actually received from a relay
-   */
-  validateResponse(e, t) {
-    switch (e) {
-      case l.upload:
-      case l.messageStatus:
-      case l.delete:
-        return t === 1;
-      case l.downloadFileChunk:
-        return t === 3;
-      default:
-        return t === 2;
-    }
-  }
-  /**
-   * delete token locally before it was removed on server so will reconnect without getting unauthorized error
-   */
-  scheduleTokenExpiration() {
-    this.tokenExpirationTimeoutHandle && clearTimeout(this.tokenExpirationTimeoutHandle), this.tokenExpirationTimeoutHandle = setTimeout(() => this.clearToken(), u.RELAY_TOKEN_TIMEOUT);
-  }
-  clearToken() {
-    this.tokenExpirationTimeoutHandle && clearTimeout(this.tokenExpirationTimeoutHandle), this.clientToken && delete this.clientToken;
-  }
-  /**
-   * established session is valid only for some period need to remove it after it's ttl
-   * so relay will reconnect without receiving error from server
-   */
-  scheduleSessionExpiration() {
-    this.sessionExpirationTimeoutHandle && clearTimeout(this.sessionExpirationTimeoutHandle), this.sessionExpirationTimeoutHandle = setTimeout(() => {
-      this.clearSession();
-    }, u.RELAY_SESSION_TIMEOUT);
-  }
-  clearSession() {
-    this.sessionExpirationTimeoutHandle && clearTimeout(this.sessionExpirationTimeoutHandle), this.sessionKeys && delete this.sessionKeys;
-  }
-  // ---------- Difficulty adjustment ----------
-  /**
-   * Continuously calculates the nonce until one requested by a relay is found
-   */
-  async ensureNonceDifficulty(e) {
-    let t, s;
-    do
-      t = await this.nacl.random_bytes(32), s = await this.nacl.h2(new Uint8Array([...e, ...t]));
-    while (!this.arrayZeroBits(s));
-    return t;
-  }
-  /**
-   * Returns `true` if the rightmost n bits of a byte are 0.
-   * Check whether the rightmost difficulty bits of an Uint8Array are 0, where
-   * the lowest indexes of the array represent those rightmost bits. Thus if
-   * the difficulty is 17, then array[0] and array[1] should be 0, as should the
-   * rightmost bit of array[2]. This is used for our difficulty settings in Zax to
-   * reduce burden on a busy server by ensuring clients have to do some
-   * additional work during the session handshake
-   */
-  arrayZeroBits(e) {
-    let t, s = this.difficulty;
-    for (let n = 0; n <= 1 + this.difficulty / 8; n++) {
-      if (t = e[n], s <= 0)
-        return !0;
-      if (s > 8) {
-        if (s -= 8, t > 0)
-          return !1;
-      } else
-        return this.firstZeroBits(t, s);
-    }
-    return !1;
-  }
-  /**
-   * Returns `true` if the rightmost n bits of a byte are 0
-   */
-  firstZeroBits(e, t) {
-    return e === e >> t << t;
-  }
-}
-class O {
-  constructor() {
-    this.relays = {};
-  }
-  /**
-   * Relay factory, that returns a Relay instance for a given URL,
-   * or creates a new one if it hasn't yet been initialized.
-   */
-  getInstance(e) {
-    let t = this.relays[e];
-    return t || (t = this.relays[e] = new N(e)), t;
-  }
-}
-class x {
-  constructor(e, t, s) {
-    this.relayFactory = new O(), this.relayConnectionMutexes = /* @__PURE__ */ new Map(), this.nacl = e, this.keyRing = t, this.identity = s;
-  }
-  static async new(e) {
-    return new x(h.getInstance(), await S.new(e), e);
-  }
-  // ---------- Alternative initializers ----------
-  /**
-   * Create a Mailbox where the secret identity key is derived from a well-known seed
-   */
-  static async fromSeed(e, t) {
-    const s = await this.new(e);
-    return t instanceof Uint8Array || (t = o.encode_latin1(t)), await s.keyRing.setCommFromSeed(t), s;
-  }
-  /**
-   * Create a Mailbox from the known secret identity key
-   */
-  static async fromSecKey(e, t) {
-    const s = await this.new(e);
-    return t instanceof Uint8Array || (t = o.fromBase64(t)), await s.keyRing.setCommFromSecKey(t), s;
-  }
-  /**
-   * Create a Mailbox from the backup string
-   */
-  static async fromBackup(e, t) {
-    return new x(h.getInstance(), await S.fromBackup(e, t), e);
-  }
-  // ---------- Relay message commands (public API) ----------
-  /**
-   * Sends a free-form object to a guest we already have in our keyring. Set `encrypt` to `false` to
-   * send a plaintext message. Returns a token that can be used with `messageStatus` command to check
-   * the status of the message
-   */
-  async upload(e, t, s, n = !0) {
-    const r = await this.prepareRelay(e), a = this.getGuestKey(t), c = n ? await this.encodeMessage(t, s) : s, d = o.toBase64(await this.nacl.h2(o.fromBase64(a))), [g] = await this.runRelayCommand(r, l.upload, { to: d, payload: c });
-    return g;
-  }
-  /**
-   * Downloads all messages from a relay, decrypts them with a relay key,
-   * and then parses each message to find out if it's a text message, file message,
-   * or if it can't be decrypted because HPK is missing in the keyring.
-   * Returns an array of mixed messages
-   */
-  async download(e) {
-    const t = await this.prepareRelay(e), s = await this.runRelayCommand(t, l.download), n = await this.decryptResponse(t, s), r = [];
-    for (const a of n) {
-      const c = this.keyRing.getTagByHpk(a.from);
-      if (!c)
-        r.push(await this.parsePlainMessage(a));
-      else if (a.kind === "message")
-        r.push(await this.parseTextMessage(a, c));
-      else if (a.kind === "file")
-        r.push(await this.parseFileMessage(a, c));
-      else
-        throw new Error("[Mailbox] download - Unknown message type");
-    }
-    return r;
-  }
-  /**
-   * Marks a raw Zax message as one that can't be decrypted,
-   * because sender's HPK is not found in the keyring
-   */
-  async parsePlainMessage({ data: e, time: t, from: s, nonce: n }) {
-    return { data: e, time: t, from: s, nonce: n, kind: b.plain };
-  }
-  /**
-   * Decrypts a message that represents uploaded file metadata
-   */
-  async parseFileMessage(e, t) {
-    const { nonce: s, ctext: n, uploadID: r } = JSON.parse(e.data), a = await this.decodeMessage(t, s, n);
-    if (a === null)
-      throw new Error("[Mailbox] Failed to decode file message");
-    return { data: JSON.parse(a), time: e.time, senderTag: t, uploadID: r, nonce: s, kind: b.file };
-  }
-  /**
-   * Attempts to decrypt a regular encrypted Zax message. Returns plain message if it was sent encrypted
-   */
-  async parseTextMessage(e, t) {
-    let s = await this.decodeMessage(t, e.nonce, e.data);
-    return s || (s = e.data), { data: s, time: e.time, senderTag: t, nonce: e.nonce, kind: b.message };
-  }
-  /**
-   * Returns the number of messages in the mailbox on a given relay
-   */
-  async count(e) {
-    const t = await this.prepareRelay(e), s = await this.runRelayCommand(t, l.count);
-    return await this.decryptResponse(t, s);
-  }
-  /**
-  * Deletes messages from a relay given a list of base64 message nonces,
-  * and returns the number of remaining messages
-  */
-  async delete(e, t) {
-    const s = await this.prepareRelay(e), [n] = await this.runRelayCommand(s, l.delete, { payload: t });
-    return parseInt(n, 10);
-  }
-  /**
-  * Gets the status of a previously sent Zax message by a storage token.
-  * Returns "time to live" in seconds or a negative value if it's not applicable.
-  * See `MessageStatusResponse` values for reference
-  */
-  async messageStatus(e, t) {
-    const s = await this.prepareRelay(e), [n] = await this.runRelayCommand(s, l.messageStatus, { token: t });
-    return parseInt(n, 10);
-  }
-  // ---------- Relay file commands (public API) ----------
-  /**
-   * Asks Zax to start a new upload session, and returns a unique file identifier
-   * required to upload file chunks.
-   */
-  async startFileUpload(e, t, s) {
-    const n = await this.prepareRelay(e), r = this.getGuestKey(t), a = o.toBase64(await this.nacl.h2(o.fromBase64(r))), c = await this.nacl.random_bytes(this.nacl.crypto_secretbox_KEYBYTES);
-    s.skey = o.toBase64(c);
-    const d = await this.encodeMessage(t, JSON.stringify(s)), g = await this.runRelayCommand(n, l.startFileUpload, {
-      to: a,
-      file_size: s.orig_size,
-      metadata: d
-    }), m = await this.decryptResponse(n, g);
-    return m.skey = c, m;
-  }
-  /**
-   * Encrypts the file chunk symmetrically and transfers it to a relay
-   */
-  async uploadFileChunk(e, t, s, n, r, a) {
-    const c = await this.prepareRelay(e), d = await p.encodeMessageSymmetric(s, a), g = await this.runRelayCommand(c, l.uploadFileChunk, {
-      uploadID: t,
-      part: n,
-      last_chunk: r - 1 === n,
-      // marker of the last chunk, sent only once
-      nonce: d.nonce
-    }, d.ctext);
-    return await this.decryptResponse(c, g);
-  }
-  /**
-   * Returns the status of a file upload by its relay-specific uploadID. Uploader can call it
-   * to verify the correct transfer, and downloader can check if the file exists and retrieve
-   * the number of chunks
-   */
-  async getFileStatus(e, t) {
-    const s = await this.prepareRelay(e), n = await this.runRelayCommand(s, l.fileStatus, { uploadID: t });
-    return await this.decryptResponse(s, n);
-  }
-  /**
-   * Fetches the file metadata by uploadID, which was declared by the uploader
-   */
-  async getFileMetadata(e, t) {
-    return (await this.download(e)).filter((r) => r.kind === "file").find((r) => r.uploadID === t)?.data;
-  }
-  /**
-   * Downloads a binary chunk of a file from a relay by a given uploadID. The total number of chunks
-   * can be retrieved via a `getFileStatus` request
-   */
-  async downloadFileChunk(e, t, s, n) {
-    n instanceof Uint8Array || (n = o.fromBase64(n));
-    const r = await this.prepareRelay(e), a = await this.runRelayCommand(r, l.downloadFileChunk, { uploadID: t, part: s }), [c, d, g] = a, m = await r.decodeMessage(c, d);
-    return await p.decodeMessageSymmetric(m.nonce, g, n);
-  }
-  /**
-   * Deletes a file from the relay (or all chunks uploaded so far, if the upload was not completed).
-   * Can be called by either the sender or recipient
-   */
-  async deleteFile(e, t) {
-    const s = await this.prepareRelay(e), n = await this.runRelayCommand(s, l.deleteFile, { uploadID: t });
-    return await this.decryptResponse(s, n);
-  }
-  // ---------- Dealing with Relay ----------
-  /**
-   * Establishes a session, exchanges temp keys and proves our ownership of this
-   * Mailbox to this specific relay. This is the first function to start
-   * communications with any relay. Returns the number of messages in the mailbox
-   */
-  async connectToRelay(e) {
-    const t = this.relayFactory.getInstance(e), s = await t.openConnection(), n = await this.encryptSignature(s), r = await t.prove(await t.encodeMessage(JSON.stringify({
-      pub_key: this.keyRing.getPubCommKey(),
-      nonce: n.nonce,
-      ctext: n.ctext
-    })));
-    return parseInt(r, 10);
-  }
-  clearSession(e) {
-    const t = this.relayFactory.getInstance(e);
-    t.clearToken(), t.clearSession();
-  }
-  async encryptSignature(e) {
-    const t = o.fromBase64(this.keyRing.getPrivateCommKey());
-    return await p.encodeMessage(e.h2Signature, e.relayPublicKey, t);
-  }
-  /**
-   * Gets a singleton Relay instance, and reconnects to a relay if a previous token has expired
-   */
-  async prepareRelay(e) {
-    const t = this.relayFactory.getInstance(e);
-    return await this.getRelayConnectionMutex(e).runExclusive(async () => {
-      t.isConnected || await this.connectToRelay(e);
-    }), t;
-  }
-  /**
-   * Encrypts the payload of the command and sends it to a relay
-   */
-  async runRelayCommand(e, t, s, n) {
-    s = { cmd: t, ...s };
-    const r = await this.keyRing.getHpk(), a = await e.encodeMessage(JSON.stringify(s));
-    return await e.runCmd(t, r, a, n);
-  }
-  /**
-   * Parses relay's response to a command, for those commands that expect an encrypted message in return.
-   * Two lines of POST response will be nonce and ctext
-   */
-  async decryptResponse(e, t) {
-    const [s, n] = t;
-    return await e.decodeMessage(s, n);
-  }
-  // ---------- Message encoding / decoding ----------
-  /**
-   * Encodes `message` to the guest key of a guest already
-   * added to the keyring
-   */
-  async encodeMessage(e, t) {
-    const s = this.getGuestKey(e), n = this.keyRing.getPrivateCommKey();
-    return await p.encodeMessage(
-      await this.nacl.encode_utf8(t),
-      o.fromBase64(s),
-      o.fromBase64(n)
-    );
-  }
-  /**
-   * Decodes a ciphertext from a guest key already in our keyring with this nonce
-   * @returns null if failed to decode
-   */
-  async decodeMessage(e, t, s) {
-    const n = this.getGuestKey(e), r = this.keyRing.getPrivateCommKey();
-    let a;
-    try {
-      a = o.fromBase64(s);
-    } catch {
-      return null;
-    }
-    return await p.decodeMessage(
-      o.fromBase64(t),
-      a,
-      o.fromBase64(n),
-      o.fromBase64(r)
-    );
-  }
-  /**
-   * Wrapper around `keyring.getGuestKey` that handles unknown guests
-   */
-  getGuestKey(e) {
-    const t = this.keyRing.getGuestKey(e);
-    if (!t)
-      throw new Error(`[Mailbox] Unknown guest ${e}`);
-    return t;
-  }
-  // ---------- Destroying Mailbox ----------
-  /**
-   * Deletes a Mailbox and all its data from local CryptoStorage. This is a very
-   * destructive operation, use with caution - it will delete the Mailbox
-   * keyring along with all stored public keys. To restore that information, you
-   * will need to do another key exchange with all the guests on your keyring.
-   */
-  async selfDestruct() {
-    await this.keyRing.selfDestruct();
-  }
-  getRelayConnectionMutex(e) {
-    return this.relayConnectionMutexes.has(e) || this.relayConnectionMutexes.set(e, new R()), this.relayConnectionMutexes.get(e);
-  }
-}
-class A {
-  constructor() {
-    this.storage = {};
-  }
-  async get(e) {
-    return (await this.getMultiple([e]))[0];
-  }
-  async getMultiple(e) {
-    return e.map((t) => this.storage[t]);
-  }
-  set(e, t) {
-    return this.setMultiple({ [e]: t });
-  }
-  async setMultiple(e) {
-    for (const t in e)
-      this.storage[t] = e[t];
-  }
-  remove(e) {
-    return this.removeMultiple([e]);
-  }
-  async removeMultiple(e) {
-    e.forEach((t) => delete this.storage[t]);
-  }
-  reset() {
-    this.storage = {};
-  }
-}
-export {
-  E as CryptoStorage,
-  _ as GlowNetworkError,
-  A as InMemoryStorage,
-  B as JsNaClDriver,
-  S as KeyRing,
-  w as Keys,
-  M as LocalStorageDriver,
-  x as Mailbox,
-  h as NaCl,
-  N as Relay,
-  o as Utils,
-  b as ZaxMessageKind
-};
-//# sourceMappingURL=glow.es.js.map
+//#endregion
+export { f as CryptoStorage, v as GlowNetworkError, S as InMemoryStorage, o as JsNaClDriver, m as KeyRing, c as Keys, d as LocalStorageDriver, x as Mailbox, s as NaCl, y as Relay, a as Utils, _ as ZaxMessageKind };
+
+//# sourceMappingURL=glow.es.js.map