internxt-crypto 0.0.11 → 0.0.13

package/dist/{email-crypto-BrT98taw.js → emailKeys-BJGdkLrg.js}

@@ -1,10 +1,10 @@
-const require_chunk = require('./chunk-Dt-PWiN7.js');
-const require_constants = require('./constants-Ccp21E03.js');
-const require_asymmetric_crypto = require('./asymmetric-crypto-BORmLhnx.js');
-const require_utils = require('./utils-CNs3cyDj.js');
-const require_symmetric_crypto = require('./symmetric-crypto-D65zB396.js');
-const require_derive_key = require('./derive-key-CBf2WxJd.js');
-const require_post_quantum_crypto = require('./post-quantum-crypto-CAi-cEkV.js');
+const require_chunk = require('./chunk-EbLFQX5m.js');
+const require_constants = require('./constants.js');
+const require_keys = require('./keys-CinT7kEY.js');
+const require_genID = require('./genID-YJSl3YhL.js');
+const require_aes = require('./aes-bOrKZuUC.js');
+const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-Ko7NxkHM.js');
+const require_kyber1024 = require('./kyber1024-jeKS8CXf.js');
 let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
 
 //#region src/key-wrapper/aesWrapper.ts
@@ -31,7 +31,7 @@ async function importWrappingKey(key) {
 async function deriveWrappingKey(eccSecret, kyberSecret) {
 	try {
 		if (eccSecret.length !== kyberSecret.length) throw new Error("secrets must have equal length");
-		return await importWrappingKey(await require_derive_key.deriveSymmetricKeyFromTwoKeysAndContext(eccSecret, kyberSecret, require_constants.CONTEXT_WRAPPING));
+		return await importWrappingKey(await require_deriveKeysFromPassword.deriveSymmetricKeyFromTwoKeysAndContext(eccSecret, kyberSecret, require_constants.CONTEXT_WRAPPING));
 	} catch (error) {
 		throw new Error("Failed to derive wrapping key", { cause: error });
 	}
@@ -66,20 +66,11 @@ async function wrapKey(encryptionKey, wrappingKey) {
 	}
 }
 
-//#endregion
-//#region src/key-wrapper/index.ts
-var key_wrapper_exports = /* @__PURE__ */ require_chunk.__exportAll({
-	deriveWrappingKey: () => deriveWrappingKey,
-	importWrappingKey: () => importWrappingKey,
-	unwrapKey: () => unwrapKey,
-	wrapKey: () => wrapKey
-});
-
 //#endregion
 //#region src/email-crypto/converters.ts
 function userToBytes(user) {
 	try {
-		return require_utils.UTF8ToUint8(JSON.stringify(user));
+		return require_genID.UTF8ToUint8(JSON.stringify(user));
 	} catch (error) {
 		throw new Error("Failed to convert User to bytes", { cause: error });
 	}
@@ -99,7 +90,7 @@ function recipientsToBytes(recipients) {
 */
 function emailToBinary(email) {
 	try {
-		return require_utils.UTF8ToUint8(JSON.stringify(email));
+		return require_genID.UTF8ToUint8(JSON.stringify(email));
 	} catch (error) {
 		throw new Error("Failed to convert EmailBody to Uint8Array", { cause: error });
 	}
@@ -117,12 +108,12 @@ function emailToBinary(email) {
 function getAux(params, isSubjectEncrypted) {
 	try {
 		const { subject, replyToEmailID, sender, recipient, recipients } = params;
-		const replyBytes = replyToEmailID ? require_utils.uuidToBytes(replyToEmailID) : new Uint8Array();
+		const replyBytes = replyToEmailID ? require_genID.uuidToBytes(replyToEmailID) : new Uint8Array();
 		const senderBytes = userToBytes(sender);
 		const recipientBytes = userToBytes(recipient);
 		const recipientsBytes = recipients ? recipientsToBytes(recipients) : new Uint8Array();
 		if (isSubjectEncrypted) return (0, _noble_hashes_utils_js.concatBytes)(replyBytes, senderBytes, recipientBytes, recipientsBytes);
-		else return (0, _noble_hashes_utils_js.concatBytes)(require_utils.UTF8ToUint8(subject), replyBytes, senderBytes, recipientBytes, recipientsBytes);
+		else return (0, _noble_hashes_utils_js.concatBytes)(require_genID.UTF8ToUint8(subject), replyBytes, senderBytes, recipientBytes, recipientsBytes);
 	} catch (error) {
 		throw new Error("Failed to create aux", { cause: error });
 	}
@@ -190,7 +181,7 @@ async function decryptEmailBody(enc, encParams, encryptionKey, isSubjectEncrypte
 async function encryptEmailContentSymmetrically(email, aux, emailID) {
 	try {
 		if (!email.text) throw new Error("Invalid input");
-		const encryptionKey = await require_symmetric_crypto.genSymmetricCryptoKey();
+		const encryptionKey = await require_aes.genSymmetricCryptoKey();
 		return {
 			enc: await encryptEmailContentSymmetricallyWithKey(email, encryptionKey, aux, emailID),
 			encryptionKey
@@ -211,10 +202,10 @@ async function encryptEmailContentSymmetrically(email, aux, emailID) {
 async function encryptEmailContentAndSubjectSymmetrically(email, subject, aux, emailID) {
 	try {
 		if (!subject || !email.text) throw new Error("Invalid input");
-		const encryptionKey = await require_symmetric_crypto.genSymmetricCryptoKey();
+		const encryptionKey = await require_aes.genSymmetricCryptoKey();
 		return {
 			enc: await encryptEmailContentSymmetricallyWithKey(email, encryptionKey, aux, emailID),
-			encSubject: require_utils.uint8ArrayToBase64(await require_symmetric_crypto.encryptSymmetrically(encryptionKey, require_utils.UTF8ToUint8(subject), aux)),
+			encSubject: require_genID.uint8ArrayToBase64(await require_aes.encryptSymmetrically(encryptionKey, require_genID.UTF8ToUint8(subject), aux)),
 			encryptionKey
 		};
 	} catch (error) {
@@ -230,10 +221,10 @@ async function encryptEmailContentAndSubjectSymmetrically(email, subject, aux, e
 */
 async function decryptEmailAndSubjectSymmetrically(encryptionKey, aux, encSubject, enc) {
 	try {
-		const subjectArray = await require_symmetric_crypto.decryptSymmetrically(encryptionKey, require_utils.base64ToUint8Array(encSubject), aux);
+		const subjectArray = await require_aes.decryptSymmetrically(encryptionKey, require_genID.base64ToUint8Array(encSubject), aux);
 		return {
 			body: await decryptEmailSymmetrically(encryptionKey, aux, enc),
-			subject: require_utils.uint8ToUTF8(subjectArray)
+			subject: require_genID.uint8ToUTF8(subjectArray)
 		};
 	} catch (error) {
 		throw new Error("Failed to symmetrically decrypt email and subject", { cause: error });
@@ -247,9 +238,9 @@ async function decryptEmailAndSubjectSymmetrically(encryptionKey, aux, encSubjec
 */
 async function encryptEmailContentSymmetricallyWithKey(emailBody, encryptionKey, aux, emailID) {
 	try {
-		const freeField = require_utils.uuidToBytes(emailID);
-		const result = { encText: require_utils.uint8ArrayToBase64(await require_symmetric_crypto.encryptSymmetrically(encryptionKey, require_utils.UTF8ToUint8(emailBody.text), aux, freeField)) };
-		if (emailBody.attachments) result.encAttachments = (await encryptEmailAttachements(emailBody.attachments, encryptionKey, aux, emailID))?.map(require_utils.uint8ArrayToBase64);
+		const freeField = require_genID.uuidToBytes(emailID);
+		const result = { encText: require_genID.uint8ArrayToBase64(await require_aes.encryptSymmetrically(encryptionKey, require_genID.UTF8ToUint8(emailBody.text), aux, freeField)) };
+		if (emailBody.attachments) result.encAttachments = (await encryptEmailAttachements(emailBody.attachments, encryptionKey, aux, emailID))?.map(require_genID.uint8ArrayToBase64);
 		return result;
 	} catch (error) {
 		throw new Error("Failed to symmetrically encrypt email with the given key", { cause: error });
@@ -257,9 +248,9 @@ async function encryptEmailContentSymmetricallyWithKey(emailBody, encryptionKey,
 }
 async function encryptEmailAttachements(attachments, encryptionKey, aux, emailID) {
 	try {
-		const freeField = require_utils.uuidToBytes(emailID);
+		const freeField = require_genID.uuidToBytes(emailID);
 		return await Promise.all(attachments.map((attachment) => {
-			return require_symmetric_crypto.encryptSymmetrically(encryptionKey, require_utils.UTF8ToUint8(attachment), aux, freeField);
+			return require_aes.encryptSymmetrically(encryptionKey, require_genID.UTF8ToUint8(attachment), aux, freeField);
 		}));
 	} catch (error) {
 		throw new Error("Failed to symmetrically encrypt email attachements", { cause: error });
@@ -268,7 +259,7 @@ async function encryptEmailAttachements(attachments, encryptionKey, aux, emailID
 async function decryptEmailAttachements(encryptedAttachments, encryptionKey, aux) {
 	try {
 		return await Promise.all(encryptedAttachments.map((attachment) => {
-			return require_symmetric_crypto.decryptSymmetrically(encryptionKey, attachment, aux);
+			return require_aes.decryptSymmetrically(encryptionKey, attachment, aux);
 		}));
 	} catch (error) {
 		throw new Error("Failed to symmetrically decrypt email attachements", { cause: error });
@@ -283,10 +274,10 @@ async function decryptEmailAttachements(encryptedAttachments, encryptionKey, aux
 */
 async function decryptEmailSymmetrically(encryptionKey, aux, enc) {
 	try {
-		const result = { text: require_utils.uint8ToUTF8(await require_symmetric_crypto.decryptSymmetrically(encryptionKey, require_utils.base64ToUint8Array(enc.encText), aux)) };
+		const result = { text: require_genID.uint8ToUTF8(await require_aes.decryptSymmetrically(encryptionKey, require_genID.base64ToUint8Array(enc.encText), aux)) };
 		if (enc.encAttachments) {
-			const encAttachements = enc.encAttachments?.map(require_utils.base64ToUint8Array);
-			result.attachments = (await decryptEmailAttachements(encAttachements, encryptionKey, aux))?.map((att) => require_utils.uint8ToUTF8(att));
+			const encAttachements = enc.encAttachments?.map(require_genID.base64ToUint8Array);
+			result.attachments = (await decryptEmailAttachements(encAttachements, encryptionKey, aux))?.map((att) => require_genID.uint8ToUTF8(att));
 		}
 		return result;
 	} catch (error) {
@@ -303,11 +294,11 @@ async function decryptEmailSymmetrically(encryptionKey, aux, enc) {
 */
 async function encryptKeysHybrid(emailEncryptionKey, recipientPublicKey, senderPrivateKey) {
 	try {
-		const eccSecret = await require_asymmetric_crypto.deriveSecretKey(recipientPublicKey.eccPublicKey, senderPrivateKey.eccPrivateKey);
-		const { cipherText: kyberCiphertext, sharedSecret: kyberSecret } = require_post_quantum_crypto.encapsulateKyber(recipientPublicKey.kyberPublicKey);
+		const eccSecret = await require_keys.deriveSecretKey(recipientPublicKey.eccPublicKey, senderPrivateKey.eccPrivateKey);
+		const { cipherText: kyberCiphertext, sharedSecret: kyberSecret } = require_kyber1024.encapsulateKyber(recipientPublicKey.kyberPublicKey);
 		return {
-			encryptedKey: require_utils.uint8ArrayToBase64(await wrapKey(emailEncryptionKey, await deriveWrappingKey(eccSecret, kyberSecret))),
-			kyberCiphertext: require_utils.uint8ArrayToBase64(kyberCiphertext)
+			encryptedKey: require_genID.uint8ArrayToBase64(await wrapKey(emailEncryptionKey, await deriveWrappingKey(eccSecret, kyberSecret))),
+			kyberCiphertext: require_genID.uint8ArrayToBase64(kyberCiphertext)
 		};
 	} catch (error) {
 		throw new Error("Failed to encrypt email key using hybrid encryption", { cause: error });
@@ -323,8 +314,8 @@ async function encryptKeysHybrid(emailEncryptionKey, recipientPublicKey, senderP
 */
 async function decryptKeysHybrid(encryptedKey, senderPublicKey, recipientPrivateKey) {
 	try {
-		const kyberCiphertext = require_utils.base64ToUint8Array(encryptedKey.kyberCiphertext);
-		return await unwrapKey(require_utils.base64ToUint8Array(encryptedKey.encryptedKey), await deriveWrappingKey(await require_asymmetric_crypto.deriveSecretKey(senderPublicKey.eccPublicKey, recipientPrivateKey.eccPrivateKey), require_post_quantum_crypto.decapsulateKyber(kyberCiphertext, recipientPrivateKey.kyberPrivateKey)));
+		const kyberCiphertext = require_genID.base64ToUint8Array(encryptedKey.kyberCiphertext);
+		return await unwrapKey(require_genID.base64ToUint8Array(encryptedKey.encryptedKey), await deriveWrappingKey(await require_keys.deriveSecretKey(senderPublicKey.eccPublicKey, recipientPrivateKey.eccPrivateKey), require_kyber1024.decapsulateKyber(kyberCiphertext, recipientPrivateKey.kyberPrivateKey)));
 	} catch (error) {
 		throw new Error("Failed to decrypt email key encrypted via hybrid encryption", { cause: error });
 	}
@@ -338,11 +329,11 @@ async function decryptKeysHybrid(encryptedKey, senderPublicKey, recipientPrivate
 */
 async function passwordProtectKey(emailEncryptionKey, password) {
 	try {
-		const { key, salt } = await require_derive_key.getKeyFromPassword(password);
+		const { key, salt } = await require_deriveKeysFromPassword.getKeyFromPassword(password);
 		const encryptedKey = await wrapKey(emailEncryptionKey, await importWrappingKey(key));
-		const saltStr = require_utils.uint8ArrayToBase64(salt);
+		const saltStr = require_genID.uint8ArrayToBase64(salt);
 		return {
-			encryptedKey: require_utils.uint8ArrayToBase64(encryptedKey),
+			encryptedKey: require_genID.uint8ArrayToBase64(encryptedKey),
 			salt: saltStr
 		};
 	} catch (error) {
@@ -358,8 +349,8 @@ async function passwordProtectKey(emailEncryptionKey, password) {
 */
 async function removePasswordProtection(emailEncryptionKey, password) {
 	try {
-		const salt = require_utils.base64ToUint8Array(emailEncryptionKey.salt);
-		return await unwrapKey(require_utils.base64ToUint8Array(emailEncryptionKey.encryptedKey), await importWrappingKey(await require_derive_key.getKeyFromPasswordAndSalt(password, salt)));
+		const salt = require_genID.base64ToUint8Array(emailEncryptionKey.salt);
+		return await unwrapKey(require_genID.base64ToUint8Array(emailEncryptionKey.encryptedKey), await importWrappingKey(await require_deriveKeysFromPassword.getKeyFromPasswordAndSalt(password, salt)));
 	} catch (error) {
 		throw new Error("Failed to remove password-protection from email key", { cause: error });
 	}
@@ -497,8 +488,8 @@ async function decryptPwdProtectedEmail(encryptedEmail, password) {
 */
 async function generateEmailKeys() {
 	try {
-		const kyberKeys = require_post_quantum_crypto.generateKyberKeys();
-		const keys = await require_asymmetric_crypto.generateEccKeys();
+		const kyberKeys = require_kyber1024.generateKyberKeys();
+		const keys = await require_keys.generateEccKeys();
 		return {
 			publicKeys: {
 				eccPublicKey: keys.publicKey,
@@ -514,21 +505,6 @@ async function generateEmailKeys() {
 	}
 }
 
-//#endregion
-//#region src/email-crypto/index.ts
-var email_crypto_exports = /* @__PURE__ */ require_chunk.__exportAll({
-	createPwdProtectedEmail: () => createPwdProtectedEmail,
-	decryptEmailHybrid: () => decryptEmailHybrid,
-	decryptPwdProtectedEmail: () => decryptPwdProtectedEmail,
-	emailToBinary: () => emailToBinary,
-	encryptEmailHybrid: () => encryptEmailHybrid,
-	encryptEmailHybridForMultipleRecipients: () => encryptEmailHybridForMultipleRecipients,
-	generateEmailKeys: () => generateEmailKeys,
-	getAux: () => getAux,
-	recipientsToBytes: () => recipientsToBytes,
-	userToBytes: () => userToBytes
-});
-
 //#endregion
 Object.defineProperty(exports, 'createPwdProtectedEmail', {
   enumerable: true,
@@ -560,12 +536,6 @@ Object.defineProperty(exports, 'emailToBinary', {
     return emailToBinary;
   }
 });
-Object.defineProperty(exports, 'email_crypto_exports', {
-  enumerable: true,
-  get: function () {
-    return email_crypto_exports;
-  }
-});
 Object.defineProperty(exports, 'encryptEmailContentSymmetricallyWithKey', {
   enumerable: true,
   get: function () {
@@ -596,16 +566,16 @@ Object.defineProperty(exports, 'getAux', {
     return getAux;
   }
 });
-Object.defineProperty(exports, 'key_wrapper_exports', {
+Object.defineProperty(exports, 'recipientsToBytes', {
   enumerable: true,
   get: function () {
-    return key_wrapper_exports;
+    return recipientsToBytes;
   }
 });
-Object.defineProperty(exports, 'recipientsToBytes', {
+Object.defineProperty(exports, 'unwrapKey', {
   enumerable: true,
   get: function () {
-    return recipientsToBytes;
+    return unwrapKey;
   }
 });
 Object.defineProperty(exports, 'userToBytes', {
@@ -614,4 +584,10 @@ Object.defineProperty(exports, 'userToBytes', {
     return userToBytes;
   }
 });
-//# sourceMappingURL=email-crypto-BrT98taw.js.map
+Object.defineProperty(exports, 'wrapKey', {
+  enumerable: true,
+  get: function () {
+    return wrapKey;
+  }
+});
+//# sourceMappingURL=emailKeys-BJGdkLrg.js.map

package/dist/emailKeys-BJGdkLrg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emailKeys-BJGdkLrg.js","names":["KEY_FORMAT","KEY_WRAPPING_ALGORITHM","deriveSymmetricKeyFromTwoKeysAndContext","CONTEXT_WRAPPING","AES_ALGORITHM","UTF8ToUint8","uuidToBytes","UTF8ToUint8","genSymmetricCryptoKey","uint8ArrayToBase64","encryptSymmetrically","UTF8ToUint8","decryptSymmetrically","base64ToUint8Array","uint8ToUTF8","uuidToBytes","deriveSecretKey","encapsulateKyber","decapsulateKyber","getKeyFromPassword","getKeyFromPasswordAndSalt","generateKyberKeys","generateEccKeys"],"sources":["../src/key-wrapper/aesWrapper.ts","../src/email-crypto/converters.ts","../src/email-crypto/utils.ts","../src/email-crypto/core.ts","../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/emailKeys.ts"],"sourcesContent":["import { KEY_WRAPPING_ALGORITHM, KEY_FORMAT, CONTEXT_WRAPPING, AES_ALGORITHM } from '../constants';\nimport { deriveSymmetricKeyFromTwoKeysAndContext } from '../derive-key';\n\n/**\n * Converts wrapping key in Uint8Array into CryptoKey\n *\n * @param key - The wrapping key in Uint8Array representation\n * @returns The resulting CryptoKey\n */\nexport async function importWrappingKey(key: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(KEY_FORMAT, key as BufferSource, KEY_WRAPPING_ALGORITHM, false, [\n      'wrapKey',\n      'unwrapKey',\n    ]);\n  } catch (error) {\n    throw new Error('Failed to import wrapping key', { cause: error });\n  }\n}\n\n/**\n * Derives wrapping key from two secrets\n *\n * @param eccSecret - The secret exchanged via elliptic curves\n * @param kyberSecret - The secret exchanged via Kyber KEM\n * @returns The resulting wrapping CryptoKey\n */\nexport async function deriveWrappingKey(eccSecret: Uint8Array, kyberSecret: Uint8Array): Promise<CryptoKey> {\n  try {\n    if (eccSecret.length !== kyberSecret.length) {\n      throw new Error('secrets must have equal length');\n    }\n    const key = await deriveSymmetricKeyFromTwoKeysAndContext(eccSecret, kyberSecret, CONTEXT_WRAPPING);\n    return await importWrappingKey(key);\n  } catch (error) {\n    throw new Error('Failed to derive wrapping key', { cause: error });\n  }\n}\n\n/**\n * Unwraps the given wrapped key\n *\n * @param encryptedKey - The encrypted key\n * @param wrappingKey - The secret key used for decryption\n * @returns The resulting wrapping CryptoKey\n */\nexport async function unwrapKey(encryptedKey: Uint8Array, wrappingKey: CryptoKey): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.unwrapKey(\n      KEY_FORMAT,\n      encryptedKey as BufferSource,\n      wrappingKey,\n      KEY_WRAPPING_ALGORITHM,\n      AES_ALGORITHM,\n      false,\n      ['encrypt', 'decrypt'],\n    );\n  } catch (error) {\n    throw new Error('Failed to unwrap key', { cause: error });\n  }\n}\n\n/**\n * Wraps the given CryptoKey\n *\n * @param encryptionKey - The CryptoKey to be wrapped\n * @param wrappingKey - The secret key used for wrapping\n * @returns The resulting ciphertext\n */\nexport async function wrapKey(encryptionKey: CryptoKey, wrappingKey: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.wrapKey(KEY_FORMAT, encryptionKey, wrappingKey, KEY_WRAPPING_ALGORITHM);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to wrap key', { cause: error });\n  }\n}\n","import { UTF8ToUint8 } from '../utils';\nimport { User, Email } from '../types';\nimport { concatBytes } from '@noble/hashes/utils.js';\n\nexport function userToBytes(user: User): Uint8Array {\n  try {\n    const json = JSON.stringify(user);\n    return UTF8ToUint8(json);\n  } catch (error) {\n    throw new Error('Failed to convert User to bytes', { cause: error });\n  }\n}\n\nexport function recipientsToBytes(recipients: User[]): Uint8Array {\n  try {\n    const array = recipients.map((user) => userToBytes(user));\n    return concatBytes(...array);\n  } catch (error) {\n    throw new Error('Failed to convert recipients to bytes', { cause: error });\n  }\n}\n\n/**\n * Converts an Email type into a Uint8Array array.\n *\n * @param email - The email.\n * @returns The Uint8Array array representation of the Email type.\n */\nexport function emailToBinary(email: Email): Uint8Array {\n  try {\n    const json = JSON.stringify(email);\n    return UTF8ToUint8(json);\n  } catch (error) {\n    throw new Error('Failed to convert EmailBody to Uint8Array', { cause: error });\n  }\n}\n","import { concatBytes } from '@noble/hashes/utils.js';\nimport { EmailPublicParameters } from '../types';\nimport { UTF8ToUint8, uuidToBytes } from '../utils';\nimport { userToBytes, recipientsToBytes } from './converters';\n\n/**\n * Creates an auxiliary string from public fields of the email.\n *\n * @param params - The email public parameters.\n * @param isSubjectEncrypted - Indicates if the email subject field should be encrypted\n * @returns The resulting auxiliary string\n */\nexport function getAux(params: EmailPublicParameters, isSubjectEncrypted: boolean): Uint8Array {\n  try {\n    const { subject, replyToEmailID, sender, recipient, recipients } = params;\n    const replyBytes = replyToEmailID ? uuidToBytes(replyToEmailID) : new Uint8Array();\n    const senderBytes = userToBytes(sender);\n    const recipientBytes = userToBytes(recipient);\n    const recipientsBytes = recipients ? recipientsToBytes(recipients) : new Uint8Array();\n\n    if (isSubjectEncrypted) {\n      return concatBytes(replyBytes, senderBytes, recipientBytes, recipientsBytes);\n    } else {\n      const subjectBytes = UTF8ToUint8(subject);\n      return concatBytes(subjectBytes, replyBytes, senderBytes, recipientBytes, recipientsBytes);\n    }\n  } catch (error) {\n    throw new Error('Failed to create aux', { cause: error });\n  }\n}\n","import {\n  HybridEncKey,\n  PwdProtectedKey,\n  PublicKeys,\n  PrivateKeys,\n  EmailBody,\n  EmailBodyEncrypted,\n  Email,\n  EmailPublicParameters,\n} from '../types';\nimport { genSymmetricCryptoKey, encryptSymmetrically, decryptSymmetrically } from '../symmetric-crypto';\nimport { encapsulateKyber, decapsulateKyber } from '../post-quantum-crypto';\nimport { deriveWrappingKey, wrapKey, unwrapKey, importWrappingKey } from '../key-wrapper';\nimport { deriveSecretKey } from '../asymmetric-crypto';\nimport { getKeyFromPassword, getKeyFromPasswordAndSalt } from '../derive-key';\nimport { UTF8ToUint8, base64ToUint8Array, uint8ArrayToBase64, uint8ToUTF8, uuidToBytes } from '../utils';\nimport { getAux } from './utils';\n\nexport async function encryptEmailBody(\n  email: Email,\n  isSubjectEncrypted: boolean,\n): Promise<{\n  enc: EmailBodyEncrypted;\n  params: EmailPublicParameters;\n  encryptionKey: CryptoKey;\n}> {\n  try {\n    const aux = getAux(email.params, isSubjectEncrypted);\n\n    let enc: EmailBodyEncrypted;\n    let encryptionKey: CryptoKey;\n    let params = email.params;\n\n    if (isSubjectEncrypted) {\n      const result = await encryptEmailContentAndSubjectSymmetrically(email.body, email.params.subject, aux, email.id);\n      enc = result.enc;\n      encryptionKey = result.encryptionKey;\n      params = { ...email.params, subject: result.encSubject };\n    } else {\n      const result = await encryptEmailContentSymmetrically(email.body, aux, email.id);\n      enc = result.enc;\n      encryptionKey = result.encryptionKey;\n    }\n\n    return { encryptionKey, enc, params };\n  } catch (error) {\n    throw new Error('Failed to encrypt email body', { cause: error });\n  }\n}\n\nexport async function decryptEmailBody(\n  enc: EmailBodyEncrypted,\n  encParams: EmailPublicParameters,\n  encryptionKey: CryptoKey,\n  isSubjectEncrypted: boolean,\n): Promise<{\n  params: EmailPublicParameters;\n  body: EmailBody;\n}> {\n  try {\n    const aux = getAux(encParams, isSubjectEncrypted);\n    let body: EmailBody;\n    let params = encParams;\n    if (isSubjectEncrypted) {\n      const result = await decryptEmailAndSubjectSymmetrically(encryptionKey, aux, encParams.subject, enc);\n      body = result.body;\n      params = { ...encParams, subject: result.subject };\n    } else {\n      body = await decryptEmailSymmetrically(encryptionKey, aux, enc);\n    }\n\n    return { body, params };\n  } catch (error) {\n    throw new Error('Failed to encrypt email body', { cause: error });\n  }\n}\n\n/**\n * Symmetrically encrypts an email with a randomly sampled key.\n *\n * @param email - The email to encrypt.\n * @param aux - The auxiliary data (e.g., email ID or timestamp) for AEAD.\n * @param emailID - The unique identifier of the email.\n * @returns The resulting ciphertext and the used symmetric key\n */\nexport async function encryptEmailContentSymmetrically(\n  email: EmailBody,\n  aux: Uint8Array,\n  emailID: string,\n): Promise<{ enc: EmailBodyEncrypted; encryptionKey: CryptoKey }> {\n  try {\n    if (!email.text) {\n      throw new Error('Invalid input');\n    }\n    const encryptionKey = await genSymmetricCryptoKey();\n    const enc = await encryptEmailContentSymmetricallyWithKey(email, encryptionKey, aux, emailID);\n    return { enc, encryptionKey };\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email', { cause: error });\n  }\n}\n\n/**\n * Symmetrically encrypts an email with a randomly sampled key.\n *\n * @param email - The email to encrypt.\n * @param subject - The email subject to encrypt.\n * @param aux - The auxiliary data (e.g., email ID or timestamp) for AEAD.\n * @param emailID - The unique identifier of the email.\n * @returns The resulting ciphertext and the used symmetric key\n */\nexport async function encryptEmailContentAndSubjectSymmetrically(\n  email: EmailBody,\n  subject: string,\n  aux: Uint8Array,\n  emailID: string,\n): Promise<{ enc: EmailBodyEncrypted; encSubject: string; encryptionKey: CryptoKey }> {\n  try {\n    if (!subject || !email.text) {\n      throw new Error('Invalid input');\n    }\n    const encryptionKey = await genSymmetricCryptoKey();\n    const enc = await encryptEmailContentSymmetricallyWithKey(email, encryptionKey, aux, emailID);\n    const subjectBuff = UTF8ToUint8(subject);\n    const subjectEnc = await encryptSymmetrically(encryptionKey, subjectBuff, aux);\n    const encSubject = uint8ArrayToBase64(subjectEnc);\n    return { enc, encSubject, encryptionKey };\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email and subject', { cause: error });\n  }\n}\n\n/**\n * Decrypts symmetrically encrypted email.\n *\n * @param encryptedEmail - The email to decrypt.\n * @param encryptionKey - The symmetric CryptoKey.\n * @returns The decrypted email\n */\nexport async function decryptEmailAndSubjectSymmetrically(\n  encryptionKey: CryptoKey,\n  aux: Uint8Array,\n  encSubject: string,\n  enc: EmailBodyEncrypted,\n): Promise<{ body: EmailBody; subject: string }> {\n  try {\n    const array = base64ToUint8Array(encSubject);\n    const subjectArray = await decryptSymmetrically(encryptionKey, array, aux);\n    const body = await decryptEmailSymmetrically(encryptionKey, aux, enc);\n    const subject = uint8ToUTF8(subjectArray);\n    return { body, subject };\n  } catch (error) {\n    throw new Error('Failed to symmetrically decrypt email and subject', { cause: error });\n  }\n}\n\n/**\n * Symmetrically encrypts an email with a randomly sampled key.\n *\n * @param email - The email to encrypt.\n * @returns The resulting ciphertext and the used symmetric key\n */\nexport async function encryptEmailContentSymmetricallyWithKey(\n  emailBody: EmailBody,\n  encryptionKey: CryptoKey,\n  aux: Uint8Array,\n  emailID: string,\n): Promise<EmailBodyEncrypted> {\n  try {\n    const freeField = uuidToBytes(emailID);\n    const text = UTF8ToUint8(emailBody.text);\n    const encryptedText = await encryptSymmetrically(encryptionKey, text, aux, freeField);\n    const encText = uint8ArrayToBase64(encryptedText);\n    const result: EmailBodyEncrypted = { encText };\n\n    if (emailBody.attachments) {\n      const encryptedAttachements = await encryptEmailAttachements(emailBody.attachments, encryptionKey, aux, emailID);\n      result.encAttachments = encryptedAttachements?.map(uint8ArrayToBase64);\n    }\n    return result;\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email with the given key', { cause: error });\n  }\n}\n\nasync function encryptEmailAttachements(\n  attachments: string[],\n  encryptionKey: CryptoKey,\n  aux: Uint8Array,\n  emailID: string,\n): Promise<Uint8Array[]> {\n  try {\n    const freeField = uuidToBytes(emailID);\n    const encryptedAttachments = await Promise.all(\n      attachments.map((attachment) => {\n        const binaryAttachment = UTF8ToUint8(attachment);\n        return encryptSymmetrically(encryptionKey, binaryAttachment, aux, freeField);\n      }),\n    );\n    return encryptedAttachments;\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email attachements', { cause: error });\n  }\n}\n\nasync function decryptEmailAttachements(\n  encryptedAttachments: Uint8Array[],\n  encryptionKey: CryptoKey,\n  aux: Uint8Array,\n): Promise<Uint8Array[]> {\n  try {\n    const decryptedAttachments = await Promise.all(\n      encryptedAttachments.map((attachment) => {\n        return decryptSymmetrically(encryptionKey, attachment, aux);\n      }),\n    );\n    return decryptedAttachments;\n  } catch (error) {\n    throw new Error('Failed to symmetrically decrypt email attachements', { cause: error });\n  }\n}\n\n/**\n * Decrypts symmetrically encrypted email.\n *\n * @param encryptedEmail - The email to decrypt.\n * @param encryptionKey - The symmetric CryptoKey.\n * @returns The decrypted email\n */\nexport async function decryptEmailSymmetrically(\n  encryptionKey: CryptoKey,\n  aux: Uint8Array,\n  enc: EmailBodyEncrypted,\n): Promise<EmailBody> {\n  try {\n    const cipher = base64ToUint8Array(enc.encText);\n    const textArray = await decryptSymmetrically(encryptionKey, cipher, aux);\n    const text = uint8ToUTF8(textArray);\n    const result: EmailBody = { text };\n\n    if (enc.encAttachments) {\n      const encAttachements = enc.encAttachments?.map(base64ToUint8Array);\n      const attachmentsArray = await decryptEmailAttachements(encAttachements, encryptionKey, aux);\n      result.attachments = attachmentsArray?.map((att) => uint8ToUTF8(att));\n    }\n    return result;\n  } catch (error) {\n    throw new Error('Failed to symmetrically decrypt email', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email symmetric key using hybrid encryption.\n *\n * @param emailEncryptionKey - The symmetric CryptoKey used for email encryption.\n * @param recipientPublicKey - The public key of the recipient.\n * @param senderPrivateKey - The private key of the sender.\n * @returns The encrypted email symmetric key\n */\nexport async function encryptKeysHybrid(\n  emailEncryptionKey: CryptoKey,\n  recipientPublicKey: PublicKeys,\n  senderPrivateKey: PrivateKeys,\n): Promise<HybridEncKey> {\n  try {\n    const eccSecret = await deriveSecretKey(recipientPublicKey.eccPublicKey, senderPrivateKey.eccPrivateKey);\n    const { cipherText: kyberCiphertext, sharedSecret: kyberSecret } = encapsulateKyber(\n      recipientPublicKey.kyberPublicKey,\n    );\n    const wrappingKey = await deriveWrappingKey(eccSecret, kyberSecret);\n    const encryptedKey = await wrapKey(emailEncryptionKey, wrappingKey);\n    const encryptedKeyBase64 = uint8ArrayToBase64(encryptedKey);\n    const kyberCiphertextBase64 = uint8ArrayToBase64(kyberCiphertext);\n\n    return { encryptedKey: encryptedKeyBase64, kyberCiphertext: kyberCiphertextBase64 };\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 senderPublicKey - The public key of the sender.\n * @param recipientPrivateKey - The private key of the recipient.\n * @returns The email encryption CryptoKey\n */\nexport async function decryptKeysHybrid(\n  encryptedKey: HybridEncKey,\n  senderPublicKey: PublicKeys,\n  recipientPrivateKey: PrivateKeys,\n): Promise<CryptoKey> {\n  try {\n    const kyberCiphertext = base64ToUint8Array(encryptedKey.kyberCiphertext);\n    const encKey = base64ToUint8Array(encryptedKey.encryptedKey);\n    const eccSecret = await deriveSecretKey(senderPublicKey.eccPublicKey, recipientPrivateKey.eccPrivateKey);\n    const kyberSecret = decapsulateKyber(kyberCiphertext, recipientPrivateKey.kyberPrivateKey);\n    const wrappingKey = await deriveWrappingKey(eccSecret, kyberSecret);\n    const encryptionKey = await unwrapKey(encKey, wrappingKey);\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 CryptoKey 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: CryptoKey, password: string): Promise<PwdProtectedKey> {\n  try {\n    const { key, salt } = await getKeyFromPassword(password);\n    const wrappingKey = await importWrappingKey(key);\n    const encryptedKey = await wrapKey(emailEncryptionKey, wrappingKey);\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 CryptoKey\n */\nexport async function removePasswordProtection(\n  emailEncryptionKey: PwdProtectedKey,\n  password: string,\n): Promise<CryptoKey> {\n  try {\n    const salt = base64ToUint8Array(emailEncryptionKey.salt);\n    const encryptedKey = base64ToUint8Array(emailEncryptionKey.encryptedKey);\n    const key = await getKeyFromPasswordAndSalt(password, salt);\n    const wrappingKey = await importWrappingKey(key);\n    const encryptionKey = await unwrapKey(encryptedKey, wrappingKey);\n    return encryptionKey;\n  } catch (error) {\n    throw new Error('Failed to remove password-protection from email key', { cause: error });\n  }\n}\n","import { PublicKeys, PrivateKeys, HybridEncryptedEmail, Email, UserWithPublicKeys } from '../types';\nimport { decryptEmailBody, encryptKeysHybrid, decryptKeysHybrid, encryptEmailBody } from './core';\n\n/**\n * Encrypts the email using hybrid encryption.\n *\n * @param email - The email to encrypt.\n * @param recipientPublicKeys - The public keys of the recipient.\n * @param senderPrivateKey - The private key of the sender.\n * @param isSubjectEncrypted -  Indicates if the email subject field should be encrypted\n * @returns The encrypted email\n */\nexport async function encryptEmailHybrid(\n  email: Email,\n  recipient: UserWithPublicKeys,\n  senderPrivateKey: PrivateKeys,\n  isSubjectEncrypted: boolean = false,\n): Promise<HybridEncryptedEmail> {\n  try {\n    const { encryptionKey, params, enc } = await encryptEmailBody(email, isSubjectEncrypted);\n    const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient.publicKeys, senderPrivateKey);\n    return { enc, encryptedKey, recipientEmail: recipient.email, params, isSubjectEncrypted, id: email.id };\n  } catch (error) {\n    throw new Error('Failed to encrypt email with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email using hybrid encryption for multiple recipients.\n *\n * @param email - The email to encrypt.\n * @param recipients - The recipients with corresponding public keys.\n * @param senderPrivateKey - The private key of the sender.\n * @param isSubjectEncrypted -  Indicates if the email subject field should be encrypted\n * @returns The set of encrypted email\n */\nexport async function encryptEmailHybridForMultipleRecipients(\n  email: Email,\n  recipients: UserWithPublicKeys[],\n  senderPrivateKey: PrivateKeys,\n  isSubjectEncrypted: boolean = false,\n): Promise<HybridEncryptedEmail[]> {\n  try {\n    const { encryptionKey, params, enc } = await encryptEmailBody(email, isSubjectEncrypted);\n\n    const encryptedEmails: HybridEncryptedEmail[] = [];\n    for (const recipient of recipients) {\n      const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient.publicKeys, senderPrivateKey);\n      encryptedEmails.push({\n        enc,\n        encryptedKey,\n        recipientEmail: recipient.email,\n        params,\n        isSubjectEncrypted,\n        id: email.id,\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 encryptedEmail - The encrypted email.\n * @param senderPublicKeys - The public key of the sender.\n * @param recipientPrivateKeys - The private key of the recipient.\n * @returns The decrypted email\n */\nexport async function decryptEmailHybrid(\n  encryptedEmail: HybridEncryptedEmail,\n  senderPublicKeys: PublicKeys,\n  recipientPrivateKeys: PrivateKeys,\n): Promise<Email> {\n  try {\n    const { isSubjectEncrypted, params: encParams, enc, encryptedKey, id } = encryptedEmail;\n    const encryptionKey = await decryptKeysHybrid(encryptedKey, senderPublicKeys, recipientPrivateKeys);\n    const { body, params } = await decryptEmailBody(enc, encParams, encryptionKey, isSubjectEncrypted);\n    return { body, params, id };\n  } catch (error) {\n    throw new Error('Failed to decrypt email with hybrid encryption', { cause: error });\n  }\n}\n","import { PwdProtectedEmail, Email } 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 isSubjectEncrypted -  Indicates if the email subject field should be encrypted\n * @returns The password-protected email\n */\nexport async function createPwdProtectedEmail(\n  email: Email,\n  password: string,\n  isSubjectEncrypted: boolean = false,\n): Promise<PwdProtectedEmail> {\n  try {\n    if (!email?.body || !email.params) {\n      throw new Error('Failed to password-protect email: Invalid email structure');\n    }\n    const { encryptionKey, params, enc } = await encryptEmailBody(email, isSubjectEncrypted);\n    const encryptedKey = await passwordProtectKey(encryptionKey, password);\n\n    return { enc, encryptedKey, params, id: email.id, isSubjectEncrypted };\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 * @returns The decrypted email\n */\nexport async function decryptPwdProtectedEmail(encryptedEmail: PwdProtectedEmail, password: string): Promise<Email> {\n  try {\n    const { isSubjectEncrypted, params: encParams, enc, id } = encryptedEmail;\n    const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);\n    const { body, params } = await decryptEmailBody(enc, encParams, encryptionKey, isSubjectEncrypted);\n    return { body, params, id };\n  } catch (error) {\n    throw new Error('Failed to decrypt password-protect email', { cause: error });\n  }\n}\n","import { generateEccKeys } from '../asymmetric-crypto';\nimport { generateKyberKeys } from '../post-quantum-crypto';\nimport { EmailKeys } from '../types';\n\n/**\n * Generates public and private keys for email service.\n *\n * @returns The user's private and public keys\n */\nexport async function generateEmailKeys(): Promise<EmailKeys> {\n  try {\n    const kyberKeys = generateKyberKeys();\n    const keys = await generateEccKeys();\n\n    const emailKeys: EmailKeys = {\n      publicKeys: {\n        eccPublicKey: keys.publicKey,\n        kyberPublicKey: kyberKeys.publicKey,\n      },\n      privateKeys: {\n        eccPrivateKey: keys.privateKey,\n        kyberPrivateKey: kyberKeys.secretKey,\n      },\n    };\n\n    return emailKeys;\n  } catch (error) {\n    throw new Error('Failed to generate keys for email service', { cause: error });\n  }\n}\n"],"mappings":"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"}

package/dist/{email-crypto-DJUEjTxA.mjs → emailKeys-Fp9WR3wl.mjs}

@@ -1,10 +1,9 @@
-import { t as __exportAll } from "./chunk-DWirmd9C.mjs";
-import { b as KEY_WRAPPING_ALGORITHM, p as CONTEXT_WRAPPING, t as AES_ALGORITHM, y as KEY_FORMAT } from "./constants-kTeX-2T0.mjs";
-import { i as generateEccKeys, s as deriveSecretKey } from "./asymmetric-crypto-CyXsV4XT.mjs";
-import { d as base64ToUint8Array, h as uint8ToUTF8, i as uuidToBytes, p as uint8ArrayToBase64, u as UTF8ToUint8 } from "./utils-DS04iUcX.mjs";
-import { n as decryptSymmetrically, o as genSymmetricCryptoKey, r as encryptSymmetrically } from "./symmetric-crypto-CrdS1Che.mjs";
-import { d as deriveSymmetricKeyFromTwoKeysAndContext, n as getKeyFromPassword, r as getKeyFromPasswordAndSalt } from "./derive-key-Be7hS-cN.mjs";
-import { a as encapsulateKyber, i as decapsulateKyber, o as generateKyberKeys } from "./post-quantum-crypto-Vv34t6gX.mjs";
+import { AES_ALGORITHM, CONTEXT_WRAPPING, KEY_FORMAT, KEY_WRAPPING_ALGORITHM } from "./constants.mjs";
+import { o as deriveSecretKey, r as generateEccKeys } from "./keys-BfcaiAOv.mjs";
+import { f as uint8ArrayToBase64, l as UTF8ToUint8, m as uint8ToUTF8, r as uuidToBytes, u as base64ToUint8Array } from "./genID-3Er5IowC.mjs";
+import { a as genSymmetricCryptoKey, n as encryptSymmetrically, t as decryptSymmetrically } from "./aes-DSDxP8uF.mjs";
+import { n as getKeyFromPasswordAndSalt, t as getKeyFromPassword, u as deriveSymmetricKeyFromTwoKeysAndContext } from "./deriveKeysFromPassword-DJRWZ8Rw.mjs";
+import { a as generateKyberKeys, i as encapsulateKyber, r as decapsulateKyber } from "./kyber1024-PpwE1rki.mjs";
 import { concatBytes } from "@noble/hashes/utils.js";
 
 //#region src/key-wrapper/aesWrapper.ts
@@ -66,15 +65,6 @@ async function wrapKey(encryptionKey, wrappingKey) {
 	}
 }
 
-//#endregion
-//#region src/key-wrapper/index.ts
-var key_wrapper_exports = /* @__PURE__ */ __exportAll({
-	deriveWrappingKey: () => deriveWrappingKey,
-	importWrappingKey: () => importWrappingKey,
-	unwrapKey: () => unwrapKey,
-	wrapKey: () => wrapKey
-});
-
 //#endregion
 //#region src/email-crypto/converters.ts
 function userToBytes(user) {
@@ -515,20 +505,5 @@ async function generateEmailKeys() {
 }
 
 //#endregion
-//#region src/email-crypto/index.ts
-var email_crypto_exports = /* @__PURE__ */ __exportAll({
-	createPwdProtectedEmail: () => createPwdProtectedEmail,
-	decryptEmailHybrid: () => decryptEmailHybrid,
-	decryptPwdProtectedEmail: () => decryptPwdProtectedEmail,
-	emailToBinary: () => emailToBinary,
-	encryptEmailHybrid: () => encryptEmailHybrid,
-	encryptEmailHybridForMultipleRecipients: () => encryptEmailHybridForMultipleRecipients,
-	generateEmailKeys: () => generateEmailKeys,
-	getAux: () => getAux,
-	recipientsToBytes: () => recipientsToBytes,
-	userToBytes: () => userToBytes
-});
-
-//#endregion
-export { decryptEmailHybrid as a, decryptEmailSymmetrically as c, emailToBinary as d, recipientsToBytes as f, decryptPwdProtectedEmail as i, encryptEmailContentSymmetricallyWithKey as l, key_wrapper_exports as m, generateEmailKeys as n, encryptEmailHybrid as o, userToBytes as p, createPwdProtectedEmail as r, encryptEmailHybridForMultipleRecipients as s, email_crypto_exports as t, getAux as u };
-//# sourceMappingURL=email-crypto-DJUEjTxA.mjs.map
+export { encryptEmailHybrid as a, encryptEmailContentSymmetricallyWithKey as c, recipientsToBytes as d, userToBytes as f, decryptEmailHybrid as i, getAux as l, wrapKey as m, createPwdProtectedEmail as n, encryptEmailHybridForMultipleRecipients as o, unwrapKey as p, decryptPwdProtectedEmail as r, decryptEmailSymmetrically as s, generateEmailKeys as t, emailToBinary as u };
+//# sourceMappingURL=emailKeys-Fp9WR3wl.mjs.map

package/dist/emailKeys-Fp9WR3wl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"emailKeys-Fp9WR3wl.mjs","names":[],"sources":["../src/key-wrapper/aesWrapper.ts","../src/email-crypto/converters.ts","../src/email-crypto/utils.ts","../src/email-crypto/core.ts","../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/emailKeys.ts"],"sourcesContent":["import { KEY_WRAPPING_ALGORITHM, KEY_FORMAT, CONTEXT_WRAPPING, AES_ALGORITHM } from '../constants';\nimport { deriveSymmetricKeyFromTwoKeysAndContext } from '../derive-key';\n\n/**\n * Converts wrapping key in Uint8Array into CryptoKey\n *\n * @param key - The wrapping key in Uint8Array representation\n * @returns The resulting CryptoKey\n */\nexport async function importWrappingKey(key: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(KEY_FORMAT, key as BufferSource, KEY_WRAPPING_ALGORITHM, false, [\n      'wrapKey',\n      'unwrapKey',\n    ]);\n  } catch (error) {\n    throw new Error('Failed to import wrapping key', { cause: error });\n  }\n}\n\n/**\n * Derives wrapping key from two secrets\n *\n * @param eccSecret - The secret exchanged via elliptic curves\n * @param kyberSecret - The secret exchanged via Kyber KEM\n * @returns The resulting wrapping CryptoKey\n */\nexport async function deriveWrappingKey(eccSecret: Uint8Array, kyberSecret: Uint8Array): Promise<CryptoKey> {\n  try {\n    if (eccSecret.length !== kyberSecret.length) {\n      throw new Error('secrets must have equal length');\n    }\n    const key = await deriveSymmetricKeyFromTwoKeysAndContext(eccSecret, kyberSecret, CONTEXT_WRAPPING);\n    return await importWrappingKey(key);\n  } catch (error) {\n    throw new Error('Failed to derive wrapping key', { cause: error });\n  }\n}\n\n/**\n * Unwraps the given wrapped key\n *\n * @param encryptedKey - The encrypted key\n * @param wrappingKey - The secret key used for decryption\n * @returns The resulting wrapping CryptoKey\n */\nexport async function unwrapKey(encryptedKey: Uint8Array, wrappingKey: CryptoKey): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.unwrapKey(\n      KEY_FORMAT,\n      encryptedKey as BufferSource,\n      wrappingKey,\n      KEY_WRAPPING_ALGORITHM,\n      AES_ALGORITHM,\n      false,\n      ['encrypt', 'decrypt'],\n    );\n  } catch (error) {\n    throw new Error('Failed to unwrap key', { cause: error });\n  }\n}\n\n/**\n * Wraps the given CryptoKey\n *\n * @param encryptionKey - The CryptoKey to be wrapped\n * @param wrappingKey - The secret key used for wrapping\n * @returns The resulting ciphertext\n */\nexport async function wrapKey(encryptionKey: CryptoKey, wrappingKey: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.wrapKey(KEY_FORMAT, encryptionKey, wrappingKey, KEY_WRAPPING_ALGORITHM);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to wrap key', { cause: error });\n  }\n}\n","import { UTF8ToUint8 } from '../utils';\nimport { User, Email } from '../types';\nimport { concatBytes } from '@noble/hashes/utils.js';\n\nexport function userToBytes(user: User): Uint8Array {\n  try {\n    const json = JSON.stringify(user);\n    return UTF8ToUint8(json);\n  } catch (error) {\n    throw new Error('Failed to convert User to bytes', { cause: error });\n  }\n}\n\nexport function recipientsToBytes(recipients: User[]): Uint8Array {\n  try {\n    const array = recipients.map((user) => userToBytes(user));\n    return concatBytes(...array);\n  } catch (error) {\n    throw new Error('Failed to convert recipients to bytes', { cause: error });\n  }\n}\n\n/**\n * Converts an Email type into a Uint8Array array.\n *\n * @param email - The email.\n * @returns The Uint8Array array representation of the Email type.\n */\nexport function emailToBinary(email: Email): Uint8Array {\n  try {\n    const json = JSON.stringify(email);\n    return UTF8ToUint8(json);\n  } catch (error) {\n    throw new Error('Failed to convert EmailBody to Uint8Array', { cause: error });\n  }\n}\n","import { concatBytes } from '@noble/hashes/utils.js';\nimport { EmailPublicParameters } from '../types';\nimport { UTF8ToUint8, uuidToBytes } from '../utils';\nimport { userToBytes, recipientsToBytes } from './converters';\n\n/**\n * Creates an auxiliary string from public fields of the email.\n *\n * @param params - The email public parameters.\n * @param isSubjectEncrypted - Indicates if the email subject field should be encrypted\n * @returns The resulting auxiliary string\n */\nexport function getAux(params: EmailPublicParameters, isSubjectEncrypted: boolean): Uint8Array {\n  try {\n    const { subject, replyToEmailID, sender, recipient, recipients } = params;\n    const replyBytes = replyToEmailID ? uuidToBytes(replyToEmailID) : new Uint8Array();\n    const senderBytes = userToBytes(sender);\n    const recipientBytes = userToBytes(recipient);\n    const recipientsBytes = recipients ? recipientsToBytes(recipients) : new Uint8Array();\n\n    if (isSubjectEncrypted) {\n      return concatBytes(replyBytes, senderBytes, recipientBytes, recipientsBytes);\n    } else {\n      const subjectBytes = UTF8ToUint8(subject);\n      return concatBytes(subjectBytes, replyBytes, senderBytes, recipientBytes, recipientsBytes);\n    }\n  } catch (error) {\n    throw new Error('Failed to create aux', { cause: error });\n  }\n}\n","import {\n  HybridEncKey,\n  PwdProtectedKey,\n  PublicKeys,\n  PrivateKeys,\n  EmailBody,\n  EmailBodyEncrypted,\n  Email,\n  EmailPublicParameters,\n} from '../types';\nimport { genSymmetricCryptoKey, encryptSymmetrically, decryptSymmetrically } from '../symmetric-crypto';\nimport { encapsulateKyber, decapsulateKyber } from '../post-quantum-crypto';\nimport { deriveWrappingKey, wrapKey, unwrapKey, importWrappingKey } from '../key-wrapper';\nimport { deriveSecretKey } from '../asymmetric-crypto';\nimport { getKeyFromPassword, getKeyFromPasswordAndSalt } from '../derive-key';\nimport { UTF8ToUint8, base64ToUint8Array, uint8ArrayToBase64, uint8ToUTF8, uuidToBytes } from '../utils';\nimport { getAux } from './utils';\n\nexport async function encryptEmailBody(\n  email: Email,\n  isSubjectEncrypted: boolean,\n): Promise<{\n  enc: EmailBodyEncrypted;\n  params: EmailPublicParameters;\n  encryptionKey: CryptoKey;\n}> {\n  try {\n    const aux = getAux(email.params, isSubjectEncrypted);\n\n    let enc: EmailBodyEncrypted;\n    let encryptionKey: CryptoKey;\n    let params = email.params;\n\n    if (isSubjectEncrypted) {\n      const result = await encryptEmailContentAndSubjectSymmetrically(email.body, email.params.subject, aux, email.id);\n      enc = result.enc;\n      encryptionKey = result.encryptionKey;\n      params = { ...email.params, subject: result.encSubject };\n    } else {\n      const result = await encryptEmailContentSymmetrically(email.body, aux, email.id);\n      enc = result.enc;\n      encryptionKey = result.encryptionKey;\n    }\n\n    return { encryptionKey, enc, params };\n  } catch (error) {\n    throw new Error('Failed to encrypt email body', { cause: error });\n  }\n}\n\nexport async function decryptEmailBody(\n  enc: EmailBodyEncrypted,\n  encParams: EmailPublicParameters,\n  encryptionKey: CryptoKey,\n  isSubjectEncrypted: boolean,\n): Promise<{\n  params: EmailPublicParameters;\n  body: EmailBody;\n}> {\n  try {\n    const aux = getAux(encParams, isSubjectEncrypted);\n    let body: EmailBody;\n    let params = encParams;\n    if (isSubjectEncrypted) {\n      const result = await decryptEmailAndSubjectSymmetrically(encryptionKey, aux, encParams.subject, enc);\n      body = result.body;\n      params = { ...encParams, subject: result.subject };\n    } else {\n      body = await decryptEmailSymmetrically(encryptionKey, aux, enc);\n    }\n\n    return { body, params };\n  } catch (error) {\n    throw new Error('Failed to encrypt email body', { cause: error });\n  }\n}\n\n/**\n * Symmetrically encrypts an email with a randomly sampled key.\n *\n * @param email - The email to encrypt.\n * @param aux - The auxiliary data (e.g., email ID or timestamp) for AEAD.\n * @param emailID - The unique identifier of the email.\n * @returns The resulting ciphertext and the used symmetric key\n */\nexport async function encryptEmailContentSymmetrically(\n  email: EmailBody,\n  aux: Uint8Array,\n  emailID: string,\n): Promise<{ enc: EmailBodyEncrypted; encryptionKey: CryptoKey }> {\n  try {\n    if (!email.text) {\n      throw new Error('Invalid input');\n    }\n    const encryptionKey = await genSymmetricCryptoKey();\n    const enc = await encryptEmailContentSymmetricallyWithKey(email, encryptionKey, aux, emailID);\n    return { enc, encryptionKey };\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email', { cause: error });\n  }\n}\n\n/**\n * Symmetrically encrypts an email with a randomly sampled key.\n *\n * @param email - The email to encrypt.\n * @param subject - The email subject to encrypt.\n * @param aux - The auxiliary data (e.g., email ID or timestamp) for AEAD.\n * @param emailID - The unique identifier of the email.\n * @returns The resulting ciphertext and the used symmetric key\n */\nexport async function encryptEmailContentAndSubjectSymmetrically(\n  email: EmailBody,\n  subject: string,\n  aux: Uint8Array,\n  emailID: string,\n): Promise<{ enc: EmailBodyEncrypted; encSubject: string; encryptionKey: CryptoKey }> {\n  try {\n    if (!subject || !email.text) {\n      throw new Error('Invalid input');\n    }\n    const encryptionKey = await genSymmetricCryptoKey();\n    const enc = await encryptEmailContentSymmetricallyWithKey(email, encryptionKey, aux, emailID);\n    const subjectBuff = UTF8ToUint8(subject);\n    const subjectEnc = await encryptSymmetrically(encryptionKey, subjectBuff, aux);\n    const encSubject = uint8ArrayToBase64(subjectEnc);\n    return { enc, encSubject, encryptionKey };\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email and subject', { cause: error });\n  }\n}\n\n/**\n * Decrypts symmetrically encrypted email.\n *\n * @param encryptedEmail - The email to decrypt.\n * @param encryptionKey - The symmetric CryptoKey.\n * @returns The decrypted email\n */\nexport async function decryptEmailAndSubjectSymmetrically(\n  encryptionKey: CryptoKey,\n  aux: Uint8Array,\n  encSubject: string,\n  enc: EmailBodyEncrypted,\n): Promise<{ body: EmailBody; subject: string }> {\n  try {\n    const array = base64ToUint8Array(encSubject);\n    const subjectArray = await decryptSymmetrically(encryptionKey, array, aux);\n    const body = await decryptEmailSymmetrically(encryptionKey, aux, enc);\n    const subject = uint8ToUTF8(subjectArray);\n    return { body, subject };\n  } catch (error) {\n    throw new Error('Failed to symmetrically decrypt email and subject', { cause: error });\n  }\n}\n\n/**\n * Symmetrically encrypts an email with a randomly sampled key.\n *\n * @param email - The email to encrypt.\n * @returns The resulting ciphertext and the used symmetric key\n */\nexport async function encryptEmailContentSymmetricallyWithKey(\n  emailBody: EmailBody,\n  encryptionKey: CryptoKey,\n  aux: Uint8Array,\n  emailID: string,\n): Promise<EmailBodyEncrypted> {\n  try {\n    const freeField = uuidToBytes(emailID);\n    const text = UTF8ToUint8(emailBody.text);\n    const encryptedText = await encryptSymmetrically(encryptionKey, text, aux, freeField);\n    const encText = uint8ArrayToBase64(encryptedText);\n    const result: EmailBodyEncrypted = { encText };\n\n    if (emailBody.attachments) {\n      const encryptedAttachements = await encryptEmailAttachements(emailBody.attachments, encryptionKey, aux, emailID);\n      result.encAttachments = encryptedAttachements?.map(uint8ArrayToBase64);\n    }\n    return result;\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email with the given key', { cause: error });\n  }\n}\n\nasync function encryptEmailAttachements(\n  attachments: string[],\n  encryptionKey: CryptoKey,\n  aux: Uint8Array,\n  emailID: string,\n): Promise<Uint8Array[]> {\n  try {\n    const freeField = uuidToBytes(emailID);\n    const encryptedAttachments = await Promise.all(\n      attachments.map((attachment) => {\n        const binaryAttachment = UTF8ToUint8(attachment);\n        return encryptSymmetrically(encryptionKey, binaryAttachment, aux, freeField);\n      }),\n    );\n    return encryptedAttachments;\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email attachements', { cause: error });\n  }\n}\n\nasync function decryptEmailAttachements(\n  encryptedAttachments: Uint8Array[],\n  encryptionKey: CryptoKey,\n  aux: Uint8Array,\n): Promise<Uint8Array[]> {\n  try {\n    const decryptedAttachments = await Promise.all(\n      encryptedAttachments.map((attachment) => {\n        return decryptSymmetrically(encryptionKey, attachment, aux);\n      }),\n    );\n    return decryptedAttachments;\n  } catch (error) {\n    throw new Error('Failed to symmetrically decrypt email attachements', { cause: error });\n  }\n}\n\n/**\n * Decrypts symmetrically encrypted email.\n *\n * @param encryptedEmail - The email to decrypt.\n * @param encryptionKey - The symmetric CryptoKey.\n * @returns The decrypted email\n */\nexport async function decryptEmailSymmetrically(\n  encryptionKey: CryptoKey,\n  aux: Uint8Array,\n  enc: EmailBodyEncrypted,\n): Promise<EmailBody> {\n  try {\n    const cipher = base64ToUint8Array(enc.encText);\n    const textArray = await decryptSymmetrically(encryptionKey, cipher, aux);\n    const text = uint8ToUTF8(textArray);\n    const result: EmailBody = { text };\n\n    if (enc.encAttachments) {\n      const encAttachements = enc.encAttachments?.map(base64ToUint8Array);\n      const attachmentsArray = await decryptEmailAttachements(encAttachements, encryptionKey, aux);\n      result.attachments = attachmentsArray?.map((att) => uint8ToUTF8(att));\n    }\n    return result;\n  } catch (error) {\n    throw new Error('Failed to symmetrically decrypt email', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email symmetric key using hybrid encryption.\n *\n * @param emailEncryptionKey - The symmetric CryptoKey used for email encryption.\n * @param recipientPublicKey - The public key of the recipient.\n * @param senderPrivateKey - The private key of the sender.\n * @returns The encrypted email symmetric key\n */\nexport async function encryptKeysHybrid(\n  emailEncryptionKey: CryptoKey,\n  recipientPublicKey: PublicKeys,\n  senderPrivateKey: PrivateKeys,\n): Promise<HybridEncKey> {\n  try {\n    const eccSecret = await deriveSecretKey(recipientPublicKey.eccPublicKey, senderPrivateKey.eccPrivateKey);\n    const { cipherText: kyberCiphertext, sharedSecret: kyberSecret } = encapsulateKyber(\n      recipientPublicKey.kyberPublicKey,\n    );\n    const wrappingKey = await deriveWrappingKey(eccSecret, kyberSecret);\n    const encryptedKey = await wrapKey(emailEncryptionKey, wrappingKey);\n    const encryptedKeyBase64 = uint8ArrayToBase64(encryptedKey);\n    const kyberCiphertextBase64 = uint8ArrayToBase64(kyberCiphertext);\n\n    return { encryptedKey: encryptedKeyBase64, kyberCiphertext: kyberCiphertextBase64 };\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 senderPublicKey - The public key of the sender.\n * @param recipientPrivateKey - The private key of the recipient.\n * @returns The email encryption CryptoKey\n */\nexport async function decryptKeysHybrid(\n  encryptedKey: HybridEncKey,\n  senderPublicKey: PublicKeys,\n  recipientPrivateKey: PrivateKeys,\n): Promise<CryptoKey> {\n  try {\n    const kyberCiphertext = base64ToUint8Array(encryptedKey.kyberCiphertext);\n    const encKey = base64ToUint8Array(encryptedKey.encryptedKey);\n    const eccSecret = await deriveSecretKey(senderPublicKey.eccPublicKey, recipientPrivateKey.eccPrivateKey);\n    const kyberSecret = decapsulateKyber(kyberCiphertext, recipientPrivateKey.kyberPrivateKey);\n    const wrappingKey = await deriveWrappingKey(eccSecret, kyberSecret);\n    const encryptionKey = await unwrapKey(encKey, wrappingKey);\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 CryptoKey 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: CryptoKey, password: string): Promise<PwdProtectedKey> {\n  try {\n    const { key, salt } = await getKeyFromPassword(password);\n    const wrappingKey = await importWrappingKey(key);\n    const encryptedKey = await wrapKey(emailEncryptionKey, wrappingKey);\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 CryptoKey\n */\nexport async function removePasswordProtection(\n  emailEncryptionKey: PwdProtectedKey,\n  password: string,\n): Promise<CryptoKey> {\n  try {\n    const salt = base64ToUint8Array(emailEncryptionKey.salt);\n    const encryptedKey = base64ToUint8Array(emailEncryptionKey.encryptedKey);\n    const key = await getKeyFromPasswordAndSalt(password, salt);\n    const wrappingKey = await importWrappingKey(key);\n    const encryptionKey = await unwrapKey(encryptedKey, wrappingKey);\n    return encryptionKey;\n  } catch (error) {\n    throw new Error('Failed to remove password-protection from email key', { cause: error });\n  }\n}\n","import { PublicKeys, PrivateKeys, HybridEncryptedEmail, Email, UserWithPublicKeys } from '../types';\nimport { decryptEmailBody, encryptKeysHybrid, decryptKeysHybrid, encryptEmailBody } from './core';\n\n/**\n * Encrypts the email using hybrid encryption.\n *\n * @param email - The email to encrypt.\n * @param recipientPublicKeys - The public keys of the recipient.\n * @param senderPrivateKey - The private key of the sender.\n * @param isSubjectEncrypted -  Indicates if the email subject field should be encrypted\n * @returns The encrypted email\n */\nexport async function encryptEmailHybrid(\n  email: Email,\n  recipient: UserWithPublicKeys,\n  senderPrivateKey: PrivateKeys,\n  isSubjectEncrypted: boolean = false,\n): Promise<HybridEncryptedEmail> {\n  try {\n    const { encryptionKey, params, enc } = await encryptEmailBody(email, isSubjectEncrypted);\n    const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient.publicKeys, senderPrivateKey);\n    return { enc, encryptedKey, recipientEmail: recipient.email, params, isSubjectEncrypted, id: email.id };\n  } catch (error) {\n    throw new Error('Failed to encrypt email with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email using hybrid encryption for multiple recipients.\n *\n * @param email - The email to encrypt.\n * @param recipients - The recipients with corresponding public keys.\n * @param senderPrivateKey - The private key of the sender.\n * @param isSubjectEncrypted -  Indicates if the email subject field should be encrypted\n * @returns The set of encrypted email\n */\nexport async function encryptEmailHybridForMultipleRecipients(\n  email: Email,\n  recipients: UserWithPublicKeys[],\n  senderPrivateKey: PrivateKeys,\n  isSubjectEncrypted: boolean = false,\n): Promise<HybridEncryptedEmail[]> {\n  try {\n    const { encryptionKey, params, enc } = await encryptEmailBody(email, isSubjectEncrypted);\n\n    const encryptedEmails: HybridEncryptedEmail[] = [];\n    for (const recipient of recipients) {\n      const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient.publicKeys, senderPrivateKey);\n      encryptedEmails.push({\n        enc,\n        encryptedKey,\n        recipientEmail: recipient.email,\n        params,\n        isSubjectEncrypted,\n        id: email.id,\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 encryptedEmail - The encrypted email.\n * @param senderPublicKeys - The public key of the sender.\n * @param recipientPrivateKeys - The private key of the recipient.\n * @returns The decrypted email\n */\nexport async function decryptEmailHybrid(\n  encryptedEmail: HybridEncryptedEmail,\n  senderPublicKeys: PublicKeys,\n  recipientPrivateKeys: PrivateKeys,\n): Promise<Email> {\n  try {\n    const { isSubjectEncrypted, params: encParams, enc, encryptedKey, id } = encryptedEmail;\n    const encryptionKey = await decryptKeysHybrid(encryptedKey, senderPublicKeys, recipientPrivateKeys);\n    const { body, params } = await decryptEmailBody(enc, encParams, encryptionKey, isSubjectEncrypted);\n    return { body, params, id };\n  } catch (error) {\n    throw new Error('Failed to decrypt email with hybrid encryption', { cause: error });\n  }\n}\n","import { PwdProtectedEmail, Email } 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 isSubjectEncrypted -  Indicates if the email subject field should be encrypted\n * @returns The password-protected email\n */\nexport async function createPwdProtectedEmail(\n  email: Email,\n  password: string,\n  isSubjectEncrypted: boolean = false,\n): Promise<PwdProtectedEmail> {\n  try {\n    if (!email?.body || !email.params) {\n      throw new Error('Failed to password-protect email: Invalid email structure');\n    }\n    const { encryptionKey, params, enc } = await encryptEmailBody(email, isSubjectEncrypted);\n    const encryptedKey = await passwordProtectKey(encryptionKey, password);\n\n    return { enc, encryptedKey, params, id: email.id, isSubjectEncrypted };\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 * @returns The decrypted email\n */\nexport async function decryptPwdProtectedEmail(encryptedEmail: PwdProtectedEmail, password: string): Promise<Email> {\n  try {\n    const { isSubjectEncrypted, params: encParams, enc, id } = encryptedEmail;\n    const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);\n    const { body, params } = await decryptEmailBody(enc, encParams, encryptionKey, isSubjectEncrypted);\n    return { body, params, id };\n  } catch (error) {\n    throw new Error('Failed to decrypt password-protect email', { cause: error });\n  }\n}\n","import { generateEccKeys } from '../asymmetric-crypto';\nimport { generateKyberKeys } from '../post-quantum-crypto';\nimport { EmailKeys } from '../types';\n\n/**\n * Generates public and private keys for email service.\n *\n * @returns The user's private and public keys\n */\nexport async function generateEmailKeys(): Promise<EmailKeys> {\n  try {\n    const kyberKeys = generateKyberKeys();\n    const keys = await generateEccKeys();\n\n    const emailKeys: EmailKeys = {\n      publicKeys: {\n        eccPublicKey: keys.publicKey,\n        kyberPublicKey: kyberKeys.publicKey,\n      },\n      privateKeys: {\n        eccPrivateKey: keys.privateKey,\n        kyberPrivateKey: kyberKeys.secretKey,\n      },\n    };\n\n    return emailKeys;\n  } catch (error) {\n    throw new Error('Failed to generate keys for email service', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AASA,eAAsB,kBAAkB,KAAqC;AAC3E,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UAAU,YAAY,KAAqB,wBAAwB,OAAO,CACnG,WACA,YACD,CAAC;UACK,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWtE,eAAsB,kBAAkB,WAAuB,aAA6C;AAC1G,KAAI;AACF,MAAI,UAAU,WAAW,YAAY,OACnC,OAAM,IAAI,MAAM,iCAAiC;AAGnD,SAAO,MAAM,kBADD,MAAM,wCAAwC,WAAW,aAAa,iBAAiB,CAChE;UAC5B,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWtE,eAAsB,UAAU,cAA0B,aAA4C;AACpG,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,YACA,cACA,aACA,wBACA,eACA,OACA,CAAC,WAAW,UAAU,CACvB;UACM,OAAO;AACd,QAAM,IAAI,MAAM,wBAAwB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW7D,eAAsB,QAAQ,eAA0B,aAA6C;AACnG,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,QAAQ,YAAY,eAAe,aAAa,uBAAuB;AAC1G,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,sBAAsB,EAAE,OAAO,OAAO,CAAC;;;;;;ACtE3D,SAAgB,YAAY,MAAwB;AAClD,KAAI;AAEF,SAAO,YADM,KAAK,UAAU,KAAK,CACT;UACjB,OAAO;AACd,QAAM,IAAI,MAAM,mCAAmC,EAAE,OAAO,OAAO,CAAC;;;AAIxE,SAAgB,kBAAkB,YAAgC;AAChE,KAAI;AAEF,SAAO,YAAY,GADL,WAAW,KAAK,SAAS,YAAY,KAAK,CAAC,CAC7B;UACrB,OAAO;AACd,QAAM,IAAI,MAAM,yCAAyC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU9E,SAAgB,cAAc,OAA0B;AACtD,KAAI;AAEF,SAAO,YADM,KAAK,UAAU,MAAM,CACV;UACjB,OAAO;AACd,QAAM,IAAI,MAAM,6CAA6C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;ACrBlF,SAAgB,OAAO,QAA+B,oBAAyC;AAC7F,KAAI;EACF,MAAM,EAAE,SAAS,gBAAgB,QAAQ,WAAW,eAAe;EACnE,MAAM,aAAa,iBAAiB,YAAY,eAAe,GAAG,IAAI,YAAY;EAClF,MAAM,cAAc,YAAY,OAAO;EACvC,MAAM,iBAAiB,YAAY,UAAU;EAC7C,MAAM,kBAAkB,aAAa,kBAAkB,WAAW,GAAG,IAAI,YAAY;AAErF,MAAI,mBACF,QAAO,YAAY,YAAY,aAAa,gBAAgB,gBAAgB;MAG5E,QAAO,YADc,YAAY,QAAQ,EACR,YAAY,aAAa,gBAAgB,gBAAgB;UAErF,OAAO;AACd,QAAM,IAAI,MAAM,wBAAwB,EAAE,OAAO,OAAO,CAAC;;;;;;ACT7D,eAAsB,iBACpB,OACA,oBAKC;AACD,KAAI;EACF,MAAM,MAAM,OAAO,MAAM,QAAQ,mBAAmB;EAEpD,IAAI;EACJ,IAAI;EACJ,IAAI,SAAS,MAAM;AAEnB,MAAI,oBAAoB;GACtB,MAAM,SAAS,MAAM,2CAA2C,MAAM,MAAM,MAAM,OAAO,SAAS,KAAK,MAAM,GAAG;AAChH,SAAM,OAAO;AACb,mBAAgB,OAAO;AACvB,YAAS;IAAE,GAAG,MAAM;IAAQ,SAAS,OAAO;IAAY;SACnD;GACL,MAAM,SAAS,MAAM,iCAAiC,MAAM,MAAM,KAAK,MAAM,GAAG;AAChF,SAAM,OAAO;AACb,mBAAgB,OAAO;;AAGzB,SAAO;GAAE;GAAe;GAAK;GAAQ;UAC9B,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC;;;AAIrE,eAAsB,iBACpB,KACA,WACA,eACA,oBAIC;AACD,KAAI;EACF,MAAM,MAAM,OAAO,WAAW,mBAAmB;EACjD,IAAI;EACJ,IAAI,SAAS;AACb,MAAI,oBAAoB;GACtB,MAAM,SAAS,MAAM,oCAAoC,eAAe,KAAK,UAAU,SAAS,IAAI;AACpG,UAAO,OAAO;AACd,YAAS;IAAE,GAAG;IAAW,SAAS,OAAO;IAAS;QAElD,QAAO,MAAM,0BAA0B,eAAe,KAAK,IAAI;AAGjE,SAAO;GAAE;GAAM;GAAQ;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYrE,eAAsB,iCACpB,OACA,KACA,SACgE;AAChE,KAAI;AACF,MAAI,CAAC,MAAM,KACT,OAAM,IAAI,MAAM,gBAAgB;EAElC,MAAM,gBAAgB,MAAM,uBAAuB;AAEnD,SAAO;GAAE,KADG,MAAM,wCAAwC,OAAO,eAAe,KAAK,QAAQ;GAC/E;GAAe;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,yCAAyC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;AAa9E,eAAsB,2CACpB,OACA,SACA,KACA,SACoF;AACpF,KAAI;AACF,MAAI,CAAC,WAAW,CAAC,MAAM,KACrB,OAAM,IAAI,MAAM,gBAAgB;EAElC,MAAM,gBAAgB,MAAM,uBAAuB;AAKnD,SAAO;GAAE,KAJG,MAAM,wCAAwC,OAAO,eAAe,KAAK,QAAQ;GAI/E,YADK,mBADA,MAAM,qBAAqB,eAD1B,YAAY,QAAQ,EACkC,IAAI,CAC7B;GACvB;GAAe;UAClC,OAAO;AACd,QAAM,IAAI,MAAM,qDAAqD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW1F,eAAsB,oCACpB,eACA,KACA,YACA,KAC+C;AAC/C,KAAI;EAEF,MAAM,eAAe,MAAM,qBAAqB,eADlC,mBAAmB,WAAW,EAC0B,IAAI;AAG1E,SAAO;GAAE,MAFI,MAAM,0BAA0B,eAAe,KAAK,IAAI;GAEtD,SADC,YAAY,aAAa;GACjB;UACjB,OAAO;AACd,QAAM,IAAI,MAAM,qDAAqD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU1F,eAAsB,wCACpB,WACA,eACA,KACA,SAC6B;AAC7B,KAAI;EACF,MAAM,YAAY,YAAY,QAAQ;EAItC,MAAM,SAA6B,EAAE,SADrB,mBADM,MAAM,qBAAqB,eADpC,YAAY,UAAU,KAAK,EAC8B,KAAK,UAAU,CACpC,EACH;AAE9C,MAAI,UAAU,YAEZ,QAAO,kBADuB,MAAM,yBAAyB,UAAU,aAAa,eAAe,KAAK,QAAQ,GACjE,IAAI,mBAAmB;AAExE,SAAO;UACA,OAAO;AACd,QAAM,IAAI,MAAM,4DAA4D,EAAE,OAAO,OAAO,CAAC;;;AAIjG,eAAe,yBACb,aACA,eACA,KACA,SACuB;AACvB,KAAI;EACF,MAAM,YAAY,YAAY,QAAQ;AAOtC,SAN6B,MAAM,QAAQ,IACzC,YAAY,KAAK,eAAe;AAE9B,UAAO,qBAAqB,eADH,YAAY,WAAW,EACa,KAAK,UAAU;IAC5E,CACH;UAEM,OAAO;AACd,QAAM,IAAI,MAAM,sDAAsD,EAAE,OAAO,OAAO,CAAC;;;AAI3F,eAAe,yBACb,sBACA,eACA,KACuB;AACvB,KAAI;AAMF,SAL6B,MAAM,QAAQ,IACzC,qBAAqB,KAAK,eAAe;AACvC,UAAO,qBAAqB,eAAe,YAAY,IAAI;IAC3D,CACH;UAEM,OAAO;AACd,QAAM,IAAI,MAAM,sDAAsD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW3F,eAAsB,0BACpB,eACA,KACA,KACoB;AACpB,KAAI;EAIF,MAAM,SAAoB,EAAE,MADf,YADK,MAAM,qBAAqB,eAD9B,mBAAmB,IAAI,QAAQ,EACsB,IAAI,CACrC,EACD;AAElC,MAAI,IAAI,gBAAgB;GACtB,MAAM,kBAAkB,IAAI,gBAAgB,IAAI,mBAAmB;AAEnE,UAAO,eADkB,MAAM,yBAAyB,iBAAiB,eAAe,IAAI,GACrD,KAAK,QAAQ,YAAY,IAAI,CAAC;;AAEvE,SAAO;UACA,OAAO;AACd,QAAM,IAAI,MAAM,yCAAyC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY9E,eAAsB,kBACpB,oBACA,oBACA,kBACuB;AACvB,KAAI;EACF,MAAM,YAAY,MAAM,gBAAgB,mBAAmB,cAAc,iBAAiB,cAAc;EACxG,MAAM,EAAE,YAAY,iBAAiB,cAAc,gBAAgB,iBACjE,mBAAmB,eACpB;AAMD,SAAO;GAAE,cAHkB,mBADN,MAAM,QAAQ,oBADf,MAAM,kBAAkB,WAAW,YAAY,CACA,CACR;GAGhB,iBAFb,mBAAmB,gBAAgB;GAEkB;UAC5E,OAAO;AACd,QAAM,IAAI,MAAM,uDAAuD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY5F,eAAsB,kBACpB,cACA,iBACA,qBACoB;AACpB,KAAI;EACF,MAAM,kBAAkB,mBAAmB,aAAa,gBAAgB;AAMxE,SADsB,MAAM,UAJb,mBAAmB,aAAa,aAAa,EAGxC,MAAM,kBAFR,MAAM,gBAAgB,gBAAgB,cAAc,oBAAoB,cAAc,EACpF,iBAAiB,iBAAiB,oBAAoB,gBAAgB,CACvB,CACT;UAEnD,OAAO;AACd,QAAM,IAAI,MAAM,+DAA+D,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWpG,eAAsB,mBAAmB,oBAA+B,UAA4C;AAClH,KAAI;EACF,MAAM,EAAE,KAAK,SAAS,MAAM,mBAAmB,SAAS;EAExD,MAAM,eAAe,MAAM,QAAQ,oBADf,MAAM,kBAAkB,IAAI,CACmB;EACnE,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,UACoB;AACpB,KAAI;EACF,MAAM,OAAO,mBAAmB,mBAAmB,KAAK;AAKxD,SADsB,MAAM,UAHP,mBAAmB,mBAAmB,aAAa,EAEpD,MAAM,kBADd,MAAM,0BAA0B,UAAU,KAAK,CACX,CACgB;UAEzD,OAAO;AACd,QAAM,IAAI,MAAM,uDAAuD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;;AC7U5F,eAAsB,mBACpB,OACA,WACA,kBACA,qBAA8B,OACC;AAC/B,KAAI;EACF,MAAM,EAAE,eAAe,QAAQ,QAAQ,MAAM,iBAAiB,OAAO,mBAAmB;AAExF,SAAO;GAAE;GAAK,cADO,MAAM,kBAAkB,eAAe,UAAU,YAAY,iBAAiB;GACvE,gBAAgB,UAAU;GAAO;GAAQ;GAAoB,IAAI,MAAM;GAAI;UAChG,OAAO;AACd,QAAM,IAAI,MAAM,kDAAkD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;AAavF,eAAsB,wCACpB,OACA,YACA,kBACA,qBAA8B,OACG;AACjC,KAAI;EACF,MAAM,EAAE,eAAe,QAAQ,QAAQ,MAAM,iBAAiB,OAAO,mBAAmB;EAExF,MAAM,kBAA0C,EAAE;AAClD,OAAK,MAAM,aAAa,YAAY;GAClC,MAAM,eAAe,MAAM,kBAAkB,eAAe,UAAU,YAAY,iBAAiB;AACnG,mBAAgB,KAAK;IACnB;IACA;IACA,gBAAgB,UAAU;IAC1B;IACA;IACA,IAAI,MAAM;IACX,CAAC;;AAEJ,SAAO;UACA,OAAO;AACd,QAAM,IAAI,MAAM,yEAAyE,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY9G,eAAsB,mBACpB,gBACA,kBACA,sBACgB;AAChB,KAAI;EACF,MAAM,EAAE,oBAAoB,QAAQ,WAAW,KAAK,cAAc,OAAO;EAEzE,MAAM,EAAE,MAAM,WAAW,MAAM,iBAAiB,KAAK,WAD/B,MAAM,kBAAkB,cAAc,kBAAkB,qBAAqB,EACpB,mBAAmB;AAClG,SAAO;GAAE;GAAM;GAAQ;GAAI;UACpB,OAAO;AACd,QAAM,IAAI,MAAM,kDAAkD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;ACvEvF,eAAsB,wBACpB,OACA,UACA,qBAA8B,OACF;AAC5B,KAAI;AACF,MAAI,CAAC,OAAO,QAAQ,CAAC,MAAM,OACzB,OAAM,IAAI,MAAM,4DAA4D;EAE9E,MAAM,EAAE,eAAe,QAAQ,QAAQ,MAAM,iBAAiB,OAAO,mBAAmB;AAGxF,SAAO;GAAE;GAAK,cAFO,MAAM,mBAAmB,eAAe,SAAS;GAE1C;GAAQ,IAAI,MAAM;GAAI;GAAoB;UAC/D,OAAO;AACd,QAAM,IAAI,MAAM,oCAAoC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWzE,eAAsB,yBAAyB,gBAAmC,UAAkC;AAClH,KAAI;EACF,MAAM,EAAE,oBAAoB,QAAQ,WAAW,KAAK,OAAO;EAE3D,MAAM,EAAE,MAAM,WAAW,MAAM,iBAAiB,KAAK,WAD/B,MAAM,yBAAyB,eAAe,cAAc,SAAS,EACZ,mBAAmB;AAClG,SAAO;GAAE;GAAM;GAAQ;GAAI;UACpB,OAAO;AACd,QAAM,IAAI,MAAM,4CAA4C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AClCjF,eAAsB,oBAAwC;AAC5D,KAAI;EACF,MAAM,YAAY,mBAAmB;EACrC,MAAM,OAAO,MAAM,iBAAiB;AAapC,SAX6B;GAC3B,YAAY;IACV,cAAc,KAAK;IACnB,gBAAgB,UAAU;IAC3B;GACD,aAAa;IACX,eAAe,KAAK;IACpB,iBAAiB,UAAU;IAC5B;GACF;UAGM,OAAO;AACd,QAAM,IAAI,MAAM,6CAA6C,EAAE,OAAO,OAAO,CAAC"}

package/dist/{utils-DS04iUcX.mjs → genID-3Er5IowC.mjs}

@@ -1,6 +1,5 @@
-import { t as __exportAll } from "./chunk-DWirmd9C.mjs";
-import { n as AES_KEY_BIT_LENGTH } from "./constants-kTeX-2T0.mjs";
-import { o as importPublicKey, r as exportPublicKey } from "./asymmetric-crypto-CyXsV4XT.mjs";
+import { AES_KEY_BIT_LENGTH } from "./constants.mjs";
+import { a as importPublicKey, n as exportPublicKey } from "./keys-BfcaiAOv.mjs";
 import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
 import * as bip39 from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english.js";
@@ -150,24 +149,5 @@ function bytesToUuid(bytes) {
 }
 
 //#endregion
-//#region src/utils/index.ts
-var utils_exports = /* @__PURE__ */ __exportAll({
-	UTF8ToUint8: () => UTF8ToUint8,
-	base64ToPublicKey: () => base64ToPublicKey,
-	base64ToUint8Array: () => base64ToUint8Array,
-	bytesToMnemonic: () => bytesToMnemonic,
-	bytesToUuid: () => bytesToUuid,
-	genMnemonic: () => genMnemonic,
-	generateUuid: () => generateUuid,
-	hexToUint8Array: () => hexToUint8Array,
-	mnemonicToBytes: () => mnemonicToBytes,
-	publicKeyToBase64: () => publicKeyToBase64,
-	uint8ArrayToBase64: () => uint8ArrayToBase64,
-	uint8ArrayToHex: () => uint8ArrayToHex,
-	uint8ToUTF8: () => uint8ToUTF8,
-	uuidToBytes: () => uuidToBytes
-});
-
-//#endregion
-export { bytesToMnemonic as a, base64ToPublicKey as c, base64ToUint8Array as d, hexToUint8Array as f, uint8ToUTF8 as h, uuidToBytes as i, publicKeyToBase64 as l, uint8ArrayToHex as m, bytesToUuid as n, genMnemonic as o, uint8ArrayToBase64 as p, generateUuid as r, mnemonicToBytes as s, utils_exports as t, UTF8ToUint8 as u };
-//# sourceMappingURL=utils-DS04iUcX.mjs.map
+export { genMnemonic as a, publicKeyToBase64 as c, hexToUint8Array as d, uint8ArrayToBase64 as f, bytesToMnemonic as i, UTF8ToUint8 as l, uint8ToUTF8 as m, generateUuid as n, mnemonicToBytes as o, uint8ArrayToHex as p, uuidToBytes as r, base64ToPublicKey as s, bytesToUuid as t, base64ToUint8Array as u };
+//# sourceMappingURL=genID-3Er5IowC.mjs.map

package/dist/genID-3Er5IowC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"genID-3Er5IowC.mjs","names":["uuidv4"],"sources":["../src/utils/converters.ts","../src/utils/keyConverters.ts","../src/utils/genMnemonic.ts","../src/utils/genID.ts"],"sourcesContent":["import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';\n\n/**\n * Converts a Uint8Array into a hexadecimal string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The hexadecimal string representation of the array.\n */\nexport function uint8ArrayToHex(array: Uint8Array): string {\n  return bytesToHex(array);\n}\n\n/**\n * Converts a UTF-8 string into a Uint8Array.\n *\n * @param str - The UTF-8 string to convert.\n * @returns A Uint8Array created from the UTF-8 string.\n */\nexport function UTF8ToUint8(str: string): Uint8Array {\n  return new TextEncoder().encode(str);\n}\n\n/**\n * Converts an Uint8Array into a UTF-8 string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The UTF-8 string representation of the array.\n */\nexport function uint8ToUTF8(array: Uint8Array): string {\n  return new TextDecoder().decode(array);\n}\n\n/**\n * Converts a hexadecimal string into a Uint8Array.\n *\n * @param hex - The hexadecimal string to convert.\n * @returns A Uint8Array created from the hex string.\n */\nexport function hexToUint8Array(hex: string): Uint8Array {\n  return hexToBytes(hex);\n}\n\n/**\n * Converts a Uint8Array into a base64 string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The base64 string representation of the array.\n */\nexport function uint8ArrayToBase64(buffer: Uint8Array): string {\n  const array = Uint16Array.from(buffer);\n  const binaryString = new TextDecoder('UTF-16').decode(array);\n  return btoa(binaryString);\n}\n\n/**\n * Converts a base64 string into a Uint8Array.\n *\n * @param str - The base64 string to convert.\n * @returns A Uint8Array created from the base64 string.\n */\nexport function base64ToUint8Array(str: string): Uint8Array {\n  const binaryString = atob(str);\n  const len = binaryString.length;\n  const array = new Uint8Array(len);\n  for (let i = 0; i < len; i++) {\n    array[i] = binaryString.codePointAt(i)!;\n  }\n  return new Uint8Array(array.buffer);\n}\n","import { uint8ArrayToBase64, base64ToUint8Array } from '.';\nimport { PublicKeys, PublicKeysBase64 } from '../types';\nimport { exportPublicKey, importPublicKey } from '../asymmetric-crypto';\n\n/**\n * Converts a base64 string into PublicKeys type.\n *\n * @param base64 - The base64 representation of the public key.\n * @returns The resulting PublicKeys.\n */\nexport async function base64ToPublicKey(base64: PublicKeysBase64): Promise<PublicKeys> {\n  try {\n    const eccPublicKeyBytes = base64ToUint8Array(base64.eccPublicKeyBase64);\n    const eccPublicKey = await importPublicKey(eccPublicKeyBytes);\n    const kyberPublicKey = base64ToUint8Array(base64.kyberPublicKeyBase64);\n    return {\n      eccPublicKey: eccPublicKey,\n      kyberPublicKey: kyberPublicKey,\n    };\n  } catch (error) {\n    throw new Error('Failed to convert base64 to PublicKeys', { cause: error });\n  }\n}\n\n/**\n * Converts a PublicKeys type into PublicKeysBase64.\n *\n * @param key - The PublicKeys key.\n * @returns The resulting PublicKeysBase64.\n */\nexport async function publicKeyToBase64(key: PublicKeys): Promise<PublicKeysBase64> {\n  try {\n    const eccPublicKeyArray = await exportPublicKey(key.eccPublicKey);\n    const keys = {\n      eccPublicKeyBase64: uint8ArrayToBase64(eccPublicKeyArray),\n      kyberPublicKeyBase64: uint8ArrayToBase64(key.kyberPublicKey),\n    };\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to convert key of the type PublicKeys to PublicKeysBase64', { cause: error });\n  }\n}\n","import * as bip39 from '@scure/bip39';\nimport { wordlist } from '@scure/bip39/wordlists/english.js';\nimport { AES_KEY_BIT_LENGTH } from '../constants';\n/**\n * Generates a mnemonic\n *\n * @returns The generated mnemonic.\n */\nexport function genMnemonic(): string {\n  return bip39.generateMnemonic(wordlist, AES_KEY_BIT_LENGTH);\n}\n\n/**\n * Converts a mnemonic to Uint8Array\n *\n * @param mnemonic - The mnemonic to convert\n * @returns The mnemonic as Uint8Array\n */\nexport function mnemonicToBytes(mnemonic: string): Uint8Array {\n  return bip39.mnemonicToEntropy(mnemonic, wordlist);\n}\n\n/**\n * Converts a Uint8Array to a mnemonic\n *\n * @param bytes - The bytes to convert\n * @returns The mnemonic string\n */\nexport function bytesToMnemonic(bytes: Uint8Array): string {\n  return bip39.entropyToMnemonic(bytes, wordlist);\n}\n","import { v4 as uuidv4, parse, stringify } from 'uuid';\n/**\n * Creates a random identifier.\n *\n * @returns The resulting auxilary string\n */\nexport function generateUuid(): string {\n  return uuidv4();\n}\n\nexport function uuidToBytes(uuid: string): Uint8Array {\n  return parse(uuid);\n}\n\nexport function bytesToUuid(bytes: Uint8Array): string {\n  return stringify(bytes);\n}\n"],"mappings":";;;;;;;;;;;;;;AAQA,SAAgB,gBAAgB,OAA2B;AACzD,QAAO,WAAW,MAAM;;;;;;;;AAS1B,SAAgB,YAAY,KAAyB;AACnD,QAAO,IAAI,aAAa,CAAC,OAAO,IAAI;;;;;;;;AAStC,SAAgB,YAAY,OAA2B;AACrD,QAAO,IAAI,aAAa,CAAC,OAAO,MAAM;;;;;;;;AASxC,SAAgB,gBAAgB,KAAyB;AACvD,QAAO,WAAW,IAAI;;;;;;;;AASxB,SAAgB,mBAAmB,QAA4B;CAC7D,MAAM,QAAQ,YAAY,KAAK,OAAO;CACtC,MAAM,eAAe,IAAI,YAAY,SAAS,CAAC,OAAO,MAAM;AAC5D,QAAO,KAAK,aAAa;;;;;;;;AAS3B,SAAgB,mBAAmB,KAAyB;CAC1D,MAAM,eAAe,KAAK,IAAI;CAC9B,MAAM,MAAM,aAAa;CACzB,MAAM,QAAQ,IAAI,WAAW,IAAI;AACjC,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,IACvB,OAAM,KAAK,aAAa,YAAY,EAAE;AAExC,QAAO,IAAI,WAAW,MAAM,OAAO;;;;;;;;;;;ACzDrC,eAAsB,kBAAkB,QAA+C;AACrF,KAAI;AAIF,SAAO;GACL,cAHmB,MAAM,gBADD,mBAAmB,OAAO,mBAAmB,CACV;GAI3D,gBAHqB,mBAAmB,OAAO,qBAAqB;GAIrE;UACM,OAAO;AACd,QAAM,IAAI,MAAM,0CAA0C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU/E,eAAsB,kBAAkB,KAA4C;AAClF,KAAI;AAMF,SAJa;GACX,oBAAoB,mBAFI,MAAM,gBAAgB,IAAI,aAAa,CAEN;GACzD,sBAAsB,mBAAmB,IAAI,eAAe;GAC7D;UAEM,OAAO;AACd,QAAM,IAAI,MAAM,oEAAoE,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AC/BzG,SAAgB,cAAsB;AACpC,QAAO,MAAM,iBAAiB,UAAU,mBAAmB;;;;;;;;AAS7D,SAAgB,gBAAgB,UAA8B;AAC5D,QAAO,MAAM,kBAAkB,UAAU,SAAS;;;;;;;;AASpD,SAAgB,gBAAgB,OAA2B;AACzD,QAAO,MAAM,kBAAkB,OAAO,SAAS;;;;;;;;;;ACvBjD,SAAgB,eAAuB;AACrC,QAAOA,IAAQ;;AAGjB,SAAgB,YAAY,MAA0B;AACpD,QAAO,MAAM,KAAK;;AAGpB,SAAgB,YAAY,OAA2B;AACrD,QAAO,UAAU,MAAM"}

package/dist/{utils-CNs3cyDj.js → genID-YJSl3YhL.js}

@@ -1,6 +1,6 @@
-const require_chunk = require('./chunk-Dt-PWiN7.js');
-const require_constants = require('./constants-Ccp21E03.js');
-const require_asymmetric_crypto = require('./asymmetric-crypto-BORmLhnx.js');
+const require_chunk = require('./chunk-EbLFQX5m.js');
+const require_constants = require('./constants.js');
+const require_keys = require('./keys-CinT7kEY.js');
 let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
 let _scure_bip39 = require("@scure/bip39");
 _scure_bip39 = require_chunk.__toESM(_scure_bip39);
@@ -80,7 +80,7 @@ function base64ToUint8Array(str) {
 async function base64ToPublicKey(base64) {
 	try {
 		return {
-			eccPublicKey: await require_asymmetric_crypto.importPublicKey(base64ToUint8Array(base64.eccPublicKeyBase64)),
+			eccPublicKey: await require_keys.importPublicKey(base64ToUint8Array(base64.eccPublicKeyBase64)),
 			kyberPublicKey: base64ToUint8Array(base64.kyberPublicKeyBase64)
 		};
 	} catch (error) {
@@ -96,7 +96,7 @@ async function base64ToPublicKey(base64) {
 async function publicKeyToBase64(key) {
 	try {
 		return {
-			eccPublicKeyBase64: uint8ArrayToBase64(await require_asymmetric_crypto.exportPublicKey(key.eccPublicKey)),
+			eccPublicKeyBase64: uint8ArrayToBase64(await require_keys.exportPublicKey(key.eccPublicKey)),
 			kyberPublicKeyBase64: uint8ArrayToBase64(key.kyberPublicKey)
 		};
 	} catch (error) {
@@ -150,25 +150,6 @@ function bytesToUuid(bytes) {
 	return (0, uuid.stringify)(bytes);
 }
 
-//#endregion
-//#region src/utils/index.ts
-var utils_exports = /* @__PURE__ */ require_chunk.__exportAll({
-	UTF8ToUint8: () => UTF8ToUint8,
-	base64ToPublicKey: () => base64ToPublicKey,
-	base64ToUint8Array: () => base64ToUint8Array,
-	bytesToMnemonic: () => bytesToMnemonic,
-	bytesToUuid: () => bytesToUuid,
-	genMnemonic: () => genMnemonic,
-	generateUuid: () => generateUuid,
-	hexToUint8Array: () => hexToUint8Array,
-	mnemonicToBytes: () => mnemonicToBytes,
-	publicKeyToBase64: () => publicKeyToBase64,
-	uint8ArrayToBase64: () => uint8ArrayToBase64,
-	uint8ArrayToHex: () => uint8ArrayToHex,
-	uint8ToUTF8: () => uint8ToUTF8,
-	uuidToBytes: () => uuidToBytes
-});
-
 //#endregion
 Object.defineProperty(exports, 'UTF8ToUint8', {
   enumerable: true,
@@ -248,16 +229,10 @@ Object.defineProperty(exports, 'uint8ToUTF8', {
     return uint8ToUTF8;
   }
 });
-Object.defineProperty(exports, 'utils_exports', {
-  enumerable: true,
-  get: function () {
-    return utils_exports;
-  }
-});
 Object.defineProperty(exports, 'uuidToBytes', {
   enumerable: true,
   get: function () {
     return uuidToBytes;
   }
 });
-//# sourceMappingURL=utils-CNs3cyDj.js.map
+//# sourceMappingURL=genID-YJSl3YhL.js.map