internxt-crypto 1.3.0 → 1.4.0

package/dist/email-crypto-Di814Pbk.js

@@ -0,0 +1,739 @@
+require("./chunk-C13QxCFV.js");
+const require_constants = require("./constants.js");
+const require_utils = require("./utils.js");
+const require_derive_key = require("./derive-key.js");
+const require_derive_password = require("./derive-password-CbYRDq7V.js");
+const require_symmetric_crypto = require("./symmetric-crypto.js");
+const require_xwing = require("./xwing-7fEqAT7W.js");
+let _noble_ciphers_aes_js = require("@noble/ciphers/aes.js");
+//#region src/key-wrapper/aesWrapper.ts
+/**
+* Unwraps the given wrapped key
+*
+* @param encryptedKey - The wrapped key
+* @param wrappingKey - The secret key used for unwrapping
+* @returns The resulting key
+*/
+async function unwrapKey(encryptedKey, wrappingKey) {
+	return (0, _noble_ciphers_aes_js.aeskw)(wrappingKey).decrypt(encryptedKey);
+}
+/**
+* Wraps the given key
+*
+* @param key - The key to be wrapped
+* @param wrappingKey - The secret key used for wrapping
+* @returns The resulting ciphertext
+*/
+async function wrapKey(key, wrappingKey) {
+	return (0, _noble_ciphers_aes_js.aeskw)(wrappingKey).encrypt(key);
+}
+//#endregion
+//#region src/email-crypto/errors.ts
+var FailedToEncryptEmail = class FailedToEncryptEmail extends Error {
+	constructor(errorMsg) {
+		super("Failed to encrypt email: " + errorMsg);
+		Object.setPrototypeOf(this, FailedToEncryptEmail.prototype);
+	}
+};
+var EmailSymmetricEncryptionError = class EmailSymmetricEncryptionError extends Error {
+	constructor(errorMsg) {
+		super("Failed to symmetrically encrypt email: " + errorMsg);
+		Object.setPrototypeOf(this, EmailSymmetricEncryptionError.prototype);
+	}
+};
+var EmailSymmetricDecryptionError = class EmailSymmetricDecryptionError extends Error {
+	constructor(errorMsg) {
+		super("Failed to symmetrically decrypt email: " + errorMsg);
+		Object.setPrototypeOf(this, EmailSymmetricDecryptionError.prototype);
+	}
+};
+var EmailHybridEncryptionError = class EmailHybridEncryptionError extends Error {
+	constructor(errorMsg) {
+		super("Failed to hybridly encrypt the key: " + errorMsg);
+		Object.setPrototypeOf(this, EmailHybridEncryptionError.prototype);
+	}
+};
+var EmailHybridDecryptionError = class EmailHybridDecryptionError extends Error {
+	constructor(errorMsg) {
+		super("Failed to hybridly decrypt the key: " + errorMsg);
+		Object.setPrototypeOf(this, EmailHybridDecryptionError.prototype);
+	}
+};
+var EmailPasswordProtectError = class EmailPasswordProtectError extends Error {
+	constructor(errorMsg) {
+		super("Failed to password-protect the key: " + errorMsg);
+		Object.setPrototypeOf(this, EmailPasswordProtectError.prototype);
+	}
+};
+var EmailPasswordOpenError = class EmailPasswordOpenError extends Error {
+	constructor(errorMsg) {
+		super("Failed to open password-protected key: " + errorMsg);
+		Object.setPrototypeOf(this, EmailPasswordOpenError.prototype);
+	}
+};
+var InvalidInputEmail = class InvalidInputEmail extends Error {
+	constructor() {
+		super("Invalid input");
+		Object.setPrototypeOf(this, InvalidInputEmail.prototype);
+	}
+};
+var FailedToDecryptEmail = class FailedToDecryptEmail extends Error {
+	constructor(errorMsg) {
+		super("Failed to decrypt email: " + errorMsg);
+		Object.setPrototypeOf(this, FailedToDecryptEmail.prototype);
+	}
+};
+//#endregion
+//#region src/email-crypto/core.ts
+/**
+* Symmetrically encrypts email.
+*
+* @param email - The email to encrypt.
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The resulting encrypted email and symmetric key used for encryption
+*/
+async function encryptEmail(email, aux) {
+	if (!email.text) throw new InvalidInputEmail();
+	try {
+		const encryptionKey = require_symmetric_crypto.genSymmetricKey();
+		return {
+			encEmail: await encryptEmailWithKey(email, encryptionKey, aux),
+			encryptionKey
+		};
+	} catch (error) {
+		throw new EmailSymmetricEncryptionError(error instanceof Error ? error.message : String(error));
+	}
+}
+/**
+* Symmetrically encrypts email with the given key.
+*
+* @param email - The email to encrypt.
+* @param encryptionKey - The symmetric key to encrypt the email.
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The resulting encrypted email and symmetric key used for encryption
+*/
+async function encryptEmailWithKey(email, encryptionKey, aux) {
+	try {
+		const enc = { encText: require_utils.uint8ArrayToBase64(await require_symmetric_crypto.encryptSymmetrically(encryptionKey, require_utils.UTF8ToUint8(email.text), aux)) };
+		if (email.attachments) {
+			const promises = email.attachments.map((attachment) => {
+				return require_symmetric_crypto.encryptSymmetrically(encryptionKey, require_utils.UTF8ToUint8(attachment), aux);
+			});
+			enc.encAttachments = (await Promise.all(promises))?.map(require_utils.uint8ArrayToBase64);
+		}
+		return enc;
+	} catch (error) {
+		throw new EmailSymmetricEncryptionError(error instanceof Error ? error.message : String(error));
+	}
+}
+/**
+* Decrypts symmetrically encrypted email.
+*
+* @param encEmail - The email 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 decryptEmail(encEmail, encryptionKey, aux) {
+	try {
+		const email = { text: require_utils.uint8ToUTF8(await require_symmetric_crypto.decryptSymmetrically(encryptionKey, require_utils.base64ToUint8Array(encEmail.encText), aux)) };
+		if (encEmail.encAttachments) {
+			const promises = (encEmail.encAttachments?.map(require_utils.base64ToUint8Array))?.map((encAtt) => require_symmetric_crypto.decryptSymmetrically(encryptionKey, encAtt, aux));
+			email.attachments = (await Promise.all(promises))?.map((att) => require_utils.uint8ToUTF8(att));
+		}
+		return email;
+	} catch (error) {
+		throw new EmailSymmetricDecryptionError(error instanceof Error ? error.message : String(error));
+	}
+}
+/**
+* Encrypts the email symmetric key using hybrid encryption.
+*
+* @param emailEncryptionKey - The symmetric key used for email encryption.
+* @param recipient - The recipient with a public hybrid key.
+* @returns The encrypted email symmetric key
+*/
+async function encryptKeysHybrid(emailEncryptionKey, recipient) {
+	try {
+		const { cipherText, sharedSecret } = require_xwing.encapsulateHybrid(recipient.publicHybridKey);
+		return {
+			encryptedKey: require_utils.uint8ArrayToBase64(await wrapKey(emailEncryptionKey, sharedSecret)),
+			hybridCiphertext: require_utils.uint8ArrayToBase64(cipherText),
+			encryptedForEmail: recipient.email
+		};
+	} catch (error) {
+		throw new EmailHybridEncryptionError(error instanceof Error ? error.message : String(error));
+	}
+}
+/**
+* Decrypts the email symmetric key encrypted via hybrid encryption.
+*
+* @param encryptedKey - The encrypted email key.
+* @param recipientPrivateKey - The private key of the recipient.
+* @returns The email encryption key
+*/
+async function decryptKeysHybrid(encryptedKey, recipientPrivateKey) {
+	try {
+		const kyberCiphertext = require_utils.base64ToUint8Array(encryptedKey.hybridCiphertext);
+		return await unwrapKey(require_utils.base64ToUint8Array(encryptedKey.encryptedKey), require_xwing.decapsulateHybrid(kyberCiphertext, recipientPrivateKey));
+	} catch (error) {
+		throw new EmailHybridDecryptionError(error instanceof Error ? error.message : String(error));
+	}
+}
+/**
+* Password-protects the email symmetric key.
+*
+* @param emailEncryptionKey - The symmetric key used for email encryption.
+* @param password - The secret password for key protection.
+* @returns The password-protected email symmetric key
+*/
+async function passwordProtectKey(emailEncryptionKey, password) {
+	try {
+		const { key, salt } = await require_derive_password.getKeyFromPassword(password);
+		const encryptedKey = await wrapKey(emailEncryptionKey, key);
+		const saltStr = require_utils.uint8ArrayToBase64(salt);
+		return {
+			encryptedKey: require_utils.uint8ArrayToBase64(encryptedKey),
+			salt: saltStr
+		};
+	} catch (error) {
+		throw new EmailPasswordProtectError(error instanceof Error ? error.message : String(error));
+	}
+}
+/**
+* Removes passoword-protection and exposes the email symmetric key.
+*
+* @param emailEncryptionKey -  The password-protected email key.
+* @param password - The secret password for key protection.
+* @returns The email encryption key
+*/
+async function removePasswordProtection(emailEncryptionKey, password) {
+	try {
+		const salt = require_utils.base64ToUint8Array(emailEncryptionKey.salt);
+		return await unwrapKey(require_utils.base64ToUint8Array(emailEncryptionKey.encryptedKey), await require_derive_password.getKeyFromPasswordAndSalt(password, salt));
+	} catch (error) {
+		throw new EmailPasswordOpenError(error instanceof Error ? error.message : String(error));
+	}
+}
+//#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
+*/
+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));
+	}
+}
+/**
+* Decrypts the email using hybrid encryption.
+*
+* @param encEmail - The encrypted email.
+* @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));
+	}
+}
+//#endregion
+//#region src/email-crypto/pwdProtectedEmail.ts
+/**
+* Creates a password-protected email.
+*
+* @param email - The email to password-protect
+* @param password - The secret password shared among recipients
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The password-protected email
+*/
+async function createPwdProtectedEmail(email, password, aux) {
+	try {
+		const { encryptionKey, encEmail } = await encryptEmail(email, aux);
+		return {
+			encEmail,
+			encryptedKey: await passwordProtectKey(encryptionKey, password)
+		};
+	} catch (error) {
+		if (error instanceof InvalidInputEmail) throw error;
+		if (error instanceof EmailSymmetricEncryptionError) throw error;
+		if (error instanceof EmailPasswordProtectError) throw error;
+		throw new FailedToEncryptEmail(error instanceof Error ? error.message : String(error));
+	}
+}
+/**
+* Opens a password-protected email.
+*
+* @param encryptedEmail - The encrypted email
+* @param password - The secret password shared among recipients.
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The decrypted email
+*/
+async function decryptPwdProtectedEmail(encryptedEmail, password, aux) {
+	if (!encryptedEmail?.encEmail || !encryptedEmail?.encryptedKey) throw new InvalidInputEmail();
+	try {
+		const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);
+		return await decryptEmail(encryptedEmail.encEmail, encryptionKey, aux);
+	} catch (error) {
+		if (error instanceof EmailPasswordOpenError) throw error;
+		if (error instanceof EmailSymmetricDecryptionError) throw error;
+		throw new FailedToDecryptEmail(error instanceof Error ? error.message : String(error));
+	}
+}
+//#endregion
+//#region src/email-crypto/coreSubject.ts
+/**
+* Symmetrically encrypts email and subject.
+*
+* @param email - The email and subject to encrypt.
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The resulting encrypted email and symmetric key used for encryption
+*/
+async function encryptEmailAndSubject(email, aux) {
+	if (!email.text || !email.subject) throw new InvalidInputEmail();
+	try {
+		const encryptionKey = require_symmetric_crypto.genSymmetricKey();
+		return {
+			encEmail: await encryptEmailAndSubjectWithKey(email, encryptionKey, aux),
+			encryptionKey
+		};
+	} catch (error) {
+		throw new EmailSymmetricEncryptionError(error instanceof Error ? error.message : String(error));
+	}
+}
+/**
+* Symmetrically encrypts email and subject with the given key.
+*
+* @param email - The email and subject to encrypt.
+* @param encryptionKey - The symmetric key to encrypt the email.
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The resulting encrypted email and symmetric key used for encryption
+*/
+async function encryptEmailAndSubjectWithKey(email, encryptionKey, aux) {
+	try {
+		const enc = await encryptEmailWithKey(email, encryptionKey, aux);
+		const encSubject = require_utils.uint8ArrayToBase64(await require_symmetric_crypto.encryptSymmetrically(encryptionKey, require_utils.UTF8ToUint8(email.subject), aux));
+		return {
+			...enc,
+			encSubject
+		};
+	} catch (error) {
+		throw new EmailSymmetricEncryptionError(error instanceof Error ? error.message : String(error));
+	}
+}
+/**
+* Decrypts symmetrically encrypted email and email subject.
+*
+* @param encEmail - The encrypted email and subject 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 and subject
+*/
+async function decryptEmailAndSubject(encEmail, encryptionKey, aux) {
+	try {
+		const subject = require_utils.uint8ToUTF8(await require_symmetric_crypto.decryptSymmetrically(encryptionKey, require_utils.base64ToUint8Array(encEmail.encSubject), aux));
+		return {
+			...await decryptEmail(encEmail, encryptionKey, aux),
+			subject
+		};
+	} catch (error) {
+		throw new EmailSymmetricDecryptionError(error instanceof Error ? error.message : String(error));
+	}
+}
+//#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
+*/
+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));
+	}
+}
+/**
+* Decrypts the email and its subject using hybrid encryption.
+*
+* @param hybridEmail - The encrypted email and subject.
+* @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));
+	}
+}
+//#endregion
+//#region src/email-crypto/pwdProtectedEmailAndSubject.ts
+/**
+* Creates a password-protected email and subject.
+*
+* @param email - The email and subject to password-protect
+* @param password - The secret password shared among recipients
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The password-protected email
+*/
+async function createPwdProtectedEmailAndSubject(email, password, aux) {
+	try {
+		const { encryptionKey, encEmail } = await encryptEmailAndSubject(email, aux);
+		return {
+			encEmail,
+			encryptedKey: await passwordProtectKey(encryptionKey, password)
+		};
+	} catch (error) {
+		if (error instanceof InvalidInputEmail) throw error;
+		if (error instanceof EmailSymmetricEncryptionError) throw error;
+		if (error instanceof EmailPasswordProtectError) throw error;
+		throw new FailedToEncryptEmail(error instanceof Error ? error.message : String(error));
+	}
+}
+/**
+* Opens a password-protected email and subject.
+*
+* @param encryptedEmail - The encrypted email and subject
+* @param password - The secret password shared among recipients.
+* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
+* @returns The decrypted email and subject
+*/
+async function decryptPwdProtectedEmailAndSubject(encryptedEmail, password, aux) {
+	if (!encryptedEmail?.encEmail || !encryptedEmail?.encryptedKey) throw new InvalidInputEmail();
+	try {
+		const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);
+		return await decryptEmailAndSubject(encryptedEmail.encEmail, encryptionKey, aux);
+	} catch (error) {
+		if (error instanceof EmailPasswordOpenError) throw error;
+		if (error instanceof EmailSymmetricDecryptionError) throw error;
+		throw new FailedToDecryptEmail(error instanceof Error ? error.message : String(error));
+	}
+}
+//#endregion
+//#region src/email-crypto/emailKeys.ts
+/**
+* Generates public and private keys for email encryption.
+*
+* @returns The user's private and public keys
+*/
+async function generateEmailKeys() {
+	return require_xwing.genHybridKeys();
+}
+/**
+* Derives database encryption key for the given user
+*
+* @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)
+* @returns The symmetric key for protecting database
+*/
+const deriveDatabaseKey = async (mnemonic) => {
+	return require_derive_key.deriveKeyFromMnemonic(mnemonic, require_constants.CONTEXT_DATABASE);
+};
+/**
+* Derives email draft encryption key for the given user
+*
+* @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)
+* @returns The symmetric key for protecting email drafts
+*/
+const deriveEmailDraftKey = async (mnemonic) => {
+	return require_derive_key.deriveKeyFromMnemonic(mnemonic, require_constants.CONTEXT_DRAFT);
+};
+//#endregion
+Object.defineProperty(exports, "EmailHybridDecryptionError", {
+	enumerable: true,
+	get: function() {
+		return EmailHybridDecryptionError;
+	}
+});
+Object.defineProperty(exports, "EmailHybridEncryptionError", {
+	enumerable: true,
+	get: function() {
+		return EmailHybridEncryptionError;
+	}
+});
+Object.defineProperty(exports, "EmailPasswordOpenError", {
+	enumerable: true,
+	get: function() {
+		return EmailPasswordOpenError;
+	}
+});
+Object.defineProperty(exports, "EmailPasswordProtectError", {
+	enumerable: true,
+	get: function() {
+		return EmailPasswordProtectError;
+	}
+});
+Object.defineProperty(exports, "EmailSymmetricDecryptionError", {
+	enumerable: true,
+	get: function() {
+		return EmailSymmetricDecryptionError;
+	}
+});
+Object.defineProperty(exports, "EmailSymmetricEncryptionError", {
+	enumerable: true,
+	get: function() {
+		return EmailSymmetricEncryptionError;
+	}
+});
+Object.defineProperty(exports, "FailedToDecryptEmail", {
+	enumerable: true,
+	get: function() {
+		return FailedToDecryptEmail;
+	}
+});
+Object.defineProperty(exports, "FailedToEncryptEmail", {
+	enumerable: true,
+	get: function() {
+		return FailedToEncryptEmail;
+	}
+});
+Object.defineProperty(exports, "InvalidInputEmail", {
+	enumerable: true,
+	get: function() {
+		return InvalidInputEmail;
+	}
+});
+Object.defineProperty(exports, "createPwdProtectedEmail", {
+	enumerable: true,
+	get: function() {
+		return createPwdProtectedEmail;
+	}
+});
+Object.defineProperty(exports, "createPwdProtectedEmailAndSubject", {
+	enumerable: true,
+	get: function() {
+		return createPwdProtectedEmailAndSubject;
+	}
+});
+Object.defineProperty(exports, "decryptEmail", {
+	enumerable: true,
+	get: function() {
+		return decryptEmail;
+	}
+});
+Object.defineProperty(exports, "decryptEmailAndSubject", {
+	enumerable: true,
+	get: function() {
+		return decryptEmailAndSubject;
+	}
+});
+Object.defineProperty(exports, "decryptEmailAndSubjectHybrid", {
+	enumerable: true,
+	get: function() {
+		return decryptEmailAndSubjectHybrid;
+	}
+});
+Object.defineProperty(exports, "decryptEmailHybrid", {
+	enumerable: true,
+	get: function() {
+		return decryptEmailHybrid;
+	}
+});
+Object.defineProperty(exports, "decryptKeysHybrid", {
+	enumerable: true,
+	get: function() {
+		return decryptKeysHybrid;
+	}
+});
+Object.defineProperty(exports, "decryptPwdProtectedEmail", {
+	enumerable: true,
+	get: function() {
+		return decryptPwdProtectedEmail;
+	}
+});
+Object.defineProperty(exports, "decryptPwdProtectedEmailAndSubject", {
+	enumerable: true,
+	get: function() {
+		return decryptPwdProtectedEmailAndSubject;
+	}
+});
+Object.defineProperty(exports, "deriveDatabaseKey", {
+	enumerable: true,
+	get: function() {
+		return deriveDatabaseKey;
+	}
+});
+Object.defineProperty(exports, "deriveEmailDraftKey", {
+	enumerable: true,
+	get: function() {
+		return deriveEmailDraftKey;
+	}
+});
+Object.defineProperty(exports, "encryptEmail", {
+	enumerable: true,
+	get: function() {
+		return encryptEmail;
+	}
+});
+Object.defineProperty(exports, "encryptEmailAndSubject", {
+	enumerable: true,
+	get: function() {
+		return encryptEmailAndSubject;
+	}
+});
+Object.defineProperty(exports, "encryptEmailAndSubjectHybrid", {
+	enumerable: true,
+	get: function() {
+		return encryptEmailAndSubjectHybrid;
+	}
+});
+Object.defineProperty(exports, "encryptEmailAndSubjectHybridForMultipleRecipients", {
+	enumerable: true,
+	get: function() {
+		return encryptEmailAndSubjectHybridForMultipleRecipients;
+	}
+});
+Object.defineProperty(exports, "encryptEmailAndSubjectWithKey", {
+	enumerable: true,
+	get: function() {
+		return encryptEmailAndSubjectWithKey;
+	}
+});
+Object.defineProperty(exports, "encryptEmailHybrid", {
+	enumerable: true,
+	get: function() {
+		return encryptEmailHybrid;
+	}
+});
+Object.defineProperty(exports, "encryptEmailHybridForMultipleRecipients", {
+	enumerable: true,
+	get: function() {
+		return encryptEmailHybridForMultipleRecipients;
+	}
+});
+Object.defineProperty(exports, "encryptEmailWithKey", {
+	enumerable: true,
+	get: function() {
+		return encryptEmailWithKey;
+	}
+});
+Object.defineProperty(exports, "encryptKeysHybrid", {
+	enumerable: true,
+	get: function() {
+		return encryptKeysHybrid;
+	}
+});
+Object.defineProperty(exports, "generateEmailKeys", {
+	enumerable: true,
+	get: function() {
+		return generateEmailKeys;
+	}
+});
+Object.defineProperty(exports, "passwordProtectKey", {
+	enumerable: true,
+	get: function() {
+		return passwordProtectKey;
+	}
+});
+Object.defineProperty(exports, "removePasswordProtection", {
+	enumerable: true,
+	get: function() {
+		return removePasswordProtection;
+	}
+});
+Object.defineProperty(exports, "unwrapKey", {
+	enumerable: true,
+	get: function() {
+		return unwrapKey;
+	}
+});
+Object.defineProperty(exports, "wrapKey", {
+	enumerable: true,
+	get: function() {
+		return wrapKey;
+	}
+});
+
+//# sourceMappingURL=email-crypto-Di814Pbk.js.map