internxt-crypto 1.0.1 → 1.1.0

package/dist/{emailEncryptionKey-BtSPYd9M.mjs.map → emailEncryptionKey-kIsseFo6.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"emailEncryptionKey-BtSPYd9M.mjs","names":[],"sources":["../src/keystore-crypto/core.ts","../src/keystore-crypto/emailEncryptionKey.ts"],"sourcesContent":["import { encryptSymmetrically, decryptSymmetrically } from '../symmetric-crypto';\nimport { base64ToUint8Array, uint8ArrayToBase64, UTF8ToUint8, mnemonicToBytes } from '../utils';\nimport { deriveSymmetricKeyFromContext } from '../derive-key';\nimport { CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY } from '../constants';\nimport { EncryptedKeystore, HybridKeyPair, KeystoreType } from '../types';\n\n/**\n * Encrypts the user's hybrid key using symmetric encryption to get a keystore\n *\n * @param secretKey - The symmetric key to encrypt the keystore content\n * @param key - The hybrid key pair\n * @param userEmail - The email of the user\n * @param type - The keystore type\n * @returns The encrypted keystore\n */\nexport async function encryptKeystoreContent(\n  secretKey: Uint8Array,\n  keys: HybridKeyPair,\n  userEmail: string,\n  type: KeystoreType,\n): Promise<EncryptedKeystore> {\n  try {\n    const aux = UTF8ToUint8(userEmail + type);\n    const publicKey = uint8ArrayToBase64(keys.publicKey);\n    const secretKeyEncrypted = await encryptSymmetrically(secretKey, keys.secretKey, aux);\n\n    const keystore: EncryptedKeystore = {\n      userEmail,\n      type,\n      publicKey,\n      privateKeyEncrypted: uint8ArrayToBase64(secretKeyEncrypted),\n    };\n    return keystore;\n  } catch (error) {\n    throw new Error('Failed to encrypt keystore content', { cause: error });\n  }\n}\n\n/**\n * Decrypts the keystore content using symmetric encryption\n *\n * @param kesytoreOpeningKey - The symmetric key to decrypt the keystore content\n * @param encryptedKeys - The encrypted keystore content\n * @returns The decrypted hybrid key pair contained in the keystore\n */\nexport async function decryptKeystoreContent(\n  kesytoreOpeningKey: Uint8Array,\n  encryptedKeystore: EncryptedKeystore,\n): Promise<HybridKeyPair> {\n  try {\n    const aux = UTF8ToUint8(encryptedKeystore.userEmail + encryptedKeystore.type);\n    const publicKey = base64ToUint8Array(encryptedKeystore.publicKey);\n    const ciphertext = base64ToUint8Array(encryptedKeystore.privateKeyEncrypted);\n    const secretKey = await decryptSymmetrically(kesytoreOpeningKey, ciphertext, aux);\n    return {\n      publicKey,\n      secretKey,\n    };\n  } catch (error) {\n    throw new Error('Failed to decrypt keystore content', { cause: error });\n  }\n}\n\n/**\n * Derives a secret key for protecting the recovery keystore\n *\n * @param recoveryCodes - The recovery codes\n * @returns The derived secret key for protecting the recovery keystore\n */\nexport async function deriveRecoveryKey(recoveryCodes: string): Promise<Uint8Array> {\n  const recoverCodesArray = mnemonicToBytes(recoveryCodes);\n  return deriveSymmetricKeyFromContext(CONTEXT_RECOVERY, recoverCodesArray);\n}\n\n/**\n * Derives a secret key for protecting the encryption keystore\n *\n * @param baseKey - The base secret key from which a new key secret will be derived\n * @returns The derived secret key for protecting the encryption keystore\n */\nexport async function deriveEncryptionKeystoreKey(baseKey: Uint8Array): Promise<Uint8Array> {\n  return deriveSymmetricKeyFromContext(CONTEXT_ENC_KEYSTORE, baseKey);\n}\n","import { EncryptedKeystore, KeystoreType, HybridKeyPair } from '../types';\nimport { genMnemonic } from '../utils';\nimport { encryptKeystoreContent, decryptKeystoreContent, deriveEncryptionKeystoreKey, deriveRecoveryKey } from './core';\nimport { genHybridKeys } from '../hybrid-crypto';\n\n/**\n * Generates hybrid keys and creates encrypted main and recovery keystores\n * The main keystore encryption key is derived from the base key (stored in session storage)\n * The recovery keystore encryption key is derived from the recovery codes\n *\n * @returns The encryption and recovery keystores, recovery codes and hybrid keys\n */\nexport async function createEncryptionAndRecoveryKeystores(\n  userEmail: string,\n  baseKey: Uint8Array,\n): Promise<{\n  encryptionKeystore: EncryptedKeystore;\n  recoveryKeystore: EncryptedKeystore;\n  recoveryCodes: string;\n  keys: HybridKeyPair;\n}> {\n  try {\n    const keys = genHybridKeys();\n\n    const secretKey = await deriveEncryptionKeystoreKey(baseKey);\n    const encryptionKeystore = await encryptKeystoreContent(secretKey, keys, userEmail, KeystoreType.ENCRYPTION);\n\n    const recoveryCodes = genMnemonic();\n    const recoveryKey = await deriveRecoveryKey(recoveryCodes);\n    const recoveryKeystore = await encryptKeystoreContent(recoveryKey, keys, userEmail, KeystoreType.RECOVERY);\n\n    return { encryptionKeystore, recoveryKeystore, recoveryCodes, keys };\n  } catch (error) {\n    throw new Error('Failed to create encryption and recovery keystores', { cause: error });\n  }\n}\n\n/**\n * Opens the encryption keystore and returns the email encryption keys\n * The decryption key is derived from the base key (stored in session storage)\n *\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @param baseKey - The base key from which the decryption key will be derived\n * @returns The encryption keys\n */\nexport async function openEncryptionKeystore(\n  encryptedKeystore: EncryptedKeystore,\n  baseKey: Uint8Array,\n): Promise<HybridKeyPair> {\n  try {\n    if (encryptedKeystore.type != KeystoreType.ENCRYPTION) {\n      throw new Error('Input is invalid');\n    }\n    const secretKey = await deriveEncryptionKeystoreKey(baseKey);\n    const keys = await decryptKeystoreContent(secretKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to open encryption keystore', { cause: error });\n  }\n}\n\n/**\n * Opens the recovery keystore and returns the email encryption keys\n * The decryption key is derived from the base key (stored in session storage)\n *\n * @param recoveryCodes - The user's recovery codes\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @returns The encryption keys\n */\nexport async function openRecoveryKeystore(\n  recoveryCodes: string,\n  encryptedKeystore: EncryptedKeystore,\n): Promise<HybridKeyPair> {\n  try {\n    if (encryptedKeystore.type != KeystoreType.RECOVERY) {\n      throw new Error('Input is invalid');\n    }\n    const recoveryKey = await deriveRecoveryKey(recoveryCodes);\n    const keys = await decryptKeystoreContent(recoveryKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to open recovery keystore', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAeA,eAAsB,uBACpB,WACA,MACA,WACA,MAC4B;AAC5B,KAAI;EACF,MAAM,MAAM,YAAY,YAAY,KAAK;AAUzC,SANoC;GAClC;GACA;GACA,WANgB,mBAAmB,KAAK,UAAU;GAOlD,qBAAqB,mBANI,MAAM,qBAAqB,WAAW,KAAK,WAAW,IAAI,CAMxB;GAC5D;UAEM,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW3E,eAAsB,uBACpB,oBACA,mBACwB;AACxB,KAAI;EACF,MAAM,MAAM,YAAY,kBAAkB,YAAY,kBAAkB,KAAK;AAI7E,SAAO;GACL,WAJgB,mBAAmB,kBAAkB,UAAU;GAK/D,WAHgB,MAAM,qBAAqB,oBAD1B,mBAAmB,kBAAkB,oBAAoB,EACC,IAAI;GAIhF;UACM,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU3E,eAAsB,kBAAkB,eAA4C;AAElF,QAAO,8BAA8B,kBADX,gBAAgB,cAAc,CACiB;;;;;;;;AAS3E,eAAsB,4BAA4B,SAA0C;AAC1F,QAAO,8BAA8B,sBAAsB,QAAQ;;;;;;;;;;;;ACrErE,eAAsB,qCACpB,WACA,SAMC;AACD,KAAI;EACF,MAAM,OAAO,eAAe;EAG5B,MAAM,qBAAqB,MAAM,uBADf,MAAM,4BAA4B,QAAQ,EACO,MAAM,WAAW,aAAa,WAAW;EAE5G,MAAM,gBAAgB,aAAa;AAInC,SAAO;GAAE;GAAoB,kBAFJ,MAAM,uBADX,MAAM,kBAAkB,cAAc,EACS,MAAM,WAAW,aAAa,SAAS;GAE3D;GAAe;GAAM;UAC7D,OAAO;AACd,QAAM,IAAI,MAAM,sDAAsD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY3F,eAAsB,uBACpB,mBACA,SACwB;AACxB,KAAI;AACF,MAAI,kBAAkB,QAAQ,aAAa,WACzC,OAAM,IAAI,MAAM,mBAAmB;AAIrC,SADa,MAAM,uBADD,MAAM,4BAA4B,QAAQ,EACP,kBAAkB;UAEhE,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY3E,eAAsB,qBACpB,eACA,mBACwB;AACxB,KAAI;AACF,MAAI,kBAAkB,QAAQ,aAAa,SACzC,OAAM,IAAI,MAAM,mBAAmB;AAIrC,SADa,MAAM,uBADC,MAAM,kBAAkB,cAAc,EACH,kBAAkB;UAElE,OAAO;AACd,QAAM,IAAI,MAAM,oCAAoC,EAAE,OAAO,OAAO,CAAC"}
+{"version":3,"file":"emailEncryptionKey-kIsseFo6.mjs","names":[],"sources":["../src/keystore-crypto/core.ts","../src/keystore-crypto/emailEncryptionKey.ts"],"sourcesContent":["import { encryptSymmetrically, decryptSymmetrically } from '../symmetric-crypto';\nimport { base64ToUint8Array, uint8ArrayToBase64, UTF8ToUint8, mnemonicToBytes } from '../utils';\nimport { deriveSymmetricKeyFromContext } from '../derive-key';\nimport { CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY } from '../constants';\nimport { EncryptedKeystore, HybridKeyPair, KeystoreType } from '../types';\n\n/**\n * Encrypts the user's hybrid key using symmetric encryption to get a keystore\n *\n * @param secretKey - The symmetric key to encrypt the keystore content\n * @param key - The hybrid key pair\n * @param userEmail - The email of the user\n * @param type - The keystore type\n * @returns The encrypted keystore\n */\nexport async function encryptKeystoreContent(\n  secretKey: Uint8Array,\n  keys: HybridKeyPair,\n  userEmail: string,\n  type: KeystoreType,\n): Promise<EncryptedKeystore> {\n  try {\n    const aux = UTF8ToUint8(userEmail + type);\n    const publicKey = uint8ArrayToBase64(keys.publicKey);\n    const secretKeyEncrypted = await encryptSymmetrically(secretKey, keys.secretKey, aux);\n\n    const keystore: EncryptedKeystore = {\n      userEmail,\n      type,\n      publicKey,\n      privateKeyEncrypted: uint8ArrayToBase64(secretKeyEncrypted),\n    };\n    return keystore;\n  } catch (error) {\n    throw new Error('Failed to encrypt keystore content', { cause: error });\n  }\n}\n\n/**\n * Decrypts the keystore content using symmetric encryption\n *\n * @param kesytoreOpeningKey - The symmetric key to decrypt the keystore content\n * @param encryptedKeys - The encrypted keystore content\n * @returns The decrypted hybrid key pair contained in the keystore\n */\nexport async function decryptKeystoreContent(\n  kesytoreOpeningKey: Uint8Array,\n  encryptedKeystore: EncryptedKeystore,\n): Promise<HybridKeyPair> {\n  try {\n    const aux = UTF8ToUint8(encryptedKeystore.userEmail + encryptedKeystore.type);\n    const publicKey = base64ToUint8Array(encryptedKeystore.publicKey);\n    const ciphertext = base64ToUint8Array(encryptedKeystore.privateKeyEncrypted);\n    const secretKey = await decryptSymmetrically(kesytoreOpeningKey, ciphertext, aux);\n    return {\n      publicKey,\n      secretKey,\n    };\n  } catch (error) {\n    throw new Error('Failed to decrypt keystore content', { cause: error });\n  }\n}\n\n/**\n * Derives a secret key for protecting the recovery keystore\n *\n * @param recoveryCodes - The recovery codes\n * @returns The derived secret key for protecting the recovery keystore\n */\nexport async function deriveRecoveryKey(recoveryCodes: string): Promise<Uint8Array> {\n  const recoverCodesArray = mnemonicToBytes(recoveryCodes);\n  return deriveSymmetricKeyFromContext(CONTEXT_RECOVERY, recoverCodesArray);\n}\n\n/**\n * Derives a secret key for protecting the encryption keystore\n *\n * @param baseKey - The base secret key from which a new key secret will be derived\n * @returns The derived secret key for protecting the encryption keystore\n */\nexport async function deriveEncryptionKeystoreKey(baseKey: Uint8Array): Promise<Uint8Array> {\n  return deriveSymmetricKeyFromContext(CONTEXT_ENC_KEYSTORE, baseKey);\n}\n","import { EncryptedKeystore, KeystoreType, HybridKeyPair } from '../types';\nimport { genMnemonic } from '../utils';\nimport { encryptKeystoreContent, decryptKeystoreContent, deriveEncryptionKeystoreKey, deriveRecoveryKey } from './core';\nimport { genHybridKeys } from '../hybrid-crypto';\n\n/**\n * Generates hybrid keys and creates encrypted main and recovery keystores\n * The main keystore encryption key is derived from the base key (stored in session storage)\n * The recovery keystore encryption key is derived from the recovery codes\n *\n * @returns The encryption and recovery keystores, recovery codes and hybrid keys\n */\nexport async function createEncryptionAndRecoveryKeystores(\n  userEmail: string,\n  baseKey: Uint8Array,\n): Promise<{\n  encryptionKeystore: EncryptedKeystore;\n  recoveryKeystore: EncryptedKeystore;\n  recoveryCodes: string;\n  keys: HybridKeyPair;\n}> {\n  try {\n    const keys = genHybridKeys();\n\n    const secretKey = await deriveEncryptionKeystoreKey(baseKey);\n    const encryptionKeystore = await encryptKeystoreContent(secretKey, keys, userEmail, KeystoreType.ENCRYPTION);\n\n    const recoveryCodes = genMnemonic();\n    const recoveryKey = await deriveRecoveryKey(recoveryCodes);\n    const recoveryKeystore = await encryptKeystoreContent(recoveryKey, keys, userEmail, KeystoreType.RECOVERY);\n\n    return { encryptionKeystore, recoveryKeystore, recoveryCodes, keys };\n  } catch (error) {\n    throw new Error('Failed to create encryption and recovery keystores', { cause: error });\n  }\n}\n\n/**\n * Opens the encryption keystore and returns the email encryption keys\n * The decryption key is derived from the base key (stored in session storage)\n *\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @param baseKey - The base key from which the decryption key will be derived\n * @returns The encryption keys\n */\nexport async function openEncryptionKeystore(\n  encryptedKeystore: EncryptedKeystore,\n  baseKey: Uint8Array,\n): Promise<HybridKeyPair> {\n  try {\n    if (encryptedKeystore.type != KeystoreType.ENCRYPTION) {\n      throw new Error('Input is invalid');\n    }\n    const secretKey = await deriveEncryptionKeystoreKey(baseKey);\n    const keys = await decryptKeystoreContent(secretKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to open encryption keystore', { cause: error });\n  }\n}\n\n/**\n * Opens the recovery keystore and returns the email encryption keys\n * The decryption key is derived from the base key (stored in session storage)\n *\n * @param recoveryCodes - The user's recovery codes\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @returns The encryption keys\n */\nexport async function openRecoveryKeystore(\n  recoveryCodes: string,\n  encryptedKeystore: EncryptedKeystore,\n): Promise<HybridKeyPair> {\n  try {\n    if (encryptedKeystore.type != KeystoreType.RECOVERY) {\n      throw new Error('Input is invalid');\n    }\n    const recoveryKey = await deriveRecoveryKey(recoveryCodes);\n    const keys = await decryptKeystoreContent(recoveryKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to open recovery keystore', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAeA,eAAsB,uBACpB,WACA,MACA,WACA,MAC4B;AAC5B,KAAI;EACF,MAAM,MAAM,YAAY,YAAY,KAAK;AAUzC,SANoC;GAClC;GACA;GACA,WANgB,mBAAmB,KAAK,UAAU;GAOlD,qBAAqB,mBANI,MAAM,qBAAqB,WAAW,KAAK,WAAW,IAAI,CAMxB;GAC5D;UAEM,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW3E,eAAsB,uBACpB,oBACA,mBACwB;AACxB,KAAI;EACF,MAAM,MAAM,YAAY,kBAAkB,YAAY,kBAAkB,KAAK;AAI7E,SAAO;GACL,WAJgB,mBAAmB,kBAAkB,UAAU;GAK/D,WAHgB,MAAM,qBAAqB,oBAD1B,mBAAmB,kBAAkB,oBAAoB,EACC,IAAI;GAIhF;UACM,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU3E,eAAsB,kBAAkB,eAA4C;AAElF,QAAO,8BAA8B,kBADX,gBAAgB,cAAc,CACiB;;;;;;;;AAS3E,eAAsB,4BAA4B,SAA0C;AAC1F,QAAO,8BAA8B,sBAAsB,QAAQ;;;;;;;;;;;;ACrErE,eAAsB,qCACpB,WACA,SAMC;AACD,KAAI;EACF,MAAM,OAAO,eAAe;EAG5B,MAAM,qBAAqB,MAAM,uBADf,MAAM,4BAA4B,QAAQ,EACO,MAAM,WAAW,aAAa,WAAW;EAE5G,MAAM,gBAAgB,aAAa;AAInC,SAAO;GAAE;GAAoB,kBAFJ,MAAM,uBADX,MAAM,kBAAkB,cAAc,EACS,MAAM,WAAW,aAAa,SAAS;GAE3D;GAAe;GAAM;UAC7D,OAAO;AACd,QAAM,IAAI,MAAM,sDAAsD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY3F,eAAsB,uBACpB,mBACA,SACwB;AACxB,KAAI;AACF,MAAI,kBAAkB,QAAQ,aAAa,WACzC,OAAM,IAAI,MAAM,mBAAmB;AAIrC,SADa,MAAM,uBADD,MAAM,4BAA4B,QAAQ,EACP,kBAAkB;UAEhE,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY3E,eAAsB,qBACpB,eACA,mBACwB;AACxB,KAAI;AACF,MAAI,kBAAkB,QAAQ,aAAa,SACzC,OAAM,IAAI,MAAM,mBAAmB;AAIrC,SADa,MAAM,uBADC,MAAM,kBAAkB,cAAc,EACH,kBAAkB;UAElE,OAAO;AACd,QAAM,IAAI,MAAM,oCAAoC,EAAE,OAAO,OAAO,CAAC"}

package/dist/{core-Bj26rNdA.js → emailKeys-DWvKANTZ.js}

@@ -170,18 +170,147 @@ async function removePasswordProtection(emailEncryptionKey, password) {
 }
 
 //#endregion
+//#region src/email-crypto/hybridEncyptedEmail.ts
+/**
+* Encrypts the email body using hybrid encryption.
+*
+* @param body - The email body 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 body
+*/
+async function encryptEmailHybrid(body, recipient, aux) {
+	try {
+		const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);
+		return {
+			encEmailBody,
+			encryptedKey: await encryptKeysHybrid(encryptionKey, recipient)
+		};
+	} catch (error) {
+		throw new Error("Failed to encrypt email body with hybrid encryption", { cause: error });
+	}
+}
+/**
+* Encrypts the email body using hybrid encryption for multiple recipients.
+*
+* @param body - The email body 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 email bodies
+*/
+async function encryptEmailHybridForMultipleRecipients(body, recipients, aux) {
+	try {
+		const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);
+		const encryptedEmails = [];
+		for (const recipient of recipients) {
+			const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);
+			encryptedEmails.push({
+				encEmailBody,
+				encryptedKey
+			});
+		}
+		return encryptedEmails;
+	} catch (error) {
+		throw new Error("Failed to encrypt email to multiple recipients with hybrid encryption", { cause: error });
+	}
+}
+/**
+* Decrypts the email using hybrid encryption.
+*
+* @param encEmailBody - 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 body
+*/
+async function decryptEmailHybrid(encEmailBody, recipientPrivateHybridKeys, aux) {
+	try {
+		const encryptionKey = await decryptKeysHybrid(encEmailBody.encryptedKey, recipientPrivateHybridKeys);
+		return await decryptEmailBody(encEmailBody.encEmailBody, encryptionKey, aux);
+	} catch (error) {
+		throw new Error("Failed to decrypt email with hybrid encryption", { cause: 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(emailBody, password, aux) {
+	try {
+		const { encryptionKey, encEmailBody } = await encryptEmailBody(emailBody, aux);
+		return {
+			encEmailBody,
+			encryptedKey: await passwordProtectKey(encryptionKey, password)
+		};
+	} catch (error) {
+		throw new Error("Failed to password-protect email", { cause: 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 body
+*/
+async function decryptPwdProtectedEmail(encryptedEmail, password, aux) {
+	try {
+		const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);
+		return await decryptEmailBody(encryptedEmail.encEmailBody, encryptionKey, aux);
+	} catch (error) {
+		throw new Error("Failed to decrypt password-protect email", { cause: 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();
+}
+
+//#endregion
+Object.defineProperty(exports, 'createPwdProtectedEmail', {
+  enumerable: true,
+  get: function () {
+    return createPwdProtectedEmail;
+  }
+});
 Object.defineProperty(exports, 'decryptEmailBody', {
   enumerable: true,
   get: function () {
     return decryptEmailBody;
   }
 });
+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, 'encryptEmailBody', {
   enumerable: true,
   get: function () {
@@ -194,12 +323,30 @@ Object.defineProperty(exports, 'encryptEmailBodyWithKey', {
     return encryptEmailBodyWithKey;
   }
 });
+Object.defineProperty(exports, 'encryptEmailHybrid', {
+  enumerable: true,
+  get: function () {
+    return encryptEmailHybrid;
+  }
+});
+Object.defineProperty(exports, 'encryptEmailHybridForMultipleRecipients', {
+  enumerable: true,
+  get: function () {
+    return encryptEmailHybridForMultipleRecipients;
+  }
+});
 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 () {
@@ -224,4 +371,4 @@ Object.defineProperty(exports, 'wrapKey', {
     return wrapKey;
   }
 });
-//# sourceMappingURL=core-Bj26rNdA.js.map
+//# sourceMappingURL=emailKeys-DWvKANTZ.js.map

package/dist/emailKeys-DWvKANTZ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emailKeys-DWvKANTZ.js","names":["genSymmetricKey","UTF8ToUint8","encryptSymmetrically","uint8ArrayToBase64","uint8ToUTF8","decryptSymmetrically","base64ToUint8Array","encapsulateHybrid","decapsulateHybrid","getKeyFromPassword","getKeyFromPasswordAndSalt","genHybridKeys"],"sources":["../src/key-wrapper/aesWrapper.ts","../src/email-crypto/core.ts","../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.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","import { HybridEncKey, PwdProtectedKey, EmailBody, EmailBodyEncrypted, RecipientWithPublicKey } 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';\n\n/**\n * Symmetrically encrypts email body.\n *\n * @param body - The email body to encrypt.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting encrypted email body and symmetric key used for encryption\n */\nexport async function encryptEmailBody(\n  body: EmailBody,\n  aux?: Uint8Array,\n): Promise<{\n  encEmailBody: EmailBodyEncrypted;\n  encryptionKey: Uint8Array;\n}> {\n  try {\n    if (!body.text || !body.subject) {\n      throw new Error('Invalid input');\n    }\n    const encryptionKey = genSymmetricKey();\n    const encEmailBody = await encryptEmailBodyWithKey(body, encryptionKey, aux);\n\n    return { encEmailBody, encryptionKey };\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email body', { cause: error });\n  }\n}\n\n/**\n * Symmetrically encrypts email body with the given key.\n *\n * @param body - The email body 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 body and symmetric key used for encryption\n */\nexport async function encryptEmailBodyWithKey(\n  body: EmailBody,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBodyEncrypted> {\n  try {\n    const text = UTF8ToUint8(body.text);\n    const subject = UTF8ToUint8(body.subject);\n    const subjectEnc = await encryptSymmetrically(encryptionKey, subject, aux);\n    const encryptedText = await encryptSymmetrically(encryptionKey, text, aux);\n    const encText = uint8ArrayToBase64(encryptedText);\n    const encSubject = uint8ArrayToBase64(subjectEnc);\n    const enc: EmailBodyEncrypted = { encText, encSubject };\n\n    if (body.attachments) {\n      const promises = body.attachments.map((attachment) => {\n        const binaryAttachment = UTF8ToUint8(attachment);\n        return encryptSymmetrically(encryptionKey, binaryAttachment, aux);\n      });\n      const encryptedAttachments = await Promise.all(promises);\n      enc.encAttachments = encryptedAttachments?.map(uint8ArrayToBase64);\n    }\n\n    return enc;\n  } catch (error) {\n    throw new Error('Failed to encrypt email body', { cause: error });\n  }\n}\n\n/**\n * Decrypts symmetrically encrypted email body.\n *\n * @param encEmailBody - The email body 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 body\n */\nexport async function decryptEmailBody(\n  encEmailBody: EmailBodyEncrypted,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encSubject = base64ToUint8Array(encEmailBody.encSubject);\n    const subjectArray = await decryptSymmetrically(encryptionKey, encSubject, aux);\n    const subject = uint8ToUTF8(subjectArray);\n    const encText = base64ToUint8Array(encEmailBody.encText);\n    const textArray = await decryptSymmetrically(encryptionKey, encText, aux);\n    const text = uint8ToUTF8(textArray);\n    const body: EmailBody = { text, subject };\n\n    if (encEmailBody.encAttachments) {\n      const encAttachments = encEmailBody.encAttachments?.map(base64ToUint8Array);\n      const promises = encAttachments?.map((encAtt) => decryptSymmetrically(encryptionKey, encAtt, aux));\n      const decryptedAttachments = await Promise.all(promises);\n      body.attachments = decryptedAttachments?.map((att) => uint8ToUTF8(att));\n    }\n\n    return body;\n  } catch (error) {\n    throw new Error('Failed to symmetrically decrypt email body', { cause: 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 Error('Failed to encrypt email key using hybrid encryption', { cause: 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 Error('Failed to decrypt email key encrypted via hybrid encryption', { cause: 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 Error('Failed to password-protect email key', { cause: 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 Error('Failed to remove password-protection from email key', { cause: error });\n  }\n}\n","import { HybridEncryptedEmail, EmailBody, RecipientWithPublicKey } from '../types';\nimport { decryptEmailBody, encryptKeysHybrid, decryptKeysHybrid, encryptEmailBody } from './core';\n\n/**\n * Encrypts the email body using hybrid encryption.\n *\n * @param body - The email body to encrypt.\n * @param recipientPublicKeys - The public keys of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The encrypted email body\n */\nexport async function encryptEmailHybrid(\n  body: EmailBody,\n  recipient: RecipientWithPublicKey,\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n    const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to encrypt email body with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email body using hybrid encryption for multiple recipients.\n *\n * @param body - The email body 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 email bodies\n */\nexport async function encryptEmailHybridForMultipleRecipients(\n  body: EmailBody,\n  recipients: RecipientWithPublicKey[],\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail[]> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n\n    const encryptedEmails: HybridEncryptedEmail[] = [];\n    for (const recipient of recipients) {\n      const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n      encryptedEmails.push({\n        encEmailBody: encEmailBody,\n        encryptedKey,\n      });\n    }\n    return encryptedEmails;\n  } catch (error) {\n    throw new Error('Failed to encrypt email to multiple recipients with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Decrypts the email using hybrid encryption.\n *\n * @param encEmailBody - The encrypted email.\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 body\n */\nexport async function decryptEmailHybrid(\n  encEmailBody: HybridEncryptedEmail,\n  recipientPrivateHybridKeys: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await decryptKeysHybrid(encEmailBody.encryptedKey, recipientPrivateHybridKeys);\n    const body = await decryptEmailBody(encEmailBody.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt email with hybrid encryption', { cause: error });\n  }\n}\n","import { PwdProtectedEmail, EmailBody } from '../types';\nimport { decryptEmailBody, passwordProtectKey, removePasswordProtection, encryptEmailBody } from './core';\n\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  emailBody: EmailBody,\n  password: string,\n  aux?: Uint8Array,\n): Promise<PwdProtectedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(emailBody, aux);\n    const encryptedKey = await passwordProtectKey(encryptionKey, password);\n\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to password-protect email', { cause: 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 body\n */\nexport async function decryptPwdProtectedEmail(\n  encryptedEmail: PwdProtectedEmail,\n  password: string,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);\n    const body = await decryptEmailBody(encryptedEmail.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt password-protect email', { cause: error });\n  }\n}\n","import { genHybridKeys } from '../hybrid-crypto';\nimport { HybridKeyPair } from '../types';\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"],"mappings":"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"}

package/dist/{core-pEGygy6S.mjs → emailKeys-nzn7U7HQ.mjs}

@@ -1,7 +1,7 @@
 import { c as base64ToUint8Array, f as uint8ToUTF8, s as UTF8ToUint8, u as uint8ArrayToBase64 } from "./genID-D08K7JPr.mjs";
 import { n as getKeyFromPasswordAndSalt, t as getKeyFromPassword } from "./deriveKeysFromPassword-DXgSvTNC.mjs";
 import { n as encryptSymmetrically, r as genSymmetricKey, t as decryptSymmetrically } from "./aes-B8TA-JKq.mjs";
-import { n as encapsulateHybrid, t as decapsulateHybrid } from "./xwing-CQmQX6hn.mjs";
+import { n as encapsulateHybrid, r as genHybridKeys, t as decapsulateHybrid } from "./xwing-CQmQX6hn.mjs";
 import { aeskw } from "@noble/ciphers/aes.js";
 
 //#region src/key-wrapper/aesWrapper.ts
@@ -169,5 +169,116 @@ async function removePasswordProtection(emailEncryptionKey, password) {
 }
 
 //#endregion
-export { encryptKeysHybrid as a, unwrapKey as c, encryptEmailBodyWithKey as i, wrapKey as l, decryptKeysHybrid as n, passwordProtectKey as o, encryptEmailBody as r, removePasswordProtection as s, decryptEmailBody as t };
-//# sourceMappingURL=core-pEGygy6S.mjs.map
+//#region src/email-crypto/hybridEncyptedEmail.ts
+/**
+* Encrypts the email body using hybrid encryption.
+*
+* @param body - The email body 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 body
+*/
+async function encryptEmailHybrid(body, recipient, aux) {
+	try {
+		const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);
+		return {
+			encEmailBody,
+			encryptedKey: await encryptKeysHybrid(encryptionKey, recipient)
+		};
+	} catch (error) {
+		throw new Error("Failed to encrypt email body with hybrid encryption", { cause: error });
+	}
+}
+/**
+* Encrypts the email body using hybrid encryption for multiple recipients.
+*
+* @param body - The email body 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 email bodies
+*/
+async function encryptEmailHybridForMultipleRecipients(body, recipients, aux) {
+	try {
+		const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);
+		const encryptedEmails = [];
+		for (const recipient of recipients) {
+			const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);
+			encryptedEmails.push({
+				encEmailBody,
+				encryptedKey
+			});
+		}
+		return encryptedEmails;
+	} catch (error) {
+		throw new Error("Failed to encrypt email to multiple recipients with hybrid encryption", { cause: error });
+	}
+}
+/**
+* Decrypts the email using hybrid encryption.
+*
+* @param encEmailBody - 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 body
+*/
+async function decryptEmailHybrid(encEmailBody, recipientPrivateHybridKeys, aux) {
+	try {
+		const encryptionKey = await decryptKeysHybrid(encEmailBody.encryptedKey, recipientPrivateHybridKeys);
+		return await decryptEmailBody(encEmailBody.encEmailBody, encryptionKey, aux);
+	} catch (error) {
+		throw new Error("Failed to decrypt email with hybrid encryption", { cause: 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(emailBody, password, aux) {
+	try {
+		const { encryptionKey, encEmailBody } = await encryptEmailBody(emailBody, aux);
+		return {
+			encEmailBody,
+			encryptedKey: await passwordProtectKey(encryptionKey, password)
+		};
+	} catch (error) {
+		throw new Error("Failed to password-protect email", { cause: 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 body
+*/
+async function decryptPwdProtectedEmail(encryptedEmail, password, aux) {
+	try {
+		const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);
+		return await decryptEmailBody(encryptedEmail.encEmailBody, encryptionKey, aux);
+	} catch (error) {
+		throw new Error("Failed to decrypt password-protect email", { cause: 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 genHybridKeys();
+}
+
+//#endregion
+export { encryptEmailHybrid as a, decryptKeysHybrid as c, encryptKeysHybrid as d, passwordProtectKey as f, wrapKey as h, decryptEmailHybrid as i, encryptEmailBody as l, unwrapKey as m, createPwdProtectedEmail as n, encryptEmailHybridForMultipleRecipients as o, removePasswordProtection as p, decryptPwdProtectedEmail as r, decryptEmailBody as s, generateEmailKeys as t, encryptEmailBodyWithKey as u };
+//# sourceMappingURL=emailKeys-nzn7U7HQ.mjs.map

package/dist/emailKeys-nzn7U7HQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"emailKeys-nzn7U7HQ.mjs","names":[],"sources":["../src/key-wrapper/aesWrapper.ts","../src/email-crypto/core.ts","../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.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","import { HybridEncKey, PwdProtectedKey, EmailBody, EmailBodyEncrypted, RecipientWithPublicKey } 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';\n\n/**\n * Symmetrically encrypts email body.\n *\n * @param body - The email body to encrypt.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting encrypted email body and symmetric key used for encryption\n */\nexport async function encryptEmailBody(\n  body: EmailBody,\n  aux?: Uint8Array,\n): Promise<{\n  encEmailBody: EmailBodyEncrypted;\n  encryptionKey: Uint8Array;\n}> {\n  try {\n    if (!body.text || !body.subject) {\n      throw new Error('Invalid input');\n    }\n    const encryptionKey = genSymmetricKey();\n    const encEmailBody = await encryptEmailBodyWithKey(body, encryptionKey, aux);\n\n    return { encEmailBody, encryptionKey };\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email body', { cause: error });\n  }\n}\n\n/**\n * Symmetrically encrypts email body with the given key.\n *\n * @param body - The email body 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 body and symmetric key used for encryption\n */\nexport async function encryptEmailBodyWithKey(\n  body: EmailBody,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBodyEncrypted> {\n  try {\n    const text = UTF8ToUint8(body.text);\n    const subject = UTF8ToUint8(body.subject);\n    const subjectEnc = await encryptSymmetrically(encryptionKey, subject, aux);\n    const encryptedText = await encryptSymmetrically(encryptionKey, text, aux);\n    const encText = uint8ArrayToBase64(encryptedText);\n    const encSubject = uint8ArrayToBase64(subjectEnc);\n    const enc: EmailBodyEncrypted = { encText, encSubject };\n\n    if (body.attachments) {\n      const promises = body.attachments.map((attachment) => {\n        const binaryAttachment = UTF8ToUint8(attachment);\n        return encryptSymmetrically(encryptionKey, binaryAttachment, aux);\n      });\n      const encryptedAttachments = await Promise.all(promises);\n      enc.encAttachments = encryptedAttachments?.map(uint8ArrayToBase64);\n    }\n\n    return enc;\n  } catch (error) {\n    throw new Error('Failed to encrypt email body', { cause: error });\n  }\n}\n\n/**\n * Decrypts symmetrically encrypted email body.\n *\n * @param encEmailBody - The email body 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 body\n */\nexport async function decryptEmailBody(\n  encEmailBody: EmailBodyEncrypted,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encSubject = base64ToUint8Array(encEmailBody.encSubject);\n    const subjectArray = await decryptSymmetrically(encryptionKey, encSubject, aux);\n    const subject = uint8ToUTF8(subjectArray);\n    const encText = base64ToUint8Array(encEmailBody.encText);\n    const textArray = await decryptSymmetrically(encryptionKey, encText, aux);\n    const text = uint8ToUTF8(textArray);\n    const body: EmailBody = { text, subject };\n\n    if (encEmailBody.encAttachments) {\n      const encAttachments = encEmailBody.encAttachments?.map(base64ToUint8Array);\n      const promises = encAttachments?.map((encAtt) => decryptSymmetrically(encryptionKey, encAtt, aux));\n      const decryptedAttachments = await Promise.all(promises);\n      body.attachments = decryptedAttachments?.map((att) => uint8ToUTF8(att));\n    }\n\n    return body;\n  } catch (error) {\n    throw new Error('Failed to symmetrically decrypt email body', { cause: 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 Error('Failed to encrypt email key using hybrid encryption', { cause: 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 Error('Failed to decrypt email key encrypted via hybrid encryption', { cause: 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 Error('Failed to password-protect email key', { cause: 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 Error('Failed to remove password-protection from email key', { cause: error });\n  }\n}\n","import { HybridEncryptedEmail, EmailBody, RecipientWithPublicKey } from '../types';\nimport { decryptEmailBody, encryptKeysHybrid, decryptKeysHybrid, encryptEmailBody } from './core';\n\n/**\n * Encrypts the email body using hybrid encryption.\n *\n * @param body - The email body to encrypt.\n * @param recipientPublicKeys - The public keys of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The encrypted email body\n */\nexport async function encryptEmailHybrid(\n  body: EmailBody,\n  recipient: RecipientWithPublicKey,\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n    const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to encrypt email body with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email body using hybrid encryption for multiple recipients.\n *\n * @param body - The email body 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 email bodies\n */\nexport async function encryptEmailHybridForMultipleRecipients(\n  body: EmailBody,\n  recipients: RecipientWithPublicKey[],\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail[]> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n\n    const encryptedEmails: HybridEncryptedEmail[] = [];\n    for (const recipient of recipients) {\n      const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n      encryptedEmails.push({\n        encEmailBody: encEmailBody,\n        encryptedKey,\n      });\n    }\n    return encryptedEmails;\n  } catch (error) {\n    throw new Error('Failed to encrypt email to multiple recipients with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Decrypts the email using hybrid encryption.\n *\n * @param encEmailBody - The encrypted email.\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 body\n */\nexport async function decryptEmailHybrid(\n  encEmailBody: HybridEncryptedEmail,\n  recipientPrivateHybridKeys: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await decryptKeysHybrid(encEmailBody.encryptedKey, recipientPrivateHybridKeys);\n    const body = await decryptEmailBody(encEmailBody.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt email with hybrid encryption', { cause: error });\n  }\n}\n","import { PwdProtectedEmail, EmailBody } from '../types';\nimport { decryptEmailBody, passwordProtectKey, removePasswordProtection, encryptEmailBody } from './core';\n\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  emailBody: EmailBody,\n  password: string,\n  aux?: Uint8Array,\n): Promise<PwdProtectedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(emailBody, aux);\n    const encryptedKey = await passwordProtectKey(encryptionKey, password);\n\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to password-protect email', { cause: 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 body\n */\nexport async function decryptPwdProtectedEmail(\n  encryptedEmail: PwdProtectedEmail,\n  password: string,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);\n    const body = await decryptEmailBody(encryptedEmail.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt password-protect email', { cause: error });\n  }\n}\n","import { genHybridKeys } from '../hybrid-crypto';\nimport { HybridKeyPair } from '../types';\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"],"mappings":";;;;;;;;;;;;;;AASA,eAAsB,UAAU,cAA0B,aAA8C;AACtG,QAAO,MAAM,YAAY,CAAC,QAAQ,aAAa;;;;;;;;;AAUjD,eAAsB,QAAQ,KAAiB,aAA8C;AAC3F,QAAO,MAAM,YAAY,CAAC,QAAQ,IAAI;;;;;;;;;;;;ACPxC,eAAsB,iBACpB,MACA,KAIC;AACD,KAAI;AACF,MAAI,CAAC,KAAK,QAAQ,CAAC,KAAK,QACtB,OAAM,IAAI,MAAM,gBAAgB;EAElC,MAAM,gBAAgB,iBAAiB;AAGvC,SAAO;GAAE,cAFY,MAAM,wBAAwB,MAAM,eAAe,IAAI;GAErD;GAAe;UAC/B,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYnF,eAAsB,wBACpB,MACA,eACA,KAC6B;AAC7B,KAAI;EACF,MAAM,OAAO,YAAY,KAAK,KAAK;EAEnC,MAAM,aAAa,MAAM,qBAAqB,eAD9B,YAAY,KAAK,QAAQ,EAC6B,IAAI;EAI1E,MAAM,MAA0B;GAAE,SAFlB,mBADM,MAAM,qBAAqB,eAAe,MAAM,IAAI,CACzB;GAEN,YADxB,mBAAmB,WAAW;GACM;AAEvD,MAAI,KAAK,aAAa;GACpB,MAAM,WAAW,KAAK,YAAY,KAAK,eAAe;AAEpD,WAAO,qBAAqB,eADH,YAAY,WAAW,EACa,IAAI;KACjE;AAEF,OAAI,kBADyB,MAAM,QAAQ,IAAI,SAAS,GACb,IAAI,mBAAmB;;AAGpE,SAAO;UACA,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYrE,eAAsB,iBACpB,cACA,eACA,KACoB;AACpB,KAAI;EAGF,MAAM,UAAU,YADK,MAAM,qBAAqB,eAD7B,mBAAmB,aAAa,WAAW,EACa,IAAI,CACtC;EAIzC,MAAM,OAAkB;GAAE,MADb,YADK,MAAM,qBAAqB,eAD7B,mBAAmB,aAAa,QAAQ,EACa,IAAI,CACtC;GACH;GAAS;AAEzC,MAAI,aAAa,gBAAgB;GAE/B,MAAM,YADiB,aAAa,gBAAgB,IAAI,mBAAmB,GAC1C,KAAK,WAAW,qBAAqB,eAAe,QAAQ,IAAI,CAAC;AAElG,QAAK,eADwB,MAAM,QAAQ,IAAI,SAAS,GACf,KAAK,QAAQ,YAAY,IAAI,CAAC;;AAGzE,SAAO;UACA,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWnF,eAAsB,kBACpB,oBACA,WACuB;AACvB,KAAI;EACF,MAAM,EAAE,YAAY,iBAAiB,kBAAkB,UAAU,gBAAgB;AAKjF,SAAO;GACL,cAJyB,mBADN,MAAM,QAAQ,oBAAoB,aAAa,CACT;GAKzD,kBAJ4B,mBAAmB,WAAW;GAK1D,mBAAmB,UAAU;GAC9B;UACM,OAAO;AACd,QAAM,IAAI,MAAM,uDAAuD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW5F,eAAsB,kBACpB,cACA,qBACqB;AACrB,KAAI;EACF,MAAM,kBAAkB,mBAAmB,aAAa,iBAAiB;AAIzE,SADsB,MAAM,UAFb,mBAAmB,aAAa,aAAa,EACvC,kBAAkB,iBAAiB,oBAAoB,CACjB;UAEpD,OAAO;AACd,QAAM,IAAI,MAAM,+DAA+D,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWpG,eAAsB,mBAAmB,oBAAgC,UAA4C;AACnH,KAAI;EACF,MAAM,EAAE,KAAK,SAAS,MAAM,mBAAmB,SAAS;EACxD,MAAM,eAAe,MAAM,QAAQ,oBAAoB,IAAI;EAC3D,MAAM,UAAU,mBAAmB,KAAK;AAExC,SAAO;GAAE,cADe,mBAAmB,aAAa;GAChB,MAAM;GAAS;UAChD,OAAO;AACd,QAAM,IAAI,MAAM,wCAAwC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW7E,eAAsB,yBACpB,oBACA,UACqB;AACrB,KAAI;EACF,MAAM,OAAO,mBAAmB,mBAAmB,KAAK;AAIxD,SADsB,MAAM,UAFP,mBAAmB,mBAAmB,aAAa,EAC5D,MAAM,0BAA0B,UAAU,KAAK,CACH;UAEjD,OAAO;AACd,QAAM,IAAI,MAAM,uDAAuD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;ACrL5F,eAAsB,mBACpB,MACA,WACA,KAC+B;AAC/B,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAM,iBAAiB,MAAM,IAAI;AAEzE,SAAO;GAAE;GAAc,cADF,MAAM,kBAAkB,eAAe,UAAU;GACjC;UAC9B,OAAO;AACd,QAAM,IAAI,MAAM,uDAAuD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY5F,eAAsB,wCACpB,MACA,YACA,KACiC;AACjC,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAM,iBAAiB,MAAM,IAAI;EAEzE,MAAM,kBAA0C,EAAE;AAClD,OAAK,MAAM,aAAa,YAAY;GAClC,MAAM,eAAe,MAAM,kBAAkB,eAAe,UAAU;AACtE,mBAAgB,KAAK;IACL;IACd;IACD,CAAC;;AAEJ,SAAO;UACA,OAAO;AACd,QAAM,IAAI,MAAM,yEAAyE,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY9G,eAAsB,mBACpB,cACA,4BACA,KACoB;AACpB,KAAI;EACF,MAAM,gBAAgB,MAAM,kBAAkB,aAAa,cAAc,2BAA2B;AAEpG,SADa,MAAM,iBAAiB,aAAa,cAAc,eAAe,IAAI;UAE3E,OAAO;AACd,QAAM,IAAI,MAAM,kDAAkD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;AC9DvF,eAAsB,wBACpB,WACA,UACA,KAC4B;AAC5B,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAM,iBAAiB,WAAW,IAAI;AAG9E,SAAO;GAAE;GAAc,cAFF,MAAM,mBAAmB,eAAe,SAAS;GAEjC;UAC9B,OAAO;AACd,QAAM,IAAI,MAAM,oCAAoC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYzE,eAAsB,yBACpB,gBACA,UACA,KACoB;AACpB,KAAI;EACF,MAAM,gBAAgB,MAAM,yBAAyB,eAAe,cAAc,SAAS;AAE3F,SADa,MAAM,iBAAiB,eAAe,cAAc,eAAe,IAAI;UAE7E,OAAO;AACd,QAAM,IAAI,MAAM,4CAA4C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;ACpCjF,eAAsB,oBAA4C;AAChE,QAAO,eAAe"}

package/dist/index.d.mts

@@ -1,10 +1,9 @@
 import { deriveSecretKey, generateEccKeys } from "./asymmetric-crypto.mjs";
 import { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, DB_LABEL, DB_VERSION, IV_LEN_BYTES, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH } from "./constants.mjs";
-import { deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys } from "./derive-key.mjs";
+import { deriveDatabaseKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys } from "./derive-key.mjs";
 import { getKeyFromPassword, getKeyFromPasswordAndSalt } from "./derive-password.mjs";
-import { Email, EmailBody, EmailBodyEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, MailCache, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey, StoredEmail, User } from "./types.mjs";
+import { EmailBody, EmailBodyEncrypted, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey } from "./types.mjs";
 import { createPwdProtectedEmail, decryptEmailHybrid, decryptPwdProtectedEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys } from "./email-crypto.mjs";
-import { addEmailToCache, addEmailToSearchIndex, addEmailsToCache, buildSearchIndexFromCache, closeDatabase, createCacheFromDB, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, encryptAndStoreEmail, encryptAndStoreManyEmail, enforceMaxEmailNumber, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getEmailBatch, getEmailCount, getEmailFromCache, openDatabase, removeEmailFromSearchIndex, searchEmails } from "./email-search.mjs";
 import { getBytesFromData, getBytesFromDataArray, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey } from "./hash.mjs";
 import { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore } from "./keystore-crypto.mjs";
 import { decapsulateKyber, encapsulateKyber, generateKyberKeys } from "./post-quantum-crypto.mjs";
@@ -29,5 +28,5 @@ declare function unwrapKey(encryptedKey: Uint8Array, wrappingKey: Uint8Array): P
  */
 declare function wrapKey(key: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array>;
 //#endregion
-export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, DB_LABEL, DB_VERSION, Email, EmailBody, EmailBodyEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, IV_LEN_BYTES, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, MailCache, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey, StoredEmail, UTF8ToUint8, User, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, addEmailToCache, addEmailToSearchIndex, addEmailsToCache, base64ToUint8Array, buildSearchIndexFromCache, bytesToMnemonic, bytesToUuid, closeDatabase, createCacheFromDB, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptAndStoreEmail, encryptAndStoreManyEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, enforceMaxEmailNumber, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getBytesFromData, getBytesFromDataArray, getEmailBatch, getEmailCount, getEmailFromCache, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openDatabase, openEncryptionKeystore, openRecoveryKeystore, removeEmailFromSearchIndex, searchEmails, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };
+export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, DB_LABEL, DB_VERSION, EmailBody, EmailBodyEncrypted, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, IV_LEN_BYTES, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey, UTF8ToUint8, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, base64ToUint8Array, bytesToMnemonic, bytesToUuid, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deriveDatabaseKey, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getBytesFromData, getBytesFromDataArray, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openEncryptionKeystore, openRecoveryKeystore, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/key-wrapper/aesWrapper.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;iBASsB,SAAA,CAAU,YAAA,EAAc,UAAA,EAAY,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,UAAA;;;;;;;AAA5F;iBAWsB,OAAA,CAAQ,GAAA,EAAK,UAAA,EAAY,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,UAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/key-wrapper/aesWrapper.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBASsB,SAAA,CAAU,YAAA,EAAc,UAAA,EAAY,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,UAAA;;;;;;AAA5F;;iBAWsB,OAAA,CAAQ,GAAA,EAAK,UAAA,EAAY,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,UAAA"}

package/dist/index.d.ts

@@ -1,10 +1,9 @@
 import { deriveSecretKey, generateEccKeys } from "./asymmetric-crypto.js";
 import { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, DB_LABEL, DB_VERSION, IV_LEN_BYTES, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH } from "./constants.js";
-import { deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys } from "./derive-key.js";
+import { deriveDatabaseKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys } from "./derive-key.js";
 import { getKeyFromPassword, getKeyFromPasswordAndSalt } from "./derive-password.js";
-import { Email, EmailBody, EmailBodyEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, MailCache, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey, StoredEmail, User } from "./types.js";
+import { EmailBody, EmailBodyEncrypted, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey } from "./types.js";
 import { createPwdProtectedEmail, decryptEmailHybrid, decryptPwdProtectedEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys } from "./email-crypto.js";
-import { addEmailToCache, addEmailToSearchIndex, addEmailsToCache, buildSearchIndexFromCache, closeDatabase, createCacheFromDB, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, encryptAndStoreEmail, encryptAndStoreManyEmail, enforceMaxEmailNumber, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getEmailBatch, getEmailCount, getEmailFromCache, openDatabase, removeEmailFromSearchIndex, searchEmails } from "./email-search.js";
 import { getBytesFromData, getBytesFromDataArray, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey } from "./hash.js";
 import { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore } from "./keystore-crypto.js";
 import { decapsulateKyber, encapsulateKyber, generateKyberKeys } from "./post-quantum-crypto.js";
@@ -29,5 +28,5 @@ declare function unwrapKey(encryptedKey: Uint8Array, wrappingKey: Uint8Array): P
  */
 declare function wrapKey(key: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array>;
 //#endregion
-export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, DB_LABEL, DB_VERSION, Email, EmailBody, EmailBodyEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, IV_LEN_BYTES, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, MailCache, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey, StoredEmail, UTF8ToUint8, User, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, addEmailToCache, addEmailToSearchIndex, addEmailsToCache, base64ToUint8Array, buildSearchIndexFromCache, bytesToMnemonic, bytesToUuid, closeDatabase, createCacheFromDB, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptAndStoreEmail, encryptAndStoreManyEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, enforceMaxEmailNumber, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getBytesFromData, getBytesFromDataArray, getEmailBatch, getEmailCount, getEmailFromCache, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openDatabase, openEncryptionKeystore, openRecoveryKeystore, removeEmailFromSearchIndex, searchEmails, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };
+export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, DB_LABEL, DB_VERSION, EmailBody, EmailBodyEncrypted, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, IV_LEN_BYTES, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey, UTF8ToUint8, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, base64ToUint8Array, bytesToMnemonic, bytesToUuid, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deriveDatabaseKey, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getBytesFromData, getBytesFromDataArray, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openEncryptionKeystore, openRecoveryKeystore, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/key-wrapper/aesWrapper.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;iBASsB,SAAA,CAAU,YAAA,EAAc,UAAA,EAAY,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,UAAA;;;;;;;AAA5F;iBAWsB,OAAA,CAAQ,GAAA,EAAK,UAAA,EAAY,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,UAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/key-wrapper/aesWrapper.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBASsB,SAAA,CAAU,YAAA,EAAc,UAAA,EAAY,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,UAAA;;;;;;AAA5F;;iBAWsB,OAAA,CAAQ,GAAA,EAAK,UAAA,EAAY,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,UAAA"}

package/dist/index.js

@@ -2,15 +2,13 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_asymmetric_crypto = require('./asymmetric-crypto.js');
 const require_constants = require('./constants.js');
 const require_genID = require('./genID-cWOPmspk.js');
-const require_deriveKeysFromKey = require('./deriveKeysFromKey-C4McqO6_.js');
+const require_deriveKeysFromKey = require('./deriveKeysFromKey-GTRMuxDj.js');
 const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-C7xAGGsh.js');
 const require_aes = require('./aes-CuW_SPl-.js');
-const require_core = require('./core-Bj26rNdA.js');
-const require_email_crypto = require('./email-crypto.js');
-const require_search = require('./search-DUTm4-rN.js');
+const require_emailKeys = require('./emailKeys-DWvKANTZ.js');
 const require_hash = require('./hash.js');
 const require_types = require('./types.js');
-const require_emailEncryptionKey = require('./emailEncryptionKey-C4X1Bwy4.js');
+const require_emailEncryptionKey = require('./emailEncryptionKey-F_YuJu1H.js');
 const require_post_quantum_crypto = require('./post-quantum-crypto.js');
 
 exports.AES_KEY_BYTE_LENGTH = require_constants.AES_KEY_BYTE_LENGTH;
@@ -37,50 +35,31 @@ exports.XWING_CIPHERTEXT_BYTE_LENGTH = require_constants.XWING_CIPHERTEXT_BYTE_L
 exports.XWING_PUBLIC_KEY_LENGTH = require_constants.XWING_PUBLIC_KEY_LENGTH;
 exports.XWING_SECRET_KEY_LENGTH = require_constants.XWING_SECRET_KEY_LENGTH;
 exports.XWING_SEED_BYTE_LENGTH = require_constants.XWING_SEED_BYTE_LENGTH;
-exports.addEmailToCache = require_search.addEmailToCache;
-exports.addEmailToSearchIndex = require_search.addEmailToSearchIndex;
-exports.addEmailsToCache = require_search.addEmailsToCache;
 exports.base64ToUint8Array = require_genID.base64ToUint8Array;
-exports.buildSearchIndexFromCache = require_search.buildSearchIndexFromCache;
 exports.bytesToMnemonic = require_genID.bytesToMnemonic;
 exports.bytesToUuid = require_genID.bytesToUuid;
-exports.closeDatabase = require_search.closeDatabase;
-exports.createCacheFromDB = require_search.createCacheFromDB;
 exports.createEncryptionAndRecoveryKeystores = require_emailEncryptionKey.createEncryptionAndRecoveryKeystores;
-exports.createPwdProtectedEmail = require_email_crypto.createPwdProtectedEmail;
+exports.createPwdProtectedEmail = require_emailKeys.createPwdProtectedEmail;
 exports.decapsulateKyber = require_post_quantum_crypto.decapsulateKyber;
-exports.decryptEmailHybrid = require_email_crypto.decryptEmailHybrid;
-exports.decryptPwdProtectedEmail = require_email_crypto.decryptPwdProtectedEmail;
+exports.decryptEmailHybrid = require_emailKeys.decryptEmailHybrid;
+exports.decryptPwdProtectedEmail = require_emailKeys.decryptPwdProtectedEmail;
 exports.decryptSymmetrically = require_aes.decryptSymmetrically;
-exports.deleteEmail = require_search.deleteEmail;
-exports.deleteEmailFromCache = require_search.deleteEmailFromCache;
-exports.deleteOldestEmails = require_search.deleteOldestEmails;
-exports.deriveIndexKey = require_search.deriveIndexKey;
+exports.deriveDatabaseKey = require_deriveKeysFromKey.deriveDatabaseKey;
 exports.deriveSecretKey = require_asymmetric_crypto.deriveSecretKey;
 exports.deriveSymmetricKeyFromContext = require_deriveKeysFromKey.deriveSymmetricKeyFromContext;
 exports.deriveSymmetricKeyFromTwoKeys = require_deriveKeysFromKey.deriveSymmetricKeyFromTwoKeys;
 exports.encapsulateKyber = require_post_quantum_crypto.encapsulateKyber;
-exports.encryptAndStoreEmail = require_search.encryptAndStoreEmail;
-exports.encryptAndStoreManyEmail = require_search.encryptAndStoreManyEmail;
-exports.encryptEmailHybrid = require_email_crypto.encryptEmailHybrid;
-exports.encryptEmailHybridForMultipleRecipients = require_email_crypto.encryptEmailHybridForMultipleRecipients;
+exports.encryptEmailHybrid = require_emailKeys.encryptEmailHybrid;
+exports.encryptEmailHybridForMultipleRecipients = require_emailKeys.encryptEmailHybridForMultipleRecipients;
 exports.encryptSymmetrically = require_aes.encryptSymmetrically;
-exports.enforceMaxEmailNumber = require_search.enforceMaxEmailNumber;
 exports.genMnemonic = require_genID.genMnemonic;
 exports.genSymmetricKey = require_aes.genSymmetricKey;
 exports.generateEccKeys = require_asymmetric_crypto.generateEccKeys;
-exports.generateEmailKeys = require_email_crypto.generateEmailKeys;
+exports.generateEmailKeys = require_emailKeys.generateEmailKeys;
 exports.generateKyberKeys = require_post_quantum_crypto.generateKyberKeys;
 exports.generateUuid = require_genID.generateUuid;
-exports.getAllEmailsSortedNewestFirst = require_search.getAllEmailsSortedNewestFirst;
-exports.getAllEmailsSortedOldestFirst = require_search.getAllEmailsSortedOldestFirst;
-exports.getAndDecryptAllEmails = require_search.getAndDecryptAllEmails;
-exports.getAndDecryptEmail = require_search.getAndDecryptEmail;
 exports.getBytesFromData = require_hash.getBytesFromData;
 exports.getBytesFromDataArray = require_hash.getBytesFromDataArray;
-exports.getEmailBatch = require_search.getEmailBatch;
-exports.getEmailCount = require_search.getEmailCount;
-exports.getEmailFromCache = require_search.getEmailFromCache;
 exports.getKeyFromPassword = require_deriveKeysFromPassword.getKeyFromPassword;
 exports.getKeyFromPasswordAndSalt = require_deriveKeysFromPassword.getKeyFromPasswordAndSalt;
 exports.hashData = require_hash.hashData;
@@ -89,14 +68,11 @@ exports.hashDataArrayWithKey = require_hash.hashDataArrayWithKey;
 exports.hashDataWithKey = require_hash.hashDataWithKey;
 exports.hexToUint8Array = require_genID.hexToUint8Array;
 exports.mnemonicToBytes = require_genID.mnemonicToBytes;
-exports.openDatabase = require_search.openDatabase;
 exports.openEncryptionKeystore = require_emailEncryptionKey.openEncryptionKeystore;
 exports.openRecoveryKeystore = require_emailEncryptionKey.openRecoveryKeystore;
-exports.removeEmailFromSearchIndex = require_search.removeEmailFromSearchIndex;
-exports.searchEmails = require_search.searchEmails;
 exports.uint8ArrayToBase64 = require_genID.uint8ArrayToBase64;
 exports.uint8ArrayToHex = require_genID.uint8ArrayToHex;
 exports.uint8ToUTF8 = require_genID.uint8ToUTF8;
-exports.unwrapKey = require_core.unwrapKey;
+exports.unwrapKey = require_emailKeys.unwrapKey;
 exports.uuidToBytes = require_genID.uuidToBytes;
-exports.wrapKey = require_core.wrapKey;
+exports.wrapKey = require_emailKeys.wrapKey;

package/dist/index.mjs

@@ -1,15 +1,13 @@
 import { deriveSecretKey, generateEccKeys } from "./asymmetric-crypto.mjs";
 import { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, DB_LABEL, DB_VERSION, IV_LEN_BYTES, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH } from "./constants.mjs";
 import { a as genMnemonic, c as base64ToUint8Array, d as uint8ArrayToHex, f as uint8ToUTF8, i as bytesToMnemonic, l as hexToUint8Array, n as generateUuid, o as mnemonicToBytes, r as uuidToBytes, s as UTF8ToUint8, t as bytesToUuid, u as uint8ArrayToBase64 } from "./genID-D08K7JPr.mjs";
-import { n as deriveSymmetricKeyFromTwoKeys, t as deriveSymmetricKeyFromContext } from "./deriveKeysFromKey-DPU_h7wr.mjs";
+import { n as deriveSymmetricKeyFromContext, r as deriveSymmetricKeyFromTwoKeys, t as deriveDatabaseKey } from "./deriveKeysFromKey-CseBjg0n.mjs";
 import { n as getKeyFromPasswordAndSalt, t as getKeyFromPassword } from "./deriveKeysFromPassword-DXgSvTNC.mjs";
 import { n as encryptSymmetrically, r as genSymmetricKey, t as decryptSymmetrically } from "./aes-B8TA-JKq.mjs";
-import { c as unwrapKey, l as wrapKey } from "./core-pEGygy6S.mjs";
-import { createPwdProtectedEmail, decryptEmailHybrid, decryptPwdProtectedEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys } from "./email-crypto.mjs";
-import { C as getEmailCount, S as getEmailBatch, _ as enforceMaxEmailNumber, a as addEmailToCache, b as getAndDecryptAllEmails, c as deleteEmailFromCache, f as deleteEmail, g as encryptAndStoreManyEmail, h as encryptAndStoreEmail, i as searchEmails, l as getEmailFromCache, m as deriveIndexKey, n as buildSearchIndexFromCache, o as addEmailsToCache, p as deleteOldestEmails, r as removeEmailFromSearchIndex, s as createCacheFromDB, t as addEmailToSearchIndex, u as closeDatabase, v as getAllEmailsSortedNewestFirst, w as openDatabase, x as getAndDecryptEmail, y as getAllEmailsSortedOldestFirst } from "./search-B9YM3XAA.mjs";
+import { a as encryptEmailHybrid, h as wrapKey, i as decryptEmailHybrid, m as unwrapKey, n as createPwdProtectedEmail, o as encryptEmailHybridForMultipleRecipients, r as decryptPwdProtectedEmail, t as generateEmailKeys } from "./emailKeys-nzn7U7HQ.mjs";
 import { getBytesFromData, getBytesFromDataArray, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey } from "./hash.mjs";
 import { KeystoreType } from "./types.mjs";
-import { n as openEncryptionKeystore, r as openRecoveryKeystore, t as createEncryptionAndRecoveryKeystores } from "./emailEncryptionKey-BtSPYd9M.mjs";
+import { n as openEncryptionKeystore, r as openRecoveryKeystore, t as createEncryptionAndRecoveryKeystores } from "./emailEncryptionKey-kIsseFo6.mjs";
 import { decapsulateKyber, encapsulateKyber, generateKyberKeys } from "./post-quantum-crypto.mjs";
 
-export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, DB_LABEL, DB_VERSION, IV_LEN_BYTES, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, UTF8ToUint8, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, addEmailToCache, addEmailToSearchIndex, addEmailsToCache, base64ToUint8Array, buildSearchIndexFromCache, bytesToMnemonic, bytesToUuid, closeDatabase, createCacheFromDB, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptAndStoreEmail, encryptAndStoreManyEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, enforceMaxEmailNumber, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getBytesFromData, getBytesFromDataArray, getEmailBatch, getEmailCount, getEmailFromCache, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openDatabase, openEncryptionKeystore, openRecoveryKeystore, removeEmailFromSearchIndex, searchEmails, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };
+export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, DB_LABEL, DB_VERSION, IV_LEN_BYTES, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, UTF8ToUint8, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, base64ToUint8Array, bytesToMnemonic, bytesToUuid, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deriveDatabaseKey, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getBytesFromData, getBytesFromDataArray, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openEncryptionKeystore, openRecoveryKeystore, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };