internxt-crypto 1.5.0 → 1.6.1

package/README.md

@@ -109,24 +109,28 @@ const { key, salt } = await getKeyFromPassword(password);
 // Hybrid email encryption
 const email: Email = {
     text: 'email text',
+    preview: 'email preview',
+    attachmentsSessionKey: new Uint8Array([1, 2, 3, 4]),
 };
 const { secretKey: bobPrivateKeys, publicKey: bobPublicKeys } = await generateEmailKeys();
 const bobWithPublicKeys = {
     email: 'bob email',
     publicHybridKey: bobPublicKeys,
 };
-const encryptedEmail = await encryptEmailHybrid(email, bobWithPublicKeys);
-const decryptedEmail = await decryptEmailHybrid(encryptedEmail, bobPrivateKeys);
+const {encryptedKeys, encEmail} = await encryptEmailHybridForMultipleRecipients(email, [bobWithPublicKeys]);
+const decryptedEmail = await decryptEmailHybrid(encEmail, encryptedKeys[0], bobPrivateKeys);
 
 expect(decryptedEmail).toStrictEqual(email);
 
 // Hybrid email and subject encryption
 const emailAndSubject: EmailAndSubject = {
     text: 'email text',
-    subject: 'email subject'
+    subject: 'email subject',
+    preview: 'email preview,',
+    attachmentsSessionKey: new Uint8Array([1, 2, 3, 4]),
 };
-const encryptedEmailAndSubject = await encryptEmailAndSubjectHybrid(emailAndSubject, bobWithPublicKeys);
-const decryptedEmailAndSubject = await decryptEmailAndSubjectHybrid(encryptedEmailAndSubject, bobPrivateKeys);
+const {encryptedKeys, encEmail} = await encryptEmailAndSubjectHybridForMultipleRecipients(emailAndSubject, [bobWithPublicKeys]);
+const decryptedEmailAndSubject = await decryptEmailAndSubjectHybrid(encEmail, encryptedKeys[0], bobPrivateKeys);
 
 expect(encryptedEmailAndSubject.encEmail.encSubject).not.toBe(emailAndSubject.subject);
 expect(decryptedEmailAndSubject).toStrictEqual(emailAndSubject);

package/dist/asymmetric-crypto.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"asymmetric-crypto.d.mts","names":[],"sources":["../src/asymmetric-crypto/ellipticCurve.ts"],"mappings":";;AASA;;;;;;iBAAsB,eAAA,CAAgB,cAAA,EAAgB,UAAA,EAAY,YAAA,EAAc,UAAA,GAAa,OAAA,CAAQ,UAAA;;;;;;iBAa/E,eAAA,CAAA,GAAmB,OAAA;EAAU,SAAA,EAAW,UAAA;EAAY,SAAA,EAAW,UAAA;AAAA"}
+{"version":3,"file":"asymmetric-crypto.d.mts","names":[],"sources":["../src/asymmetric-crypto/ellipticCurve.ts"],"mappings":";;AAcA;;;;;;iBAAsB,eAAA,CAAgB,cAAA,EAAgB,UAAA,EAAY,YAAA,EAAc,UAAA,GAAa,OAAA,CAAQ,UAAA;;;;;;iBAe/E,eAAA,CAAA,GAAmB,OAAA;EAAU,SAAA,EAAW,UAAA;EAAY,SAAA,EAAW,UAAA;AAAA"}

package/dist/asymmetric-crypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"asymmetric-crypto.d.ts","names":[],"sources":["../src/asymmetric-crypto/ellipticCurve.ts"],"mappings":";;AASA;;;;;;iBAAsB,eAAA,CAAgB,cAAA,EAAgB,UAAA,EAAY,YAAA,EAAc,UAAA,GAAa,OAAA,CAAQ,UAAA;;;;;;iBAa/E,eAAA,CAAA,GAAmB,OAAA;EAAU,SAAA,EAAW,UAAA;EAAY,SAAA,EAAW,UAAA;AAAA"}
+{"version":3,"file":"asymmetric-crypto.d.ts","names":[],"sources":["../src/asymmetric-crypto/ellipticCurve.ts"],"mappings":";;AAcA;;;;;;iBAAsB,eAAA,CAAgB,cAAA,EAAgB,UAAA,EAAY,YAAA,EAAc,UAAA,GAAa,OAAA,CAAQ,UAAA;;;;;;iBAe/E,eAAA,CAAA,GAAmB,OAAA;EAAU,SAAA,EAAW,UAAA;EAAY,SAAA,EAAW,UAAA;AAAA"}

package/dist/asymmetric-crypto.js

@@ -2,6 +2,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./chunk-C13QxCFV.js");
 let _noble_curves_webcrypto_js = require("@noble/curves/webcrypto.js");
 //#region src/asymmetric-crypto/ellipticCurve.ts
