internxt-crypto 1.5.0 → 1.6.1

package/dist/react-native/email-crypto-C3ka3aAj.js

@@ -0,0 +1,700 @@
+require("./chunk-DskHE4z1.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-DIPrE8Mz.js");
+const require_symmetric_crypto = require("./symmetric-crypto.js");
+const require_xwing = require("./xwing-CSdiyHAt.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);
+		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);
+	}
+};
+//#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 text = require_utils.UTF8ToUint8(email.text);
+		const preview = require_utils.UTF8ToUint8(email.preview);
+		return {
+			encText: require_utils.uint8ArrayToBase64(await require_symmetric_crypto.encryptSymmetrically(encryptionKey, text, aux)),
+			encPreview: require_utils.uint8ArrayToBase64(await require_symmetric_crypto.encryptSymmetrically(encryptionKey, preview, aux)),
+			encAttachmentsSessionKey: require_utils.uint8ArrayToBase64(await require_symmetric_crypto.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 require_utils.uint8ToUTF8(await require_symmetric_crypto.decryptSymmetrically(encryptionKey, require_utils.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.
+* @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 {
+		return {
+			text: require_utils.uint8ToUTF8(await require_symmetric_crypto.decryptSymmetrically(encryptionKey, require_utils.base64ToUint8Array(encEmail.encText), aux)),
+			preview: require_utils.uint8ToUTF8(await require_symmetric_crypto.decryptSymmetrically(encryptionKey, require_utils.base64ToUint8Array(encEmail.encPreview), aux)),
+			attachmentsSessionKey: await require_symmetric_crypto.decryptSymmetrically(encryptionKey, require_utils.base64ToUint8Array(encEmail.encAttachmentsSessionKey), aux)
+		};
+	} 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 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 keys (one per user) and encrypted email
+*/
+async function encryptEmailHybridForMultipleRecipients(email, recipients, aux) {
+	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, 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
+/**
+* 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 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 keys and encrypted email and subject
+*/
+async function encryptEmailAndSubjectHybridForMultipleRecipients(email, recipients, aux) {
+	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 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(encEmail, encryptedKey, recipientPrivateHybridKeys, aux) {
+	return await decryptEmailAndSubject(encEmail, await decryptKeysHybrid(encryptedKey, recipientPrivateHybridKeys), aux);
+}
+//#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, "EmailPreviewSymmetricDecryptionError", {
+	enumerable: true,
+	get: function() {
+		return EmailPreviewSymmetricDecryptionError;
+	}
+});
+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, "decryptEmailPreviewHybrid", {
+	enumerable: true,
+	get: function() {
+		return decryptEmailPreviewHybrid;
+	}
+});
+Object.defineProperty(exports, "decryptKeysHybrid", {
+	enumerable: true,
+	get: function() {
+		return decryptKeysHybrid;
+	}
+});
+Object.defineProperty(exports, "decryptPreview", {
+	enumerable: true,
+	get: function() {
+		return decryptPreview;
+	}
+});
+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, "encryptEmailAndSubjectHybridForMultipleRecipients", {
+	enumerable: true,
+	get: function() {
+		return encryptEmailAndSubjectHybridForMultipleRecipients;
+	}
+});
+Object.defineProperty(exports, "encryptEmailAndSubjectWithKey", {
+	enumerable: true,
+	get: function() {
+		return encryptEmailAndSubjectWithKey;
+	}
+});
+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-C3ka3aAj.js.map