internxt-crypto 0.0.11 → 0.0.14

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

@@ -1,37 +1,24 @@
-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 { CONTEXT_WRAPPING } 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 { n as encryptSymmetrically, o as genSymmetricKey, t as decryptSymmetrically } from "./aes-DCb9dJqb.mjs";
+import { n as getKeyFromPasswordAndSalt, t as getKeyFromPassword, u as deriveSymmetricKeyFromTwoKeysAndContext } from "./deriveKeysFromPassword-XIwzErlL.mjs";
+import { n as encapsulateKyber, r as generateKyberKeys, t as decapsulateKyber } from "./kyber768-SXnIo-Nw.mjs";
 import { concatBytes } from "@noble/hashes/utils.js";
+import { aeskw } from "@noble/ciphers/aes.js";
 
 //#region src/key-wrapper/aesWrapper.ts
 /**
-* Converts wrapping key in Uint8Array into CryptoKey
-*
-* @param key - The wrapping key in Uint8Array representation
-* @returns The resulting CryptoKey
-*/
-async function importWrappingKey(key) {
-	try {
-		return await crypto.subtle.importKey(KEY_FORMAT, key, KEY_WRAPPING_ALGORITHM, false, ["wrapKey", "unwrapKey"]);
-	} catch (error) {
-		throw new Error("Failed to import wrapping key", { cause: error });
-	}
-}
-/**
 * Derives wrapping key from two secrets
 *
 * @param eccSecret - The secret exchanged via elliptic curves
 * @param kyberSecret - The secret exchanged via Kyber KEM
-* @returns The resulting wrapping CryptoKey
+* @returns The resulting wrapping key
 */
 async function deriveWrappingKey(eccSecret, kyberSecret) {
 	try {
 		if (eccSecret.length !== kyberSecret.length) throw new Error("secrets must have equal length");
-		return await importWrappingKey(await deriveSymmetricKeyFromTwoKeysAndContext(eccSecret, kyberSecret, CONTEXT_WRAPPING));
+		return deriveSymmetricKeyFromTwoKeysAndContext(eccSecret, kyberSecret, CONTEXT_WRAPPING);
 	} catch (error) {
 		throw new Error("Failed to derive wrapping key", { cause: error });
 	}
@@ -39,42 +26,24 @@ async function deriveWrappingKey(eccSecret, kyberSecret) {
 /**
 * Unwraps the given wrapped key
 *
-* @param encryptedKey - The encrypted key
-* @param wrappingKey - The secret key used for decryption
-* @returns The resulting wrapping CryptoKey
+* @param encryptedKey - The wrapped key
+* @param wrappingKey - The secret key used for unwrapping
+* @returns The resulting key
 */
 async function unwrapKey(encryptedKey, wrappingKey) {
-	try {
-		return await crypto.subtle.unwrapKey(KEY_FORMAT, encryptedKey, wrappingKey, KEY_WRAPPING_ALGORITHM, AES_ALGORITHM, false, ["encrypt", "decrypt"]);
-	} catch (error) {
-		throw new Error("Failed to unwrap key", { cause: error });
-	}
+	return aeskw(wrappingKey).decrypt(encryptedKey);
 }
 /**
-* Wraps the given CryptoKey
+* Wraps the given key
 *
-* @param encryptionKey - The CryptoKey to be wrapped
+* @param key - The key to be wrapped
 * @param wrappingKey - The secret key used for wrapping
 * @returns The resulting ciphertext
 */
-async function wrapKey(encryptionKey, wrappingKey) {
-	try {
-		const result = await crypto.subtle.wrapKey(KEY_FORMAT, encryptionKey, wrappingKey, KEY_WRAPPING_ALGORITHM);
-		return new Uint8Array(result);
-	} catch (error) {
-		throw new Error("Failed to wrap key", { cause: error });
-	}
+async function wrapKey(key, wrappingKey) {
+	return aeskw(wrappingKey).encrypt(key);
 }
 
-//#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) {
@@ -190,7 +159,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 genSymmetricCryptoKey();
+		const encryptionKey = genSymmetricKey();
 		return {
 			enc: await encryptEmailContentSymmetricallyWithKey(email, encryptionKey, aux, emailID),
 			encryptionKey
@@ -211,7 +180,7 @@ 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 genSymmetricCryptoKey();
+		const encryptionKey = genSymmetricKey();
 		return {
 			enc: await encryptEmailContentSymmetricallyWithKey(email, encryptionKey, aux, emailID),
 			encSubject: uint8ArrayToBase64(await encryptSymmetrically(encryptionKey, UTF8ToUint8(subject), aux)),
@@ -225,7 +194,7 @@ async function encryptEmailContentAndSubjectSymmetrically(email, subject, aux, e
 * Decrypts symmetrically encrypted email.
 *
 * @param encryptedEmail - The email to decrypt.
-* @param encryptionKey - The symmetric CryptoKey.
+* @param encryptionKey - The symmetric key.
 * @returns The decrypted email
 */
 async function decryptEmailAndSubjectSymmetrically(encryptionKey, aux, encSubject, enc) {
@@ -278,7 +247,7 @@ async function decryptEmailAttachements(encryptedAttachments, encryptionKey, aux
 * Decrypts symmetrically encrypted email.
 *
 * @param encryptedEmail - The email to decrypt.
-* @param encryptionKey - The symmetric CryptoKey.
+* @param encryptionKey - The symmetric key.
 * @returns The decrypted email
 */
 async function decryptEmailSymmetrically(encryptionKey, aux, enc) {
@@ -296,7 +265,7 @@ async function decryptEmailSymmetrically(encryptionKey, aux, enc) {
 /**
 * Encrypts the email symmetric key using hybrid encryption.
 *
-* @param emailEncryptionKey - The symmetric CryptoKey used for email encryption.
+* @param emailEncryptionKey - The symmetric key used for email encryption.
 * @param recipientPublicKey - The public key of the recipient.
 * @param senderPrivateKey - The private key of the sender.
 * @returns The encrypted email symmetric key
@@ -319,7 +288,7 @@ async function encryptKeysHybrid(emailEncryptionKey, recipientPublicKey, senderP
 * @param encryptedKey - The encrypted email key.
 * @param senderPublicKey - The public key of the sender.
 * @param recipientPrivateKey - The private key of the recipient.
-* @returns The email encryption CryptoKey
+* @returns The email encryption key
 */
 async function decryptKeysHybrid(encryptedKey, senderPublicKey, recipientPrivateKey) {
 	try {
@@ -332,14 +301,14 @@ async function decryptKeysHybrid(encryptedKey, senderPublicKey, recipientPrivate
 /**
 * Password-protects the email symmetric key.
 *
-* @param emailEncryptionKey - The symmetric CryptoKey used for email encryption.
+* @param emailEncryptionKey - The symmetric key used for email encryption.
 * @param password - The secret password for key protection.
 * @returns The password-protected email symmetric key
 */
 async function passwordProtectKey(emailEncryptionKey, password) {
 	try {
 		const { key, salt } = await getKeyFromPassword(password);
-		const encryptedKey = await wrapKey(emailEncryptionKey, await importWrappingKey(key));
+		const encryptedKey = await wrapKey(emailEncryptionKey, key);
 		const saltStr = uint8ArrayToBase64(salt);
 		return {
 			encryptedKey: uint8ArrayToBase64(encryptedKey),
@@ -354,12 +323,12 @@ async function passwordProtectKey(emailEncryptionKey, password) {
 *
 * @param emailEncryptionKey -  The password-protected email key.
 * @param password - The secret password for key protection.
-* @returns The email encryption CryptoKey
+* @returns The email encryption key
 */
 async function removePasswordProtection(emailEncryptionKey, password) {
 	try {
 		const salt = base64ToUint8Array(emailEncryptionKey.salt);
-		return await unwrapKey(base64ToUint8Array(emailEncryptionKey.encryptedKey), await importWrappingKey(await getKeyFromPasswordAndSalt(password, salt)));
+		return await unwrapKey(base64ToUint8Array(emailEncryptionKey.encryptedKey), await getKeyFromPasswordAndSalt(password, salt));
 	} catch (error) {
 		throw new Error("Failed to remove password-protection from email key", { cause: error });
 	}
@@ -515,20 +484,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-D4lp9NRv.mjs.map

package/dist/emailKeys-D4lp9NRv.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"emailKeys-D4lp9NRv.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 { CONTEXT_WRAPPING } from '../constants';\nimport { deriveSymmetricKeyFromTwoKeysAndContext } from '../derive-key';\nimport { aeskw } from '@noble/ciphers/aes.js';\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 key\n */\nexport async function deriveWrappingKey(eccSecret: Uint8Array, kyberSecret: Uint8Array): Promise<Uint8Array> {\n  try {\n    if (eccSecret.length !== kyberSecret.length) {\n      throw new Error('secrets must have equal length');\n    }\n    return deriveSymmetricKeyFromTwoKeysAndContext(eccSecret, kyberSecret, CONTEXT_WRAPPING);\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 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 { 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 { encryptSymmetrically, decryptSymmetrically, genSymmetricKey } from '../symmetric-crypto';\nimport { encapsulateKyber, decapsulateKyber } from '../post-quantum-crypto';\nimport { deriveWrappingKey, wrapKey, unwrapKey } 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: Uint8Array;\n}> {\n  try {\n    const aux = getAux(email.params, isSubjectEncrypted);\n\n    let enc: EmailBodyEncrypted;\n    let encryptionKey: Uint8Array;\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: Uint8Array,\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: Uint8Array }> {\n  try {\n    if (!email.text) {\n      throw new Error('Invalid input');\n    }\n    const encryptionKey = genSymmetricKey();\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: Uint8Array }> {\n  try {\n    if (!subject || !email.text) {\n      throw new Error('Invalid input');\n    }\n    const encryptionKey = genSymmetricKey();\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 key.\n * @returns The decrypted email\n */\nexport async function decryptEmailAndSubjectSymmetrically(\n  encryptionKey: Uint8Array,\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: Uint8Array,\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: Uint8Array,\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: Uint8Array,\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 key.\n * @returns The decrypted email\n */\nexport async function decryptEmailSymmetrically(\n  encryptionKey: Uint8Array,\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 key 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: Uint8Array,\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 key\n */\nexport async function decryptKeysHybrid(\n  encryptedKey: HybridEncKey,\n  senderPublicKey: PublicKeys,\n  recipientPrivateKey: PrivateKeys,\n): Promise<Uint8Array> {\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 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 { 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/{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

package/dist/genID-YJSl3YhL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"genID-YJSl3YhL.js","names":["importPublicKey","exportPublicKey","bip39","wordlist","AES_KEY_BIT_LENGTH","uuid"],"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,+CAAkB,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,+CAAkB,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,MAAMA,6BADD,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,MAAMC,6BAAgB,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,QAAOC,aAAM,iBAAiBC,4CAAUC,qCAAmB;;;;;;;;AAS7D,SAAgB,gBAAgB,UAA8B;AAC5D,QAAOF,aAAM,kBAAkB,UAAUC,2CAAS;;;;;;;;AASpD,SAAgB,gBAAgB,OAA2B;AACzD,QAAOD,aAAM,kBAAkB,OAAOC,2CAAS;;;;;;;;;;ACvBjD,SAAgB,eAAuB;AACrC,sBAAe;;AAGjB,SAAgB,YAAY,QAA0B;AACpD,wBAAaE,OAAK;;AAGpB,SAAgB,YAAY,OAA2B;AACrD,4BAAiB,MAAM"}

package/dist/hash.d.mts

@@ -57,9 +57,6 @@ declare function getBytesFromDataHex(bytes: number, data: Uint8Array): string;
  * @returns The resulting hash hex string
  */
 declare function computeMac(keyMaterial: Uint8Array, data: Uint8Array[]): string;
-declare namespace index_d_exports {
-  export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex };
-}
 //#endregion
-export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex, index_d_exports as t };
+export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex };
 //# sourceMappingURL=hash.d.mts.map

package/dist/hash.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.mts","names":[],"sources":["../src/hash/blake3.ts","../src/hash/mac.ts"],"mappings":";;AASA;;;;;iBAAgB,aAAA,CAAc,IAAA,EAAM,UAAA,KAAe,UAAA;;;;AAkBnD;;;iBAAgB,gBAAA,CAAiB,IAAA,EAAM,UAAA;AAAA,iBAIvB,uBAAA,CAAwB,OAAA,EAAS,UAAA,EAAY,IAAA,EAAM,UAAA;AAAA,iBASnD,oBAAA,CAAqB,OAAA,EAAS,UAAA,EAAY,IAAA,EAAM,UAAA,KAAe,UAAA;;;;;;;;iBAmB/D,qBAAA,CAAsB,KAAA,UAAe,IAAA,EAAM,UAAA,KAAe,UAAA;;AAnB1E;;;;;;iBAsCgB,wBAAA,CAAyB,KAAA,UAAe,IAAA,EAAM,UAAA;;;;;;;;iBAgB9C,gBAAA,CAAiB,KAAA,UAAe,IAAA,EAAM,UAAA,GAAa,UAAA;AAnCnE;;;;;;;AAAA,iBA8CgB,mBAAA,CAAoB,KAAA,UAAe,IAAA,EAAM,UAAA;;;;AAhGzD;;;;;;iBCEgB,UAAA,CAAW,WAAA,EAAa,UAAA,EAAY,IAAA,EAAM,UAAA"}

package/dist/hash.d.ts

@@ -57,9 +57,6 @@ declare function getBytesFromDataHex(bytes: number, data: Uint8Array): string;
  * @returns The resulting hash hex string
  */
 declare function computeMac(keyMaterial: Uint8Array, data: Uint8Array[]): string;
-declare namespace index_d_exports {
-  export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex };
-}
 //#endregion
-export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex, index_d_exports as t };
+export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex };
 //# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","names":[],"sources":["../src/hash/blake3.ts","../src/hash/mac.ts"],"mappings":";;AASA;;;;;iBAAgB,aAAA,CAAc,IAAA,EAAM,UAAA,KAAe,UAAA;;;;AAkBnD;;;iBAAgB,gBAAA,CAAiB,IAAA,EAAM,UAAA;AAAA,iBAIvB,uBAAA,CAAwB,OAAA,EAAS,UAAA,EAAY,IAAA,EAAM,UAAA;AAAA,iBASnD,oBAAA,CAAqB,OAAA,EAAS,UAAA,EAAY,IAAA,EAAM,UAAA,KAAe,UAAA;;;;;;;;iBAmB/D,qBAAA,CAAsB,KAAA,UAAe,IAAA,EAAM,UAAA,KAAe,UAAA;;AAnB1E;;;;;;iBAsCgB,wBAAA,CAAyB,KAAA,UAAe,IAAA,EAAM,UAAA;;;;;;;;iBAgB9C,gBAAA,CAAiB,KAAA,UAAe,IAAA,EAAM,UAAA,GAAa,UAAA;AAnCnE;;;;;;;AAAA,iBA8CgB,mBAAA,CAAoB,KAAA,UAAe,IAAA,EAAM,UAAA;;;;AAhGzD;;;;;;iBCEgB,UAAA,CAAW,WAAA,EAAa,UAAA,EAAY,IAAA,EAAM,UAAA"}

package/dist/hash.js

@@ -1,11 +1,12 @@
-const require_hash = require('./hash-BoqwNkcd.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_mac = require('./mac-BMb1F0dN.js');
 
-exports.computeMac = require_hash.computeMac;
-exports.getBytesFromData = require_hash.getBytesFromData;
-exports.getBytesFromDataArray = require_hash.getBytesFromDataArray;
-exports.getBytesFromDataArrayHex = require_hash.getBytesFromDataArrayHex;
-exports.getBytesFromDataHex = require_hash.getBytesFromDataHex;
-exports.hashDataArray = require_hash.hashDataArray;
-exports.hashDataArrayHex = require_hash.hashDataArrayHex;
-exports.hashDataArrayWithKey = require_hash.hashDataArrayWithKey;
-exports.hashDataArrayWithKeyHex = require_hash.hashDataArrayWithKeyHex;
+exports.computeMac = require_mac.computeMac;
+exports.getBytesFromData = require_mac.getBytesFromData;
+exports.getBytesFromDataArray = require_mac.getBytesFromDataArray;
+exports.getBytesFromDataArrayHex = require_mac.getBytesFromDataArrayHex;
+exports.getBytesFromDataHex = require_mac.getBytesFromDataHex;
+exports.hashDataArray = require_mac.hashDataArray;
+exports.hashDataArrayHex = require_mac.hashDataArrayHex;
+exports.hashDataArrayWithKey = require_mac.hashDataArrayWithKey;
+exports.hashDataArrayWithKeyHex = require_mac.hashDataArrayWithKeyHex;

package/dist/hash.mjs

@@ -1,3 +1,3 @@
-import { a as getBytesFromDataArrayHex, c as hashDataArrayHex, i as getBytesFromDataArray, l as hashDataArrayWithKey, n as computeMac, o as getBytesFromDataHex, r as getBytesFromData, s as hashDataArray, u as hashDataArrayWithKeyHex } from "./hash-CXeGAwai.mjs";
+import { a as getBytesFromDataHex, c as hashDataArrayWithKey, i as getBytesFromDataArrayHex, l as hashDataArrayWithKeyHex, n as getBytesFromData, o as hashDataArray, r as getBytesFromDataArray, s as hashDataArrayHex, t as computeMac } from "./mac-ZpRlx8Fs.mjs";
 
 export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex };

package/dist/index.d.mts

@@ -1,52 +1,32 @@
-import { t as index_d_exports } from "./asymmetric-crypto.mjs";
-import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, HASH_BIT_LEN, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH } from "./constants.mjs";
-import { t as index_d_exports$1 } from "./derive-key.mjs";
-import { _ as PwdProtectedEmail, a as EmailKeysEncrypted, b as User, c as EncryptedKeystore, d as KeystoreType, f as MailCache, g as PublicKeysBase64, h as PublicKeys, i as EmailKeys, l as HybridEncKey, m as PrivateKeysEncrypted, n as EmailBody, o as EmailPublicParameters, p as PrivateKeys, r as EmailBodyEncrypted, s as EmailSearchResult, t as Email, u as HybridEncryptedEmail, v as PwdProtectedKey, x as UserWithPublicKeys, y as StoredEmail } from "./types-DwQJtrTx.mjs";
-import { t as index_d_exports$2 } from "./email-crypto.mjs";
-import { t as index_d_exports$3 } from "./email-search.mjs";
-import { t as index_d_exports$4 } from "./hash.mjs";
-import { t as index_d_exports$6 } from "./keystore-crypto.mjs";
-import { t as index_d_exports$7 } from "./keystore-service.mjs";
-import { t as index_d_exports$8 } from "./index-MaOov-ag.mjs";
-import { t as index_d_exports$9 } from "./index-D5pBU_A5.mjs";
-import { t as index_d_exports$10 } from "./symmetric-crypto.mjs";
-import { t as index_d_exports$11 } from "./utils.mjs";
+import { deriveSecretKey, exportPrivateKey, exportPublicKey, generateEccKeys, importPrivateKey, importPublicKey } from "./asymmetric-crypto.mjs";
+import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, HASH_BIT_LEN, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, 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 { deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, verifyKeyFromPasswordHex } from "./derive-key.mjs";
+import { Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys } 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 { computeMac, getBytesFromData, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex } from "./hash.mjs";
+import { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore } from "./keystore-crypto.mjs";
+import { decapsulateKyber, encapsulateKyber, generateKyberKeys } from "./post-quantum-crypto.mjs";
+import { decryptSymmetrically, deriveSymmetricCryptoKey, encryptSymmetrically, exportSymmetricCryptoKey, genSymmetricCryptoKey, genSymmetricKey, importSymmetricCryptoKey } from "./symmetric-crypto.mjs";
+import { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes } from "./utils.mjs";
 
 //#region src/key-wrapper/aesWrapper.d.ts
-/**
- * Converts wrapping key in Uint8Array into CryptoKey
- *
- * @param key - The wrapping key in Uint8Array representation
- * @returns The resulting CryptoKey
- */
-declare function importWrappingKey(key: Uint8Array): Promise<CryptoKey>;
-/**
- * Derives wrapping key from two secrets
- *
- * @param eccSecret - The secret exchanged via elliptic curves
- * @param kyberSecret - The secret exchanged via Kyber KEM
- * @returns The resulting wrapping CryptoKey
- */
-declare function deriveWrappingKey(eccSecret: Uint8Array, kyberSecret: Uint8Array): Promise<CryptoKey>;
 /**
  * Unwraps the given wrapped key
  *
- * @param encryptedKey - The encrypted key
- * @param wrappingKey - The secret key used for decryption
- * @returns The resulting wrapping CryptoKey
+ * @param encryptedKey - The wrapped key
+ * @param wrappingKey - The secret key used for unwrapping
+ * @returns The resulting key
  */
-declare function unwrapKey(encryptedKey: Uint8Array, wrappingKey: CryptoKey): Promise<CryptoKey>;
+declare function unwrapKey(encryptedKey: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array>;
 /**
- * Wraps the given CryptoKey
+ * Wraps the given key
  *
- * @param encryptionKey - The CryptoKey to be wrapped
+ * @param key - The key to be wrapped
  * @param wrappingKey - The secret key used for wrapping
  * @returns The resulting ciphertext
  */
-declare function wrapKey(encryptionKey: CryptoKey, wrappingKey: CryptoKey): Promise<Uint8Array>;
-declare namespace index_d_exports$5 {
-  export { deriveWrappingKey, importWrappingKey, unwrapKey, wrapKey };
-}
+declare function wrapKey(key: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array>;
 //#endregion
-export { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HASH_BIT_LEN, HybridEncKey, HybridEncryptedEmail, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys, index_d_exports as asymmetric, index_d_exports$1 as deriveKey, index_d_exports$2 as emailCrypto, index_d_exports$3 as emailSearch, index_d_exports$4 as hash, index_d_exports$5 as keyWrapper, index_d_exports$6 as keystoreCrypto, index_d_exports$7 as keystoreService, index_d_exports$8 as pq, index_d_exports$9 as storage, index_d_exports$10 as symmetric, index_d_exports$11 as utils };
+export { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HASH_BIT_LEN, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, UTF8ToUint8, User, UserWithPublicKeys, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, addEmailToCache, addEmailToSearchIndex, addEmailsToCache, base64ToPublicKey, base64ToUint8Array, buildSearchIndexFromCache, bytesToMnemonic, bytesToUuid, closeDatabase, computeMac, createCacheFromDB, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, deriveSecretKey, deriveSymmetricCryptoKey, deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, encapsulateKyber, encryptAndStoreEmail, encryptAndStoreManyEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, enforceMaxEmailNumber, exportPrivateKey, exportPublicKey, exportSymmetricCryptoKey, genMnemonic, genSymmetricCryptoKey, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getBytesFromData, getBytesFromDataArrayHex, getBytesFromDataHex, getEmailBatch, getEmailCount, getEmailFromCache, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex, hexToUint8Array, importPrivateKey, importPublicKey, importSymmetricCryptoKey, mnemonicToBytes, openDatabase, openEncryptionKeystore, openRecoveryKeystore, publicKeyToBase64, removeEmailFromSearchIndex, searchEmails, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, verifyKeyFromPasswordHex, wrapKey };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

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