+function asBytes(result) {
+	if (result instanceof Uint8Array) return result;
+	throw new Error("Expected raw key bytes, got JWK");
+}
 /**
 * Derives secret key from the other user's public key and own private key
 *
@@ -11,7 +15,9 @@ let _noble_curves_webcrypto_js = require("@noble/curves/webcrypto.js");
 */
 async function deriveSecretKey(aliceSecretKey, bobPublicKey) {
 	try {
-		return await _noble_curves_webcrypto_js.x25519.getSharedSecret(aliceSecretKey, bobPublicKey);
+		const spkiPublic = asBytes(await _noble_curves_webcrypto_js.x25519.utils.convertPublicKey(bobPublicKey, "raw", "spki"));
+		const pkcs8Secret = asBytes(await _noble_curves_webcrypto_js.x25519.utils.convertSecretKey(aliceSecretKey, "raw", "pkcs8"));
+		return await _noble_curves_webcrypto_js.x25519.getSharedSecret(pkcs8Secret, spkiPublic);
 	} catch (error) {
 		throw new Error("Failed to derive elliptic curve secret key", { cause: error });
 	}
@@ -22,7 +28,11 @@ async function deriveSecretKey(aliceSecretKey, bobPublicKey) {
 * @returns The generated key pair
 */
 async function generateEccKeys() {
-	return _noble_curves_webcrypto_js.x25519.keygen();
+	const { secretKey, publicKey } = await _noble_curves_webcrypto_js.x25519.keygen();
+	return {
+		secretKey: asBytes(await _noble_curves_webcrypto_js.x25519.utils.convertSecretKey(secretKey, "pkcs8", "raw")),
+		publicKey: asBytes(await _noble_curves_webcrypto_js.x25519.utils.convertPublicKey(publicKey, "spki", "raw"))
+	};
 }
 //#endregion
 exports.deriveSecretKey = deriveSecretKey;

package/dist/asymmetric-crypto.js.map

@@ -1 +1 @@
-{"version":3,"file":"asymmetric-crypto.js","names":["x25519"],"sources":["../src/asymmetric-crypto/ellipticCurve.ts"],"sourcesContent":["import { x25519 } from '@noble/curves/webcrypto.js';\n\n/**\n * Derives secret key from the other user's public key and own private key\n *\n * @param aliceSecretKey - The secret key of the user deriving the shared secret key\n * @param bobPublicKey - The public key of the other user\n * @returns The derived secret key bits\n */\nexport async function deriveSecretKey(aliceSecretKey: Uint8Array, bobPublicKey: Uint8Array): Promise<Uint8Array> {\n  try {\n    return await x25519.getSharedSecret(aliceSecretKey, bobPublicKey);\n  } catch (error) {\n    throw new Error('Failed to derive elliptic curve secret key', { cause: error });\n  }\n}\n\n/**\n * Generates elliptic curve key pair\n *\n * @returns The generated key pair\n */\nexport async function generateEccKeys(): Promise<{ secretKey: Uint8Array; publicKey: Uint8Array }> {\n  return x25519.keygen();\n}\n"],"mappings":";;;;;;;;;;;AASA,eAAsB,gBAAgB,gBAA4B,cAA+C;AAC/G,KAAI;AACF,SAAO,MAAMA,2BAAAA,OAAO,gBAAgB,gBAAgB,aAAa;UAC1D,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASnF,eAAsB,kBAA6E;AACjG,QAAOA,2BAAAA,OAAO,QAAQ"}
+{"version":3,"file":"asymmetric-crypto.js","names":["x25519"],"sources":["../src/asymmetric-crypto/ellipticCurve.ts"],"sourcesContent":["import { x25519 } from '@noble/curves/webcrypto.js';\n\nfunction asBytes(result: unknown): Uint8Array {\n  if (result instanceof Uint8Array) return result;\n  throw new Error('Expected raw key bytes, got JWK');\n}\n\n/**\n * Derives secret key from the other user's public key and own private key\n *\n * @param aliceSecretKey - The secret key of the user deriving the shared secret key\n * @param bobPublicKey - The public key of the other user\n * @returns The derived secret key bits\n */\nexport async function deriveSecretKey(aliceSecretKey: Uint8Array, bobPublicKey: Uint8Array): Promise<Uint8Array> {\n  try {\n    const spkiPublic = asBytes(await x25519.utils.convertPublicKey(bobPublicKey, 'raw', 'spki'));\n    const pkcs8Secret = asBytes(await x25519.utils.convertSecretKey(aliceSecretKey, 'raw', 'pkcs8'));\n    return await x25519.getSharedSecret(pkcs8Secret, spkiPublic);\n  } catch (error) {\n    throw new Error('Failed to derive elliptic curve secret key', { cause: error });\n  }\n}\n\n/**\n * Generates elliptic curve key pair\n *\n * @returns The generated key pair\n */\nexport async function generateEccKeys(): Promise<{ secretKey: Uint8Array; publicKey: Uint8Array }> {\n  const { secretKey, publicKey } = await x25519.keygen();\n  return {\n    secretKey: asBytes(await x25519.utils.convertSecretKey(secretKey, 'pkcs8', 'raw')),\n    publicKey: asBytes(await x25519.utils.convertPublicKey(publicKey, 'spki', 'raw')),\n  };\n}\n"],"mappings":";;;;AAEA,SAAS,QAAQ,QAA6B;AAC5C,KAAI,kBAAkB,WAAY,QAAO;AACzC,OAAM,IAAI,MAAM,kCAAkC;;;;;;;;;AAUpD,eAAsB,gBAAgB,gBAA4B,cAA+C;AAC/G,KAAI;EACF,MAAM,aAAa,QAAQ,MAAMA,2BAAAA,OAAO,MAAM,iBAAiB,cAAc,OAAO,OAAO,CAAC;EAC5F,MAAM,cAAc,QAAQ,MAAMA,2BAAAA,OAAO,MAAM,iBAAiB,gBAAgB,OAAO,QAAQ,CAAC;AAChG,SAAO,MAAMA,2BAAAA,OAAO,gBAAgB,aAAa,WAAW;UACrD,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASnF,eAAsB,kBAA6E;CACjG,MAAM,EAAE,WAAW,cAAc,MAAMA,2BAAAA,OAAO,QAAQ;AACtD,QAAO;EACL,WAAW,QAAQ,MAAMA,2BAAAA,OAAO,MAAM,iBAAiB,WAAW,SAAS,MAAM,CAAC;EAClF,WAAW,QAAQ,MAAMA,2BAAAA,OAAO,MAAM,iBAAiB,WAAW,QAAQ,MAAM,CAAC;EAClF"}

package/dist/asymmetric-crypto.mjs

@@ -1,5 +1,9 @@
 import { x25519 } from "@noble/curves/webcrypto.js";
 //#region src/asymmetric-crypto/ellipticCurve.ts
+function asBytes(result) {
+	if (result instanceof Uint8Array) return result;
+	throw new Error("Expected raw key bytes, got JWK");
+}
 /**
 * Derives secret key from the other user's public key and own private key
 *
@@ -9,7 +13,9 @@ import { x25519 } from "@noble/curves/webcrypto.js";
 */
 async function deriveSecretKey(aliceSecretKey, bobPublicKey) {
 	try {
-		return await x25519.getSharedSecret(aliceSecretKey, bobPublicKey);
+		const spkiPublic = asBytes(await x25519.utils.convertPublicKey(bobPublicKey, "raw", "spki"));
+		const pkcs8Secret = asBytes(await x25519.utils.convertSecretKey(aliceSecretKey, "raw", "pkcs8"));
+		return await x25519.getSharedSecret(pkcs8Secret, spkiPublic);
 	} catch (error) {
 		throw new Error("Failed to derive elliptic curve secret key", { cause: error });
 	}
@@ -20,7 +26,11 @@ async function deriveSecretKey(aliceSecretKey, bobPublicKey) {
 * @returns The generated key pair
 */
 async function generateEccKeys() {
-	return x25519.keygen();
+	const { secretKey, publicKey } = await x25519.keygen();
+	return {
+		secretKey: asBytes(await x25519.utils.convertSecretKey(secretKey, "pkcs8", "raw")),
+		publicKey: asBytes(await x25519.utils.convertPublicKey(publicKey, "spki", "raw"))
+	};
 }
 //#endregion
 export { deriveSecretKey, generateEccKeys };

package/dist/asymmetric-crypto.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"asymmetric-crypto.mjs","names":[],"sources":["../src/asymmetric-crypto/ellipticCurve.ts"],"sourcesContent":["import { x25519 } from '@noble/curves/webcrypto.js';\n\n/**\n * Derives secret key from the other user's public key and own private key\n *\n * @param aliceSecretKey - The secret key of the user deriving the shared secret key\n * @param bobPublicKey - The public key of the other user\n * @returns The derived secret key bits\n */\nexport async function deriveSecretKey(aliceSecretKey: Uint8Array, bobPublicKey: Uint8Array): Promise<Uint8Array> {\n  try {\n    return await x25519.getSharedSecret(aliceSecretKey, bobPublicKey);\n  } catch (error) {\n    throw new Error('Failed to derive elliptic curve secret key', { cause: error });\n  }\n}\n\n/**\n * Generates elliptic curve key pair\n *\n * @returns The generated key pair\n */\nexport async function generateEccKeys(): Promise<{ secretKey: Uint8Array; publicKey: Uint8Array }> {\n  return x25519.keygen();\n}\n"],"mappings":";;;;;;;;;AASA,eAAsB,gBAAgB,gBAA4B,cAA+C;AAC/G,KAAI;AACF,SAAO,MAAM,OAAO,gBAAgB,gBAAgB,aAAa;UAC1D,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASnF,eAAsB,kBAA6E;AACjG,QAAO,OAAO,QAAQ"}
+{"version":3,"file":"asymmetric-crypto.mjs","names":[],"sources":["../src/asymmetric-crypto/ellipticCurve.ts"],"sourcesContent":["import { x25519 } from '@noble/curves/webcrypto.js';\n\nfunction asBytes(result: unknown): Uint8Array {\n  if (result instanceof Uint8Array) return result;\n  throw new Error('Expected raw key bytes, got JWK');\n}\n\n/**\n * Derives secret key from the other user's public key and own private key\n *\n * @param aliceSecretKey - The secret key of the user deriving the shared secret key\n * @param bobPublicKey - The public key of the other user\n * @returns The derived secret key bits\n */\nexport async function deriveSecretKey(aliceSecretKey: Uint8Array, bobPublicKey: Uint8Array): Promise<Uint8Array> {\n  try {\n    const spkiPublic = asBytes(await x25519.utils.convertPublicKey(bobPublicKey, 'raw', 'spki'));\n    const pkcs8Secret = asBytes(await x25519.utils.convertSecretKey(aliceSecretKey, 'raw', 'pkcs8'));\n    return await x25519.getSharedSecret(pkcs8Secret, spkiPublic);\n  } catch (error) {\n    throw new Error('Failed to derive elliptic curve secret key', { cause: error });\n  }\n}\n\n/**\n * Generates elliptic curve key pair\n *\n * @returns The generated key pair\n */\nexport async function generateEccKeys(): Promise<{ secretKey: Uint8Array; publicKey: Uint8Array }> {\n  const { secretKey, publicKey } = await x25519.keygen();\n  return {\n    secretKey: asBytes(await x25519.utils.convertSecretKey(secretKey, 'pkcs8', 'raw')),\n    publicKey: asBytes(await x25519.utils.convertPublicKey(publicKey, 'spki', 'raw')),\n  };\n}\n"],"mappings":";;AAEA,SAAS,QAAQ,QAA6B;AAC5C,KAAI,kBAAkB,WAAY,QAAO;AACzC,OAAM,IAAI,MAAM,kCAAkC;;;;;;;;;AAUpD,eAAsB,gBAAgB,gBAA4B,cAA+C;AAC/G,KAAI;EACF,MAAM,aAAa,QAAQ,MAAM,OAAO,MAAM,iBAAiB,cAAc,OAAO,OAAO,CAAC;EAC5F,MAAM,cAAc,QAAQ,MAAM,OAAO,MAAM,iBAAiB,gBAAgB,OAAO,QAAQ,CAAC;AAChG,SAAO,MAAM,OAAO,gBAAgB,aAAa,WAAW;UACrD,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASnF,eAAsB,kBAA6E;CACjG,MAAM,EAAE,WAAW,cAAc,MAAM,OAAO,QAAQ;AACtD,QAAO;EACL,WAAW,QAAQ,MAAM,OAAO,MAAM,iBAAiB,WAAW,SAAS,MAAM,CAAC;EAClF,WAAW,QAAQ,MAAM,OAAO,MAAM,iBAAiB,WAAW,QAAQ,MAAM,CAAC;EAClF"}

package/dist/{email-crypto-_Wcbvr_n.mjs → email-crypto-CoRbTphp.mjs}

@@ -31,54 +31,70 @@ async function wrapKey(key, wrappingKey) {
 var FailedToEncryptEmail = class FailedToEncryptEmail extends Error {
 	constructor(errorMsg) {
 		super("Failed to encrypt email: " + errorMsg);
+		this.name = this.constructor.name;
 		Object.setPrototypeOf(this, FailedToEncryptEmail.prototype);
 	}
 };
 var EmailSymmetricEncryptionError = class EmailSymmetricEncryptionError extends Error {
 	constructor(errorMsg) {
 		super("Failed to symmetrically encrypt email: " + errorMsg);
+		this.name = this.constructor.name;
 		Object.setPrototypeOf(this, EmailSymmetricEncryptionError.prototype);
 	}
 };
 var EmailSymmetricDecryptionError = class EmailSymmetricDecryptionError extends Error {
 	constructor(errorMsg) {
 		super("Failed to symmetrically decrypt email: " + errorMsg);
+		this.name = this.constructor.name;
 		Object.setPrototypeOf(this, EmailSymmetricDecryptionError.prototype);
 	}
 };
+var EmailPreviewSymmetricDecryptionError = class EmailPreviewSymmetricDecryptionError extends Error {
+	constructor(errorMsg) {
+		super("Failed to symmetrically decrypt email preview: " + errorMsg);
+		this.name = this.constructor.name;
+		Object.setPrototypeOf(this, EmailPreviewSymmetricDecryptionError.prototype);
+	}
+};
 var EmailHybridEncryptionError = class EmailHybridEncryptionError extends Error {
 	constructor(errorMsg) {
 		super("Failed to hybridly encrypt the key: " + errorMsg);
+		this.name = this.constructor.name;
 		Object.setPrototypeOf(this, EmailHybridEncryptionError.prototype);
 	}
 };
 var EmailHybridDecryptionError = class EmailHybridDecryptionError extends Error {
 	constructor(errorMsg) {
 		super("Failed to hybridly decrypt the key: " + errorMsg);
+		this.name = this.constructor.name;
 		Object.setPrototypeOf(this, EmailHybridDecryptionError.prototype);
 	}
 };
 var EmailPasswordProtectError = class EmailPasswordProtectError extends Error {
 	constructor(errorMsg) {
 		super("Failed to password-protect the key: " + errorMsg);
+		this.name = this.constructor.name;
 		Object.setPrototypeOf(this, EmailPasswordProtectError.prototype);
 	}
 };
 var EmailPasswordOpenError = class EmailPasswordOpenError extends Error {
 	constructor(errorMsg) {
 		super("Failed to open password-protected key: " + errorMsg);
+		this.name = this.constructor.name;
 		Object.setPrototypeOf(this, EmailPasswordOpenError.prototype);
 	}
 };
 var InvalidInputEmail = class InvalidInputEmail extends Error {
 	constructor() {
 		super("Invalid input");
+		this.name = this.constructor.name;
 		Object.setPrototypeOf(this, InvalidInputEmail.prototype);
 	}
 };
 var FailedToDecryptEmail = class FailedToDecryptEmail extends Error {
 	constructor(errorMsg) {
 		super("Failed to decrypt email: " + errorMsg);
+		this.name = this.constructor.name;
 		Object.setPrototypeOf(this, FailedToDecryptEmail.prototype);
 	}
 };
@@ -113,12 +129,33 @@ async function encryptEmail(email, aux) {
 */
 async function encryptEmailWithKey(email, encryptionKey, aux) {
 	try {
-		return { encText: uint8ArrayToBase64(await encryptSymmetrically(encryptionKey, UTF8ToUint8(email.text), aux)) };
+		const text = UTF8ToUint8(email.text);
+		const preview = UTF8ToUint8(email.preview);
+		return {
+			encText: uint8ArrayToBase64(await encryptSymmetrically(encryptionKey, text, aux)),
+			encPreview: uint8ArrayToBase64(await encryptSymmetrically(encryptionKey, preview, aux)),
+			encAttachmentsSessionKey: uint8ArrayToBase64(await encryptSymmetrically(encryptionKey, email.attachmentsSessionKey, aux))
+		};
 	} catch (error) {
 		throw new EmailSymmetricEncryptionError(error instanceof Error ? error.message : String(error));
 	}
 }
 /**
+* Decrypts symmetrically encrypted email preview.
+*
+* @param encEmailPreview - The email preview to decrypt.
+* @param encryptionKey - The symmetric key to decrypt the email.
+* @param aux - An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The resulting decrypted email
+*/
+async function decryptPreview(encEmailPreview, encryptionKey, aux) {
+	try {
+		return uint8ToUTF8(await decryptSymmetrically(encryptionKey, base64ToUint8Array(encEmailPreview), aux));
+	} catch (error) {
+		throw new EmailPreviewSymmetricDecryptionError(error instanceof Error ? error.message : String(error));
+	}
+}
+/**
 * Decrypts symmetrically encrypted email.
 *
 * @param encEmail - The email to decrypt.
@@ -128,7 +165,11 @@ async function encryptEmailWithKey(email, encryptionKey, aux) {
 */
 async function decryptEmail(encEmail, encryptionKey, aux) {
 	try {
-		return { text: uint8ToUTF8(await decryptSymmetrically(encryptionKey, base64ToUint8Array(encEmail.encText), aux)) };
+		return {
+			text: uint8ToUTF8(await decryptSymmetrically(encryptionKey, base64ToUint8Array(encEmail.encText), aux)),
+			preview: uint8ToUTF8(await decryptSymmetrically(encryptionKey, base64ToUint8Array(encEmail.encPreview), aux)),
+			attachmentsSessionKey: await decryptSymmetrically(encryptionKey, base64ToUint8Array(encEmail.encAttachmentsSessionKey), aux)
+		};
 	} catch (error) {
 		throw new EmailSymmetricDecryptionError(error instanceof Error ? error.message : String(error));
 	}
@@ -205,72 +246,39 @@ async function removePasswordProtection(emailEncryptionKey, password) {
 //#endregion
 //#region src/email-crypto/hybridEncyptedEmail.ts
 /**
-* Encrypts the email using hybrid encryption.
-*
-* @param email - The email to encrypt.
-* @param recipientPublicKeys - The public keys of the recipient.
-* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The encrypted email
-*/
-async function encryptEmailHybrid(email, recipient, aux) {
-	try {
-		const { encryptionKey, encEmail } = await encryptEmail(email, aux);
-		return {
-			encEmail,
-			encryptedKey: await encryptKeysHybrid(encryptionKey, recipient)
-		};
-	} catch (error) {
-		if (error instanceof InvalidInputEmail) throw error;
-		if (error instanceof EmailSymmetricEncryptionError) throw error;
-		if (error instanceof EmailHybridEncryptionError) throw error;
-		throw new FailedToEncryptEmail(error instanceof Error ? error.message : String(error));
-	}
-}
-/**
 * Encrypts the email using hybrid encryption for multiple recipients.
 *
 * @param email - The email to encrypt for multiple recipients.
 * @param recipients - The recipients with corresponding public keys.
 * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The set of encrypted emails
+* @returns The set of encrypted keys (one per user) and encrypted email
 */
 async function encryptEmailHybridForMultipleRecipients(email, recipients, aux) {
-	try {
-		if (!recipients || recipients.length === 0) throw new InvalidInputEmail();
-		const { encryptionKey, encEmail } = await encryptEmail(email, aux);
-		const encryptedEmails = [];
-		for (const recipient of recipients) {
-			const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);
-			encryptedEmails.push({
-				encEmail,
-				encryptedKey
-			});
-		}
-		return encryptedEmails;
-	} catch (error) {
-		if (error instanceof InvalidInputEmail) throw error;
-		if (error instanceof EmailSymmetricEncryptionError) throw error;
-		if (error instanceof EmailHybridEncryptionError) throw error;
-		throw new FailedToEncryptEmail(error instanceof Error ? error.message : String(error));
-	}
+	if (!recipients || recipients.length === 0) throw new InvalidInputEmail();
+	const { encryptionKey, encEmail } = await encryptEmail(email, aux);
+	return {
+		encryptedKeys: await Promise.all(recipients.map((recipient) => encryptKeysHybrid(encryptionKey, recipient))),
+		encEmail
+	};
 }
 /**
 * Decrypts the email using hybrid encryption.
 *
 * @param encEmail - The encrypted email.
+* @param encryptedKey - The encrypted key for this recipient.
 * @param recipientPrivateHybridKeys - The private key of the recipient.
 * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
 * @returns The decrypted email
 */
-async function decryptEmailHybrid(encEmail, recipientPrivateHybridKeys, aux) {
-	try {
-		const encryptionKey = await decryptKeysHybrid(encEmail.encryptedKey, recipientPrivateHybridKeys);
-		return await decryptEmail(encEmail.encEmail, encryptionKey, aux);
-	} catch (error) {
-		if (error instanceof EmailHybridDecryptionError) throw error;
-		if (error instanceof EmailSymmetricDecryptionError) throw error;
-		throw new FailedToDecryptEmail(error instanceof Error ? error.message : String(error));
-	}
+async function decryptEmailHybrid(encEmail, encryptedKey, recipientPrivateHybridKeys, aux) {
+	return await decryptEmail(encEmail, await decryptKeysHybrid(encryptedKey, recipientPrivateHybridKeys), aux);
+}
+async function decryptEmailPreviewHybrid(encPreview, encryptedKey, recipientPrivateHybridKeys, aux) {
+	const encryptionKey = await decryptKeysHybrid(encryptedKey, recipientPrivateHybridKeys);
+	return {
+		preview: await decryptPreview(encPreview, encryptionKey, aux),
+		encryptionKey
+	};
 }
 //#endregion
 //#region src/email-crypto/pwdProtectedEmail.ts
@@ -378,73 +386,32 @@ async function decryptEmailAndSubject(encEmail, encryptionKey, aux) {
 //#endregion
 //#region src/email-crypto/hybridEncryptedEmailAndSubject.ts
 /**
-* Encrypts the email and its subject using hybrid encryption.
-*
-* @param email - The email and subject to encrypt.
-* @param recipientPublicKeys - The public keys of the recipient.
-* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The encrypted email and subject
-*/
-async function encryptEmailAndSubjectHybrid(email, recipient, aux) {
-	try {
-		const { encryptionKey, encEmail } = await encryptEmailAndSubject(email, aux);
-		return {
-			encEmail,
-			encryptedKey: await encryptKeysHybrid(encryptionKey, recipient)
-		};
-	} catch (error) {
-		if (error instanceof InvalidInputEmail) throw error;
-		if (error instanceof EmailSymmetricEncryptionError) throw error;
-		if (error instanceof EmailHybridEncryptionError) throw error;
-		throw new FailedToEncryptEmail(error instanceof Error ? error.message : String(error));
-	}
-}
-/**
 * Encrypts the email and its subject using hybrid encryption for multiple recipients.
 *
 * @param email - The email and subject to encrypt for multiple recipients.
 * @param recipients - The recipients with corresponding public keys.
 * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The set of encrypted emails and subjects
+* @returns The set of encrypted keys and encrypted email and subject
 */
 async function encryptEmailAndSubjectHybridForMultipleRecipients(email, recipients, aux) {
-	try {
-		if (!recipients || recipients.length === 0) throw new InvalidInputEmail();
-		const { encryptionKey, encEmail } = await encryptEmailAndSubject(email, aux);
-		const encryptedEmails = [];
-		for (const recipient of recipients) {
-			const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);
-			encryptedEmails.push({
-				encEmail,
-				encryptedKey
-			});
-		}
-		return encryptedEmails;
-	} catch (error) {
-		if (error instanceof InvalidInputEmail) throw error;
-		if (error instanceof EmailSymmetricEncryptionError) throw error;
-		if (error instanceof EmailHybridEncryptionError) throw error;
-		throw new FailedToEncryptEmail(error instanceof Error ? error.message : String(error));
-	}
+	if (!recipients || recipients.length === 0) throw new InvalidInputEmail();
+	const { encryptionKey, encEmail } = await encryptEmailAndSubject(email, aux);
+	return {
+		encEmail,
+		encryptedKeys: await Promise.all(recipients.map((recipient) => encryptKeysHybrid(encryptionKey, recipient)))
+	};
 }
 /**
 * Decrypts the email and its subject using hybrid encryption.
 *
-* @param hybridEmail - The encrypted email and subject.
+* @param encEmail - The encrypted email and subject.
+* @param encryptedKey - The encrypted key for this recipient.
 * @param recipientPrivateHybridKeys - The private key of the recipient.
 * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
 * @returns The decrypted email and subject
 */
-async function decryptEmailAndSubjectHybrid(hybridEmail, recipientPrivateHybridKeys, aux) {
-	try {
-		const encryptionKey = await decryptKeysHybrid(hybridEmail.encryptedKey, recipientPrivateHybridKeys);
-		return await decryptEmailAndSubject(hybridEmail.encEmail, encryptionKey, aux);
-	} catch (error) {
-		if (error instanceof InvalidInputEmail) throw error;
-		if (error instanceof EmailHybridDecryptionError) throw error;
-		if (error instanceof EmailSymmetricDecryptionError) throw error;
-		throw new FailedToDecryptEmail(error instanceof Error ? error.message : String(error));
-	}
+async function decryptEmailAndSubjectHybrid(encEmail, encryptedKey, recipientPrivateHybridKeys, aux) {
+	return await decryptEmailAndSubject(encEmail, await decryptKeysHybrid(encryptedKey, recipientPrivateHybridKeys), aux);
 }
 //#endregion
 //#region src/email-crypto/pwdProtectedEmailAndSubject.ts
@@ -518,6 +485,6 @@ const deriveEmailDraftKey = async (mnemonic) => {
 	return deriveKeyFromMnemonic(mnemonic, CONTEXT_DRAFT);
 };
 //#endregion
-export { FailedToDecryptEmail as A, removePasswordProtection as C, EmailPasswordProtectError as D, EmailPasswordOpenError as E, InvalidInputEmail as M, unwrapKey as N, EmailSymmetricDecryptionError as O, wrapKey as P, passwordProtectKey as S, EmailHybridEncryptionError as T, decryptEmail as _, decryptPwdProtectedEmailAndSubject as a, encryptEmailWithKey as b, encryptEmailAndSubjectHybridForMultipleRecipients as c, encryptEmailAndSubjectWithKey as d, createPwdProtectedEmail as f, encryptEmailHybridForMultipleRecipients as g, encryptEmailHybrid as h, createPwdProtectedEmailAndSubject as i, FailedToEncryptEmail as j, EmailSymmetricEncryptionError as k, decryptEmailAndSubject as l, decryptEmailHybrid as m, deriveEmailDraftKey as n, decryptEmailAndSubjectHybrid as o, decryptPwdProtectedEmail as p, generateEmailKeys as r, encryptEmailAndSubjectHybrid as s, deriveDatabaseKey as t, encryptEmailAndSubject as u, decryptKeysHybrid as v, EmailHybridDecryptionError as w, encryptKeysHybrid as x, encryptEmail as y };
+export { EmailSymmetricEncryptionError as A, removePasswordProtection as C, EmailPasswordProtectError as D, EmailPasswordOpenError as E, wrapKey as F, FailedToEncryptEmail as M, InvalidInputEmail as N, EmailPreviewSymmetricDecryptionError as O, unwrapKey as P, passwordProtectKey as S, EmailHybridEncryptionError as T, decryptKeysHybrid as _, decryptPwdProtectedEmailAndSubject as a, encryptEmailWithKey as b, decryptEmailAndSubject as c, createPwdProtectedEmail as d, decryptPwdProtectedEmail as f, decryptEmail as g, encryptEmailHybridForMultipleRecipients as h, createPwdProtectedEmailAndSubject as i, FailedToDecryptEmail as j, EmailSymmetricDecryptionError as k, encryptEmailAndSubject as l, decryptEmailPreviewHybrid as m, deriveEmailDraftKey as n, decryptEmailAndSubjectHybrid as o, decryptEmailHybrid as p, generateEmailKeys as r, encryptEmailAndSubjectHybridForMultipleRecipients as s, deriveDatabaseKey as t, encryptEmailAndSubjectWithKey as u, decryptPreview as v, EmailHybridDecryptionError as w, encryptKeysHybrid as x, encryptEmail as y };
 
-//# sourceMappingURL=email-crypto-_Wcbvr_n.mjs.map
+//# sourceMappingURL=email-crypto-CoRbTphp.mjs.map

package/dist/email-crypto-CoRbTphp.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"email-crypto-CoRbTphp.mjs","names":[],"sources":["../src/key-wrapper/aesWrapper.ts","../src/email-crypto/errors.ts","../src/email-crypto/core.ts","../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/coreSubject.ts","../src/email-crypto/hybridEncryptedEmailAndSubject.ts","../src/email-crypto/pwdProtectedEmailAndSubject.ts","../src/email-crypto/emailKeys.ts"],"sourcesContent":["import { aeskw } from '@noble/ciphers/aes.js';\n\n/**\n * Unwraps the given wrapped key\n *\n * @param encryptedKey - The wrapped key\n * @param wrappingKey - The secret key used for unwrapping\n * @returns The resulting key\n */\nexport async function unwrapKey(encryptedKey: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array> {\n  return aeskw(wrappingKey).decrypt(encryptedKey);\n}\n\n/**\n * Wraps the given key\n *\n * @param key - The key to be wrapped\n * @param wrappingKey - The secret key used for wrapping\n * @returns The resulting ciphertext\n */\nexport async function wrapKey(key: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array> {\n  return aeskw(wrappingKey).encrypt(key);\n}\n","export class FailedToEncryptEmail extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to encrypt email: ' + errorMsg);\n\n    this.name = this.constructor.name;\n    Object.setPrototypeOf(this, FailedToEncryptEmail.prototype);\n  }\n}\n\nexport class EmailSymmetricEncryptionError extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to symmetrically encrypt email: ' + errorMsg);\n\n    this.name = this.constructor.name;\n    Object.setPrototypeOf(this, EmailSymmetricEncryptionError.prototype);\n  }\n}\n\nexport class EmailSymmetricDecryptionError extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to symmetrically decrypt email: ' + errorMsg);\n\n    this.name = this.constructor.name;\n    Object.setPrototypeOf(this, EmailSymmetricDecryptionError.prototype);\n  }\n}\n\nexport class EmailPreviewSymmetricDecryptionError extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to symmetrically decrypt email preview: ' + errorMsg);\n\n    this.name = this.constructor.name;\n    Object.setPrototypeOf(this, EmailPreviewSymmetricDecryptionError.prototype);\n  }\n}\n\nexport class EmailHybridEncryptionError extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to hybridly encrypt the key: ' + errorMsg);\n\n    this.name = this.constructor.name;\n    Object.setPrototypeOf(this, EmailHybridEncryptionError.prototype);\n  }\n}\n\nexport class EmailHybridDecryptionError extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to hybridly decrypt the key: ' + errorMsg);\n\n    this.name = this.constructor.name;\n    Object.setPrototypeOf(this, EmailHybridDecryptionError.prototype);\n  }\n}\n\nexport class EmailPasswordProtectError extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to password-protect the key: ' + errorMsg);\n\n    this.name = this.constructor.name;\n    Object.setPrototypeOf(this, EmailPasswordProtectError.prototype);\n  }\n}\n\nexport class EmailPasswordOpenError extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to open password-protected key: ' + errorMsg);\n\n    this.name = this.constructor.name;\n    Object.setPrototypeOf(this, EmailPasswordOpenError.prototype);\n  }\n}\n\nexport class InvalidInputEmail extends Error {\n  constructor() {\n    super('Invalid input');\n\n    this.name = this.constructor.name;\n    Object.setPrototypeOf(this, InvalidInputEmail.prototype);\n  }\n}\n\nexport class FailedToDecryptEmail extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to decrypt email: ' + errorMsg);\n\n    this.name = this.constructor.name;\n    Object.setPrototypeOf(this, FailedToDecryptEmail.prototype);\n  }\n}\n","import { HybridEncKey, PwdProtectedKey, Email, RecipientWithPublicKey, EmailEncrypted } from '../types';\nimport { encryptSymmetrically, decryptSymmetrically, genSymmetricKey } from '../symmetric-crypto';\nimport { encapsulateHybrid, decapsulateHybrid } from '../hybrid-crypto';\nimport { wrapKey, unwrapKey } from '../key-wrapper';\nimport { getKeyFromPassword, getKeyFromPasswordAndSalt } from '../derive-password';\nimport { UTF8ToUint8, base64ToUint8Array, uint8ArrayToBase64, uint8ToUTF8 } from '../utils';\nimport {\n  EmailHybridDecryptionError,\n  EmailHybridEncryptionError,\n  InvalidInputEmail,\n  EmailSymmetricDecryptionError,\n  EmailSymmetricEncryptionError,\n  EmailPasswordOpenError,\n  EmailPasswordProtectError,\n  EmailPreviewSymmetricDecryptionError,\n} from './errors';\n\n/**\n * Symmetrically encrypts email.\n *\n * @param email - The email to encrypt.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting encrypted email and symmetric key used for encryption\n */\nexport async function encryptEmail(\n  email: Email,\n  aux?: Uint8Array,\n): Promise<{\n  encEmail: EmailEncrypted;\n  encryptionKey: Uint8Array;\n}> {\n  if (!email.text) {\n    throw new InvalidInputEmail();\n  }\n  try {\n    const encryptionKey = genSymmetricKey();\n    const encEmail = await encryptEmailWithKey(email, encryptionKey, aux);\n\n    return { encEmail, encryptionKey };\n  } catch (error) {\n    throw new EmailSymmetricEncryptionError(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Symmetrically encrypts email with the given key.\n *\n * @param email - The email to encrypt.\n * @param encryptionKey - The symmetric key to encrypt the email.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting encrypted email and symmetric key used for encryption\n */\nexport async function encryptEmailWithKey(\n  email: Email,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailEncrypted> {\n  try {\n    const text = UTF8ToUint8(email.text);\n    const preview = UTF8ToUint8(email.preview);\n\n    const encryptedText = await encryptSymmetrically(encryptionKey, text, aux);\n    const encText = uint8ArrayToBase64(encryptedText);\n\n    const encryptedPreview = await encryptSymmetrically(encryptionKey, preview, aux);\n    const encPreview = uint8ArrayToBase64(encryptedPreview);\n\n    const encryptedAttachmentsSessionKey = await encryptSymmetrically(encryptionKey, email.attachmentsSessionKey, aux);\n    const encAttachmentsSessionKey = uint8ArrayToBase64(encryptedAttachmentsSessionKey);\n\n    return { encText, encPreview, encAttachmentsSessionKey };\n  } catch (error) {\n    throw new EmailSymmetricEncryptionError(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Decrypts symmetrically encrypted email preview.\n *\n * @param encEmailPreview - The email preview to decrypt.\n * @param encryptionKey - The symmetric key to decrypt the email.\n * @param aux - An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting decrypted email\n */\nexport async function decryptPreview(\n  encEmailPreview: string,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<string> {\n  try {\n    const encPreview = base64ToUint8Array(encEmailPreview);\n    const previewArray = await decryptSymmetrically(encryptionKey, encPreview, aux);\n    const preview = uint8ToUTF8(previewArray);\n\n    return preview;\n  } catch (error) {\n    throw new EmailPreviewSymmetricDecryptionError(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Decrypts symmetrically encrypted email.\n *\n * @param encEmail - The email to decrypt.\n * @param encryptionKey - The symmetric key to decrypt the email.\n * @param aux - An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting decrypted email\n */\nexport async function decryptEmail(\n  encEmail: EmailEncrypted,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<Email> {\n  try {\n    const encText = base64ToUint8Array(encEmail.encText);\n    const textArray = await decryptSymmetrically(encryptionKey, encText, aux);\n    const text = uint8ToUTF8(textArray);\n\n    const encPreview = base64ToUint8Array(encEmail.encPreview);\n    const previewArray = await decryptSymmetrically(encryptionKey, encPreview, aux);\n    const preview = uint8ToUTF8(previewArray);\n\n    const encAttachementSessionKey = base64ToUint8Array(encEmail.encAttachmentsSessionKey);\n    const attachmentsSessionKey = await decryptSymmetrically(encryptionKey, encAttachementSessionKey, aux);\n\n    return { text, preview, attachmentsSessionKey };\n  } catch (error) {\n    throw new EmailSymmetricDecryptionError(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Encrypts the email symmetric key using hybrid encryption.\n *\n * @param emailEncryptionKey - The symmetric key used for email encryption.\n * @param recipient - The recipient with a public hybrid key.\n * @returns The encrypted email symmetric key\n */\nexport async function encryptKeysHybrid(\n  emailEncryptionKey: Uint8Array,\n  recipient: RecipientWithPublicKey,\n): Promise<HybridEncKey> {\n  try {\n    const { cipherText, sharedSecret } = encapsulateHybrid(recipient.publicHybridKey);\n    const encryptedKey = await wrapKey(emailEncryptionKey, sharedSecret);\n    const encryptedKeyBase64 = uint8ArrayToBase64(encryptedKey);\n    const kyberCiphertextBase64 = uint8ArrayToBase64(cipherText);\n\n    return {\n      encryptedKey: encryptedKeyBase64,\n      hybridCiphertext: kyberCiphertextBase64,\n      encryptedForEmail: recipient.email,\n    };\n  } catch (error) {\n    throw new EmailHybridEncryptionError(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Decrypts the email symmetric key encrypted via hybrid encryption.\n *\n * @param encryptedKey - The encrypted email key.\n * @param recipientPrivateKey - The private key of the recipient.\n * @returns The email encryption key\n */\nexport async function decryptKeysHybrid(\n  encryptedKey: HybridEncKey,\n  recipientPrivateKey: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const kyberCiphertext = base64ToUint8Array(encryptedKey.hybridCiphertext);\n    const encKey = base64ToUint8Array(encryptedKey.encryptedKey);\n    const sharedSecret = decapsulateHybrid(kyberCiphertext, recipientPrivateKey);\n    const encryptionKey = await unwrapKey(encKey, sharedSecret);\n    return encryptionKey;\n  } catch (error) {\n    throw new EmailHybridDecryptionError(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Password-protects the email symmetric key.\n *\n * @param emailEncryptionKey - The symmetric key used for email encryption.\n * @param password - The secret password for key protection.\n * @returns The password-protected email symmetric key\n */\nexport async function passwordProtectKey(emailEncryptionKey: Uint8Array, password: string): Promise<PwdProtectedKey> {\n  try {\n    const { key, salt } = await getKeyFromPassword(password);\n    const encryptedKey = await wrapKey(emailEncryptionKey, key);\n    const saltStr = uint8ArrayToBase64(salt);\n    const encryptedKeyStr = uint8ArrayToBase64(encryptedKey);\n    return { encryptedKey: encryptedKeyStr, salt: saltStr };\n  } catch (error) {\n    throw new EmailPasswordProtectError(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Removes passoword-protection and exposes the email symmetric key.\n *\n * @param emailEncryptionKey -  The password-protected email key.\n * @param password - The secret password for key protection.\n * @returns The email encryption key\n */\nexport async function removePasswordProtection(\n  emailEncryptionKey: PwdProtectedKey,\n  password: string,\n): Promise<Uint8Array> {\n  try {\n    const salt = base64ToUint8Array(emailEncryptionKey.salt);\n    const encryptedKey = base64ToUint8Array(emailEncryptionKey.encryptedKey);\n    const key = await getKeyFromPasswordAndSalt(password, salt);\n    const encryptionKey = await unwrapKey(encryptedKey, key);\n    return encryptionKey;\n  } catch (error) {\n    throw new EmailPasswordOpenError(error instanceof Error ? error.message : String(error));\n  }\n}\n","import { Email, RecipientWithPublicKey, HybridEncKey, EmailEncrypted } from '../types';\nimport { decryptEmail, decryptPreview, encryptKeysHybrid, decryptKeysHybrid, encryptEmail } from './core';\nimport { InvalidInputEmail } from './errors';\n\n/**\n * Encrypts the email using hybrid encryption for multiple recipients.\n *\n * @param email - The email to encrypt for multiple recipients.\n * @param recipients - The recipients with corresponding public keys.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The set of encrypted keys (one per user) and encrypted email\n */\nexport async function encryptEmailHybridForMultipleRecipients(\n  email: Email,\n  recipients: RecipientWithPublicKey[],\n  aux?: Uint8Array,\n): Promise<{ encryptedKeys: HybridEncKey[]; encEmail: EmailEncrypted }> {\n  if (!recipients || recipients.length === 0) {\n    throw new InvalidInputEmail();\n  }\n  const { encryptionKey, encEmail } = await encryptEmail(email, aux);\n\n  const encryptedKeys = await Promise.all(recipients.map((recipient) => encryptKeysHybrid(encryptionKey, recipient)));\n\n  return { encryptedKeys, encEmail };\n}\n\n/**\n * Decrypts the email using hybrid encryption.\n *\n * @param encEmail - The encrypted email.\n * @param encryptedKey - The encrypted key for this recipient.\n * @param recipientPrivateHybridKeys - The private key of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email\n */\nexport async function decryptEmailHybrid(\n  encEmail: EmailEncrypted,\n  encryptedKey: HybridEncKey,\n  recipientPrivateHybridKeys: Uint8Array,\n  aux?: Uint8Array,\n): Promise<Email> {\n  const encryptionKey = await decryptKeysHybrid(encryptedKey, recipientPrivateHybridKeys);\n  return await decryptEmail(encEmail, encryptionKey, aux);\n}\n\nexport async function decryptEmailPreviewHybrid(\n  encPreview: string,\n  encryptedKey: HybridEncKey,\n  recipientPrivateHybridKeys: Uint8Array,\n  aux?: Uint8Array,\n): Promise<{ preview: string; encryptionKey: Uint8Array }> {\n  const encryptionKey = await decryptKeysHybrid(encryptedKey, recipientPrivateHybridKeys);\n  const preview = await decryptPreview(encPreview, encryptionKey, aux);\n  return { preview, encryptionKey };\n}\n","import { PwdProtectedEmail, Email } from '../types';\nimport { decryptEmail, passwordProtectKey, removePasswordProtection, encryptEmail } from './core';\nimport {\n  EmailSymmetricEncryptionError,\n  FailedToDecryptEmail,\n  FailedToEncryptEmail,\n  EmailPasswordProtectError,\n  EmailSymmetricDecryptionError,\n  EmailPasswordOpenError,\n  InvalidInputEmail,\n} from './errors';\n/**\n * Creates a password-protected email.\n *\n * @param email - The email to password-protect\n * @param password - The secret password shared among recipients\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The password-protected email\n */\nexport async function createPwdProtectedEmail(\n  email: Email,\n  password: string,\n  aux?: Uint8Array,\n): Promise<PwdProtectedEmail> {\n  try {\n    const { encryptionKey, encEmail } = await encryptEmail(email, aux);\n    const encryptedKey = await passwordProtectKey(encryptionKey, password);\n\n    return { encEmail, encryptedKey };\n  } catch (error) {\n    if (error instanceof InvalidInputEmail) throw error;\n    if (error instanceof EmailSymmetricEncryptionError) throw error;\n    if (error instanceof EmailPasswordProtectError) throw error;\n    throw new FailedToEncryptEmail(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Opens a password-protected email.\n *\n * @param encryptedEmail - The encrypted email\n * @param password - The secret password shared among recipients.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email\n */\nexport async function decryptPwdProtectedEmail(\n  encryptedEmail: PwdProtectedEmail,\n  password: string,\n  aux?: Uint8Array,\n): Promise<Email> {\n  if (!encryptedEmail?.encEmail || !encryptedEmail?.encryptedKey) {\n    throw new InvalidInputEmail();\n  }\n  try {\n    const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);\n    return await decryptEmail(encryptedEmail.encEmail, encryptionKey, aux);\n  } catch (error) {\n    if (error instanceof EmailPasswordOpenError) throw error;\n    if (error instanceof EmailSymmetricDecryptionError) throw error;\n    throw new FailedToDecryptEmail(error instanceof Error ? error.message : String(error));\n  }\n}\n","import { EmailAndSubject, EmailAndSubjectEncrypted } from '../types';\nimport { encryptSymmetrically, decryptSymmetrically, genSymmetricKey } from '../symmetric-crypto';\nimport { encryptEmailWithKey, decryptEmail } from './core';\nimport { UTF8ToUint8, base64ToUint8Array, uint8ArrayToBase64, uint8ToUTF8 } from '../utils';\nimport { InvalidInputEmail, EmailSymmetricDecryptionError, EmailSymmetricEncryptionError } from './errors';\n\n/**\n * Symmetrically encrypts email and subject.\n *\n * @param email - The email and subject to encrypt.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting encrypted email and symmetric key used for encryption\n */\nexport async function encryptEmailAndSubject(\n  email: EmailAndSubject,\n  aux?: Uint8Array,\n): Promise<{\n  encEmail: EmailAndSubjectEncrypted;\n  encryptionKey: Uint8Array;\n}> {\n  if (!email.text || !email.subject) {\n    throw new InvalidInputEmail();\n  }\n  try {\n    const encryptionKey = genSymmetricKey();\n    const encEmail = await encryptEmailAndSubjectWithKey(email, encryptionKey, aux);\n\n    return { encEmail, encryptionKey };\n  } catch (error) {\n    throw new EmailSymmetricEncryptionError(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Symmetrically encrypts email and subject with the given key.\n *\n * @param email - The email and subject to encrypt.\n * @param encryptionKey - The symmetric key to encrypt the email.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting encrypted email and symmetric key used for encryption\n */\nexport async function encryptEmailAndSubjectWithKey(\n  email: EmailAndSubject,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailAndSubjectEncrypted> {\n  try {\n    const enc = await encryptEmailWithKey(email, encryptionKey, aux);\n    const subject = UTF8ToUint8(email.subject);\n    const subjectEnc = await encryptSymmetrically(encryptionKey, subject, aux);\n    const encSubject = uint8ArrayToBase64(subjectEnc);\n\n    return { ...enc, encSubject };\n  } catch (error) {\n    throw new EmailSymmetricEncryptionError(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Decrypts symmetrically encrypted email and email subject.\n *\n * @param encEmail - The encrypted email and subject to decrypt.\n * @param encryptionKey - The symmetric key to decrypt the email.\n * @param aux - An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting decrypted email and subject\n */\nexport async function decryptEmailAndSubject(\n  encEmail: EmailAndSubjectEncrypted,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailAndSubject> {\n  try {\n    const encSubject = base64ToUint8Array(encEmail.encSubject);\n    const subjectArray = await decryptSymmetrically(encryptionKey, encSubject, aux);\n    const subject = uint8ToUTF8(subjectArray);\n    const email = await decryptEmail(encEmail, encryptionKey, aux);\n\n    return { ...email, subject };\n  } catch (error) {\n    throw new EmailSymmetricDecryptionError(error instanceof Error ? error.message : String(error));\n  }\n}\n","import { RecipientWithPublicKey, EmailAndSubject, EmailAndSubjectEncrypted, HybridEncKey } from '../types';\nimport { encryptKeysHybrid, decryptKeysHybrid } from './core';\nimport { encryptEmailAndSubject, decryptEmailAndSubject } from './coreSubject';\nimport {\n  InvalidInputEmail,\n} from './errors';\n\n/**\n * Encrypts the email and its subject using hybrid encryption for multiple recipients.\n *\n * @param email - The email and subject to encrypt for multiple recipients.\n * @param recipients - The recipients with corresponding public keys.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The set of encrypted keys and encrypted email and subject\n */\nexport async function encryptEmailAndSubjectHybridForMultipleRecipients(\n  email: EmailAndSubject,\n  recipients: RecipientWithPublicKey[],\n  aux?: Uint8Array,\n): Promise<{ encryptedKeys: HybridEncKey[]; encEmail: EmailAndSubjectEncrypted }> {\n    if (!recipients || recipients.length === 0) {\n      throw new InvalidInputEmail();\n    }\n    const { encryptionKey, encEmail } = await encryptEmailAndSubject(email, aux);\n\n    const encryptedKeys = await Promise.all(recipients.map((recipient) => encryptKeysHybrid(encryptionKey, recipient)));\n\n    return { encEmail, encryptedKeys };\n}\n\n/**\n * Decrypts the email and its subject using hybrid encryption.\n *\n * @param encEmail - The encrypted email and subject.\n * @param encryptedKey - The encrypted key for this recipient.\n * @param recipientPrivateHybridKeys - The private key of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email and subject\n */\nexport async function decryptEmailAndSubjectHybrid(\n  encEmail: EmailAndSubjectEncrypted,\n  encryptedKey: HybridEncKey,\n  recipientPrivateHybridKeys: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailAndSubject> {\n    const encryptionKey = await decryptKeysHybrid(encryptedKey, recipientPrivateHybridKeys);\n    return await decryptEmailAndSubject(encEmail, encryptionKey, aux);\n}\n","import { EmailAndSubject, PwdProtectedEmailAndSubject } from '../types';\nimport { passwordProtectKey, removePasswordProtection } from './core';\nimport { encryptEmailAndSubject, decryptEmailAndSubject } from './coreSubject';\nimport {\n  FailedToDecryptEmail,\n  FailedToEncryptEmail,\n  InvalidInputEmail,\n  EmailPasswordOpenError,\n  EmailPasswordProtectError,\n  EmailSymmetricDecryptionError,\n  EmailSymmetricEncryptionError,\n} from './errors';\n\n/**\n * Creates a password-protected email and subject.\n *\n * @param email - The email and subject to password-protect\n * @param password - The secret password shared among recipients\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The password-protected email\n */\nexport async function createPwdProtectedEmailAndSubject(\n  email: EmailAndSubject,\n  password: string,\n  aux?: Uint8Array,\n): Promise<PwdProtectedEmailAndSubject> {\n  try {\n    const { encryptionKey, encEmail } = await encryptEmailAndSubject(email, aux);\n    const encryptedKey = await passwordProtectKey(encryptionKey, password);\n\n    return { encEmail, encryptedKey };\n  } catch (error) {\n    if (error instanceof InvalidInputEmail) throw error;\n    if (error instanceof EmailSymmetricEncryptionError) throw error;\n    if (error instanceof EmailPasswordProtectError) throw error;\n    throw new FailedToEncryptEmail(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Opens a password-protected email and subject.\n *\n * @param encryptedEmail - The encrypted email and subject\n * @param password - The secret password shared among recipients.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email and subject\n */\nexport async function decryptPwdProtectedEmailAndSubject(\n  encryptedEmail: PwdProtectedEmailAndSubject,\n  password: string,\n  aux?: Uint8Array,\n): Promise<EmailAndSubject> {\n  if (!encryptedEmail?.encEmail || !encryptedEmail?.encryptedKey) {\n    throw new InvalidInputEmail();\n  }\n  try {\n    const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);\n    return await decryptEmailAndSubject(encryptedEmail.encEmail, encryptionKey, aux);\n  } catch (error) {\n    if (error instanceof EmailPasswordOpenError) throw error;\n    if (error instanceof EmailSymmetricDecryptionError) throw error;\n    throw new FailedToDecryptEmail(error instanceof Error ? error.message : String(error));\n  }\n}\n","import { genHybridKeys } from '../hybrid-crypto';\nimport { HybridKeyPair } from '../types';\nimport { deriveKeyFromMnemonic } from '../derive-key';\nimport { CONTEXT_DATABASE, CONTEXT_DRAFT } from '../constants';\n\n/**\n * Generates public and private keys for email encryption.\n *\n * @returns The user's private and public keys\n */\nexport async function generateEmailKeys(): Promise<HybridKeyPair> {\n  return genHybridKeys();\n}\n\n/**\n * Derives database encryption key for the given user\n *\n * @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)\n * @returns The symmetric key for protecting database\n */\nexport const deriveDatabaseKey = async (mnemonic: string): Promise<Uint8Array> => {\n  return deriveKeyFromMnemonic(mnemonic, CONTEXT_DATABASE);\n};\n\n/**\n * Derives email draft encryption key for the given user\n *\n * @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)\n * @returns The symmetric key for protecting email drafts\n */\nexport const deriveEmailDraftKey = async (mnemonic: string): Promise<Uint8Array> => {\n  return deriveKeyFromMnemonic(mnemonic, CONTEXT_DRAFT);\n};\n"],"mappings":"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"}