internxt-crypto 1.2.0 → 1.3.1

package/dist/derive-password.js

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-iMHv-tIA.js');
-
-exports.generateSalt = require_deriveKeysFromPassword.generateSalt;
-exports.getKeyFromPassword = require_deriveKeysFromPassword.getKeyFromPassword;
-exports.getKeyFromPasswordAndSalt = require_deriveKeysFromPassword.getKeyFromPasswordAndSalt;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_derive_password = require("./derive-password-CbYRDq7V.js");
+exports.generateSalt = require_derive_password.generateSalt;
+exports.getKeyFromPassword = require_derive_password.getKeyFromPassword;
+exports.getKeyFromPasswordAndSalt = require_derive_password.getKeyFromPasswordAndSalt;

package/dist/derive-password.mjs

@@ -1,3 +1,2 @@
-import { n as getKeyFromPassword, r as getKeyFromPasswordAndSalt, t as generateSalt } from "./deriveKeysFromPassword-DFzo2OII.mjs";
-
-export { generateSalt, getKeyFromPassword, getKeyFromPasswordAndSalt };
+import { n as getKeyFromPassword, r as getKeyFromPasswordAndSalt, t as generateSalt } from "./derive-password-PED-YfwE.mjs";
+export { generateSalt, getKeyFromPassword, getKeyFromPasswordAndSalt };

package/dist/{emailKeys-BFI-paQq.js → email-crypto-Cr7znO1a.js}

@@ -1,12 +1,11 @@
-const require_chunk = require('./chunk-EbLFQX5m.js');
-const require_constants = require('./constants.js');
-const require_genID = require('./genID-cWOPmspk.js');
-const require_deriveKeysFromMnemonic = require('./deriveKeysFromMnemonic-Dbx7VSBQ.js');
-const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-iMHv-tIA.js');
-const require_aes = require('./aes-CuW_SPl-.js');
-const require_xwing = require('./xwing-iRWVRtNE.js');
+require("./chunk-C13QxCFV.js");
+const require_constants = require("./constants.js");
+const require_utils = require("./utils.js");
+const require_derive_key = require("./derive-key.js");
+const require_derive_password = require("./derive-password-CbYRDq7V.js");
+const require_symmetric_crypto = require("./symmetric-crypto.js");
+const require_xwing = require("./xwing-7fEqAT7W.js");
 let _noble_ciphers_aes_js = require("@noble/ciphers/aes.js");
-
 //#region src/key-wrapper/aesWrapper.ts
 /**
 * Unwraps the given wrapped key
@@ -28,7 +27,6 @@ async function unwrapKey(encryptedKey, wrappingKey) {
 async function wrapKey(key, wrappingKey) {
 	return (0, _noble_ciphers_aes_js.aeskw)(wrappingKey).encrypt(key);
 }
-
 //#endregion
 //#region src/email-crypto/core.ts
 /**
@@ -41,7 +39,7 @@ async function wrapKey(key, wrappingKey) {
 async function encryptEmailBody(body, aux) {
 	try {
 		if (!body.text || !body.subject) throw new Error("Invalid input");
-		const encryptionKey = require_aes.genSymmetricKey();
+		const encryptionKey = require_symmetric_crypto.genSymmetricKey();
 		return {
 			encEmailBody: await encryptEmailBodyWithKey(body, encryptionKey, aux),
 			encryptionKey
@@ -60,17 +58,17 @@ async function encryptEmailBody(body, aux) {
 */
 async function encryptEmailBodyWithKey(body, encryptionKey, aux) {
 	try {
-		const text = require_genID.UTF8ToUint8(body.text);
-		const subjectEnc = await require_aes.encryptSymmetrically(encryptionKey, require_genID.UTF8ToUint8(body.subject), aux);
+		const text = require_utils.UTF8ToUint8(body.text);
+		const subjectEnc = await require_symmetric_crypto.encryptSymmetrically(encryptionKey, require_utils.UTF8ToUint8(body.subject), aux);
 		const enc = {
-			encText: require_genID.uint8ArrayToBase64(await require_aes.encryptSymmetrically(encryptionKey, text, aux)),
-			encSubject: require_genID.uint8ArrayToBase64(subjectEnc)
+			encText: require_utils.uint8ArrayToBase64(await require_symmetric_crypto.encryptSymmetrically(encryptionKey, text, aux)),
+			encSubject: require_utils.uint8ArrayToBase64(subjectEnc)
 		};
 		if (body.attachments) {
 			const promises = body.attachments.map((attachment) => {
-				return require_aes.encryptSymmetrically(encryptionKey, require_genID.UTF8ToUint8(attachment), aux);
+				return require_symmetric_crypto.encryptSymmetrically(encryptionKey, require_utils.UTF8ToUint8(attachment), aux);
 			});
-			enc.encAttachments = (await Promise.all(promises))?.map(require_genID.uint8ArrayToBase64);
+			enc.encAttachments = (await Promise.all(promises))?.map(require_utils.uint8ArrayToBase64);
 		}
 		return enc;
 	} catch (error) {
@@ -87,14 +85,14 @@ async function encryptEmailBodyWithKey(body, encryptionKey, aux) {
 */
 async function decryptEmailBody(encEmailBody, encryptionKey, aux) {
 	try {
-		const subject = require_genID.uint8ToUTF8(await require_aes.decryptSymmetrically(encryptionKey, require_genID.base64ToUint8Array(encEmailBody.encSubject), aux));
+		const subject = require_utils.uint8ToUTF8(await require_symmetric_crypto.decryptSymmetrically(encryptionKey, require_utils.base64ToUint8Array(encEmailBody.encSubject), aux));
 		const body = {
-			text: require_genID.uint8ToUTF8(await require_aes.decryptSymmetrically(encryptionKey, require_genID.base64ToUint8Array(encEmailBody.encText), aux)),
+			text: require_utils.uint8ToUTF8(await require_symmetric_crypto.decryptSymmetrically(encryptionKey, require_utils.base64ToUint8Array(encEmailBody.encText), aux)),
 			subject
 		};
 		if (encEmailBody.encAttachments) {
-			const promises = (encEmailBody.encAttachments?.map(require_genID.base64ToUint8Array))?.map((encAtt) => require_aes.decryptSymmetrically(encryptionKey, encAtt, aux));
-			body.attachments = (await Promise.all(promises))?.map((att) => require_genID.uint8ToUTF8(att));
+			const promises = (encEmailBody.encAttachments?.map(require_utils.base64ToUint8Array))?.map((encAtt) => require_symmetric_crypto.decryptSymmetrically(encryptionKey, encAtt, aux));
+			body.attachments = (await Promise.all(promises))?.map((att) => require_utils.uint8ToUTF8(att));
 		}
 		return body;
 	} catch (error) {
@@ -112,8 +110,8 @@ async function encryptKeysHybrid(emailEncryptionKey, recipient) {
 	try {
 		const { cipherText, sharedSecret } = require_xwing.encapsulateHybrid(recipient.publicHybridKey);
 		return {
-			encryptedKey: require_genID.uint8ArrayToBase64(await wrapKey(emailEncryptionKey, sharedSecret)),
-			hybridCiphertext: require_genID.uint8ArrayToBase64(cipherText),
+			encryptedKey: require_utils.uint8ArrayToBase64(await wrapKey(emailEncryptionKey, sharedSecret)),
+			hybridCiphertext: require_utils.uint8ArrayToBase64(cipherText),
 			encryptedForEmail: recipient.email
 		};
 	} catch (error) {
@@ -129,8 +127,8 @@ async function encryptKeysHybrid(emailEncryptionKey, recipient) {
 */
 async function decryptKeysHybrid(encryptedKey, recipientPrivateKey) {
 	try {
-		const kyberCiphertext = require_genID.base64ToUint8Array(encryptedKey.hybridCiphertext);
-		return await unwrapKey(require_genID.base64ToUint8Array(encryptedKey.encryptedKey), require_xwing.decapsulateHybrid(kyberCiphertext, recipientPrivateKey));
+		const kyberCiphertext = require_utils.base64ToUint8Array(encryptedKey.hybridCiphertext);
+		return await unwrapKey(require_utils.base64ToUint8Array(encryptedKey.encryptedKey), require_xwing.decapsulateHybrid(kyberCiphertext, recipientPrivateKey));
 	} catch (error) {
 		throw new Error("Failed to decrypt email key encrypted via hybrid encryption", { cause: error });
 	}
@@ -144,11 +142,11 @@ async function decryptKeysHybrid(encryptedKey, recipientPrivateKey) {
 */
 async function passwordProtectKey(emailEncryptionKey, password) {
 	try {
-		const { key, salt } = await require_deriveKeysFromPassword.getKeyFromPassword(password);
+		const { key, salt } = await require_derive_password.getKeyFromPassword(password);
 		const encryptedKey = await wrapKey(emailEncryptionKey, key);
-		const saltStr = require_genID.uint8ArrayToBase64(salt);
+		const saltStr = require_utils.uint8ArrayToBase64(salt);
 		return {
-			encryptedKey: require_genID.uint8ArrayToBase64(encryptedKey),
+			encryptedKey: require_utils.uint8ArrayToBase64(encryptedKey),
 			salt: saltStr
 		};
 	} catch (error) {
@@ -164,13 +162,12 @@ async function passwordProtectKey(emailEncryptionKey, password) {
 */
 async function removePasswordProtection(emailEncryptionKey, password) {
 	try {
-		const salt = require_genID.base64ToUint8Array(emailEncryptionKey.salt);
-		return await unwrapKey(require_genID.base64ToUint8Array(emailEncryptionKey.encryptedKey), await require_deriveKeysFromPassword.getKeyFromPasswordAndSalt(password, salt));
+		const salt = require_utils.base64ToUint8Array(emailEncryptionKey.salt);
+		return await unwrapKey(require_utils.base64ToUint8Array(emailEncryptionKey.encryptedKey), await require_derive_password.getKeyFromPasswordAndSalt(password, salt));
 	} catch (error) {
 		throw new Error("Failed to remove password-protection from email key", { cause: error });
 	}
 }
-
 //#endregion
 //#region src/email-crypto/hybridEncyptedEmail.ts
 /**
@@ -232,7 +229,6 @@ async function decryptEmailHybrid(encEmailBody, recipientPrivateHybridKeys, aux)
 		throw new Error("Failed to decrypt email with hybrid encryption", { cause: error });
 	}
 }
-
 //#endregion
 //#region src/email-crypto/pwdProtectedEmail.ts
 /**
@@ -270,7 +266,6 @@ async function decryptPwdProtectedEmail(encryptedEmail, password, aux) {
 		throw new Error("Failed to decrypt password-protect email", { cause: error });
 	}
 }
-
 //#endregion
 //#region src/email-crypto/emailKeys.ts
 /**
@@ -288,7 +283,7 @@ async function generateEmailKeys() {
 * @returns The symmetric key for protecting database
 */
 const deriveDatabaseKey = async (mnemonic) => {
-	return require_deriveKeysFromMnemonic.deriveKeyFromMnemonic(mnemonic, require_constants.CONTEXT_DATABASE);
+	return require_derive_key.deriveKeyFromMnemonic(mnemonic, require_constants.CONTEXT_DATABASE);
 };
 /**
 * Derives email draft encryption key for the given user
@@ -297,110 +292,110 @@ const deriveDatabaseKey = async (mnemonic) => {
 * @returns The symmetric key for protecting email drafts
 */
 const deriveEmailDraftKey = async (mnemonic) => {
-	return require_deriveKeysFromMnemonic.deriveKeyFromMnemonic(mnemonic, require_constants.CONTEXT_DRAFT);
+	return require_derive_key.deriveKeyFromMnemonic(mnemonic, require_constants.CONTEXT_DRAFT);
 };
-
 //#endregion
-Object.defineProperty(exports, 'createPwdProtectedEmail', {
-  enumerable: true,
-  get: function () {
-    return createPwdProtectedEmail;
-  }
+Object.defineProperty(exports, "createPwdProtectedEmail", {
+	enumerable: true,
+	get: function() {
+		return createPwdProtectedEmail;
+	}
 });
-Object.defineProperty(exports, 'decryptEmailBody', {
-  enumerable: true,
-  get: function () {
-    return decryptEmailBody;
-  }
+Object.defineProperty(exports, "decryptEmailBody", {
+	enumerable: true,
+	get: function() {
+		return decryptEmailBody;
+	}
 });
-Object.defineProperty(exports, 'decryptEmailHybrid', {
-  enumerable: true,
-  get: function () {
-    return decryptEmailHybrid;
-  }
+Object.defineProperty(exports, "decryptEmailHybrid", {
+	enumerable: true,
+	get: function() {
+		return decryptEmailHybrid;
+	}
 });
-Object.defineProperty(exports, 'decryptKeysHybrid', {
-  enumerable: true,
-  get: function () {
-    return decryptKeysHybrid;
-  }
+Object.defineProperty(exports, "decryptKeysHybrid", {
+	enumerable: true,
+	get: function() {
+		return decryptKeysHybrid;
+	}
 });
-Object.defineProperty(exports, 'decryptPwdProtectedEmail', {
-  enumerable: true,
-  get: function () {
-    return decryptPwdProtectedEmail;
-  }
+Object.defineProperty(exports, "decryptPwdProtectedEmail", {
+	enumerable: true,
+	get: function() {
+		return decryptPwdProtectedEmail;
+	}
 });
-Object.defineProperty(exports, 'deriveDatabaseKey', {
-  enumerable: true,
-  get: function () {
-    return deriveDatabaseKey;
-  }
+Object.defineProperty(exports, "deriveDatabaseKey", {
+	enumerable: true,
+	get: function() {
+		return deriveDatabaseKey;
+	}
 });
-Object.defineProperty(exports, 'deriveEmailDraftKey', {
-  enumerable: true,
-  get: function () {
-    return deriveEmailDraftKey;
-  }
+Object.defineProperty(exports, "deriveEmailDraftKey", {
+	enumerable: true,
+	get: function() {
+		return deriveEmailDraftKey;
+	}
 });
-Object.defineProperty(exports, 'encryptEmailBody', {
-  enumerable: true,
-  get: function () {
-    return encryptEmailBody;
-  }
+Object.defineProperty(exports, "encryptEmailBody", {
+	enumerable: true,
+	get: function() {
+		return encryptEmailBody;
+	}
 });
-Object.defineProperty(exports, 'encryptEmailBodyWithKey', {
-  enumerable: true,
-  get: function () {
-    return encryptEmailBodyWithKey;
-  }
+Object.defineProperty(exports, "encryptEmailBodyWithKey", {
+	enumerable: true,
+	get: function() {
+		return encryptEmailBodyWithKey;
+	}
 });
-Object.defineProperty(exports, 'encryptEmailHybrid', {
-  enumerable: true,
-  get: function () {
-    return encryptEmailHybrid;
-  }
+Object.defineProperty(exports, "encryptEmailHybrid", {
+	enumerable: true,
+	get: function() {
+		return encryptEmailHybrid;
+	}
 });
-Object.defineProperty(exports, 'encryptEmailHybridForMultipleRecipients', {
-  enumerable: true,
-  get: function () {
-    return encryptEmailHybridForMultipleRecipients;
-  }
+Object.defineProperty(exports, "encryptEmailHybridForMultipleRecipients", {
+	enumerable: true,
+	get: function() {
+		return encryptEmailHybridForMultipleRecipients;
+	}
 });
-Object.defineProperty(exports, 'encryptKeysHybrid', {
-  enumerable: true,
-  get: function () {
-    return encryptKeysHybrid;
-  }
+Object.defineProperty(exports, "encryptKeysHybrid", {
+	enumerable: true,
+	get: function() {
+		return encryptKeysHybrid;
+	}
 });
-Object.defineProperty(exports, 'generateEmailKeys', {
-  enumerable: true,
-  get: function () {
-    return generateEmailKeys;
-  }
+Object.defineProperty(exports, "generateEmailKeys", {
+	enumerable: true,
+	get: function() {
+		return generateEmailKeys;
+	}
 });
-Object.defineProperty(exports, 'passwordProtectKey', {
-  enumerable: true,
-  get: function () {
-    return passwordProtectKey;
-  }
+Object.defineProperty(exports, "passwordProtectKey", {
+	enumerable: true,
+	get: function() {
+		return passwordProtectKey;
+	}
 });
-Object.defineProperty(exports, 'removePasswordProtection', {
-  enumerable: true,
-  get: function () {
-    return removePasswordProtection;
-  }
+Object.defineProperty(exports, "removePasswordProtection", {
+	enumerable: true,
+	get: function() {
+		return removePasswordProtection;
+	}
 });
-Object.defineProperty(exports, 'unwrapKey', {
-  enumerable: true,
-  get: function () {
-    return unwrapKey;
-  }
+Object.defineProperty(exports, "unwrapKey", {
+	enumerable: true,
+	get: function() {
+		return unwrapKey;
+	}
 });
-Object.defineProperty(exports, 'wrapKey', {
-  enumerable: true,
-  get: function () {
-    return wrapKey;
-  }
+Object.defineProperty(exports, "wrapKey", {
+	enumerable: true,
+	get: function() {
+		return wrapKey;
+	}
 });
-//# sourceMappingURL=emailKeys-BFI-paQq.js.map
+
+//# sourceMappingURL=email-crypto-Cr7znO1a.js.map

package/dist/email-crypto-Cr7znO1a.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"email-crypto-Cr7znO1a.js","names":["genSymmetricKey","UTF8ToUint8","encryptSymmetrically","uint8ArrayToBase64","uint8ToUTF8","decryptSymmetrically","base64ToUint8Array","encapsulateHybrid","decapsulateHybrid","getKeyFromPassword","getKeyFromPasswordAndSalt","genHybridKeys","deriveKeyFromMnemonic","CONTEXT_DATABASE","CONTEXT_DRAFT"],"sources":["../src/key-wrapper/aesWrapper.ts","../src/email-crypto/core.ts","../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/emailKeys.ts"],"sourcesContent":["import { aeskw } from '@noble/ciphers/aes.js';\n\n/**\n * Unwraps the given wrapped key\n *\n * @param encryptedKey - The wrapped key\n * @param wrappingKey - The secret key used for unwrapping\n * @returns The resulting key\n */\nexport async function unwrapKey(encryptedKey: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array> {\n  return aeskw(wrappingKey).decrypt(encryptedKey);\n}\n\n/**\n * Wraps the given key\n *\n * @param key - The key to be wrapped\n * @param wrappingKey - The secret key used for wrapping\n * @returns The resulting ciphertext\n */\nexport async function wrapKey(key: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array> {\n  return aeskw(wrappingKey).encrypt(key);\n}\n","import { HybridEncKey, PwdProtectedKey, EmailBody, EmailBodyEncrypted, RecipientWithPublicKey } from '../types';\nimport { encryptSymmetrically, decryptSymmetrically, genSymmetricKey } from '../symmetric-crypto';\nimport { encapsulateHybrid, decapsulateHybrid } from '../hybrid-crypto';\nimport { wrapKey, unwrapKey } from '../key-wrapper';\nimport { getKeyFromPassword, getKeyFromPasswordAndSalt } from '../derive-password';\nimport { UTF8ToUint8, base64ToUint8Array, uint8ArrayToBase64, uint8ToUTF8 } from '../utils';\n\n/**\n * Symmetrically encrypts email body.\n *\n * @param body - The email body to encrypt.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting encrypted email body and symmetric key used for encryption\n */\nexport async function encryptEmailBody(\n  body: EmailBody,\n  aux?: Uint8Array,\n): Promise<{\n  encEmailBody: EmailBodyEncrypted;\n  encryptionKey: Uint8Array;\n}> {\n  try {\n    if (!body.text || !body.subject) {\n      throw new Error('Invalid input');\n    }\n    const encryptionKey = genSymmetricKey();\n    const encEmailBody = await encryptEmailBodyWithKey(body, encryptionKey, aux);\n\n    return { encEmailBody, encryptionKey };\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email body', { cause: error });\n  }\n}\n\n/**\n * Symmetrically encrypts email body with the given key.\n *\n * @param body - The email body to encrypt.\n * @param encryptionKey - The symmetric key to encrypt the email.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting encrypted email body and symmetric key used for encryption\n */\nexport async function encryptEmailBodyWithKey(\n  body: EmailBody,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBodyEncrypted> {\n  try {\n    const text = UTF8ToUint8(body.text);\n    const subject = UTF8ToUint8(body.subject);\n    const subjectEnc = await encryptSymmetrically(encryptionKey, subject, aux);\n    const encryptedText = await encryptSymmetrically(encryptionKey, text, aux);\n    const encText = uint8ArrayToBase64(encryptedText);\n    const encSubject = uint8ArrayToBase64(subjectEnc);\n    const enc: EmailBodyEncrypted = { encText, encSubject };\n\n    if (body.attachments) {\n      const promises = body.attachments.map((attachment) => {\n        const binaryAttachment = UTF8ToUint8(attachment);\n        return encryptSymmetrically(encryptionKey, binaryAttachment, aux);\n      });\n      const encryptedAttachments = await Promise.all(promises);\n      enc.encAttachments = encryptedAttachments?.map(uint8ArrayToBase64);\n    }\n\n    return enc;\n  } catch (error) {\n    throw new Error('Failed to encrypt email body', { cause: error });\n  }\n}\n\n/**\n * Decrypts symmetrically encrypted email body.\n *\n * @param encEmailBody - The email body to decrypt.\n * @param encryptionKey - The symmetric key to decrypt the email.\n * @param aux - An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting decrypted email body\n */\nexport async function decryptEmailBody(\n  encEmailBody: EmailBodyEncrypted,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encSubject = base64ToUint8Array(encEmailBody.encSubject);\n    const subjectArray = await decryptSymmetrically(encryptionKey, encSubject, aux);\n    const subject = uint8ToUTF8(subjectArray);\n    const encText = base64ToUint8Array(encEmailBody.encText);\n    const textArray = await decryptSymmetrically(encryptionKey, encText, aux);\n    const text = uint8ToUTF8(textArray);\n    const body: EmailBody = { text, subject };\n\n    if (encEmailBody.encAttachments) {\n      const encAttachments = encEmailBody.encAttachments?.map(base64ToUint8Array);\n      const promises = encAttachments?.map((encAtt) => decryptSymmetrically(encryptionKey, encAtt, aux));\n      const decryptedAttachments = await Promise.all(promises);\n      body.attachments = decryptedAttachments?.map((att) => uint8ToUTF8(att));\n    }\n\n    return body;\n  } catch (error) {\n    throw new Error('Failed to symmetrically decrypt email body', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email symmetric key using hybrid encryption.\n *\n * @param emailEncryptionKey - The symmetric key used for email encryption.\n * @param recipient - The recipient with a public hybrid key.\n * @returns The encrypted email symmetric key\n */\nexport async function encryptKeysHybrid(\n  emailEncryptionKey: Uint8Array,\n  recipient: RecipientWithPublicKey,\n): Promise<HybridEncKey> {\n  try {\n    const { cipherText, sharedSecret } = encapsulateHybrid(recipient.publicHybridKey);\n    const encryptedKey = await wrapKey(emailEncryptionKey, sharedSecret);\n    const encryptedKeyBase64 = uint8ArrayToBase64(encryptedKey);\n    const kyberCiphertextBase64 = uint8ArrayToBase64(cipherText);\n\n    return {\n      encryptedKey: encryptedKeyBase64,\n      hybridCiphertext: kyberCiphertextBase64,\n      encryptedForEmail: recipient.email,\n    };\n  } catch (error) {\n    throw new Error('Failed to encrypt email key using hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Decrypts the email symmetric key encrypted via hybrid encryption.\n *\n * @param encryptedKey - The encrypted email key.\n * @param recipientPrivateKey - The private key of the recipient.\n * @returns The email encryption key\n */\nexport async function decryptKeysHybrid(\n  encryptedKey: HybridEncKey,\n  recipientPrivateKey: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const kyberCiphertext = base64ToUint8Array(encryptedKey.hybridCiphertext);\n    const encKey = base64ToUint8Array(encryptedKey.encryptedKey);\n    const sharedSecret = decapsulateHybrid(kyberCiphertext, recipientPrivateKey);\n    const encryptionKey = await unwrapKey(encKey, sharedSecret);\n    return encryptionKey;\n  } catch (error) {\n    throw new Error('Failed to decrypt email key encrypted via hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Password-protects the email symmetric key.\n *\n * @param emailEncryptionKey - The symmetric key used for email encryption.\n * @param password - The secret password for key protection.\n * @returns The password-protected email symmetric key\n */\nexport async function passwordProtectKey(emailEncryptionKey: Uint8Array, password: string): Promise<PwdProtectedKey> {\n  try {\n    const { key, salt } = await getKeyFromPassword(password);\n    const encryptedKey = await wrapKey(emailEncryptionKey, key);\n    const saltStr = uint8ArrayToBase64(salt);\n    const encryptedKeyStr = uint8ArrayToBase64(encryptedKey);\n    return { encryptedKey: encryptedKeyStr, salt: saltStr };\n  } catch (error) {\n    throw new Error('Failed to password-protect email key', { cause: error });\n  }\n}\n\n/**\n * Removes passoword-protection and exposes the email symmetric key.\n *\n * @param emailEncryptionKey -  The password-protected email key.\n * @param password - The secret password for key protection.\n * @returns The email encryption key\n */\nexport async function removePasswordProtection(\n  emailEncryptionKey: PwdProtectedKey,\n  password: string,\n): Promise<Uint8Array> {\n  try {\n    const salt = base64ToUint8Array(emailEncryptionKey.salt);\n    const encryptedKey = base64ToUint8Array(emailEncryptionKey.encryptedKey);\n    const key = await getKeyFromPasswordAndSalt(password, salt);\n    const encryptionKey = await unwrapKey(encryptedKey, key);\n    return encryptionKey;\n  } catch (error) {\n    throw new Error('Failed to remove password-protection from email key', { cause: error });\n  }\n}\n","import { HybridEncryptedEmail, EmailBody, RecipientWithPublicKey } from '../types';\nimport { decryptEmailBody, encryptKeysHybrid, decryptKeysHybrid, encryptEmailBody } from './core';\n\n/**\n * Encrypts the email body using hybrid encryption.\n *\n * @param body - The email body to encrypt.\n * @param recipientPublicKeys - The public keys of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The encrypted email body\n */\nexport async function encryptEmailHybrid(\n  body: EmailBody,\n  recipient: RecipientWithPublicKey,\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n    const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to encrypt email body with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email body using hybrid encryption for multiple recipients.\n *\n * @param body - The email body to encrypt for multiple recipients.\n * @param recipients - The recipients with corresponding public keys.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The set of encrypted email bodies\n */\nexport async function encryptEmailHybridForMultipleRecipients(\n  body: EmailBody,\n  recipients: RecipientWithPublicKey[],\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail[]> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n\n    const encryptedEmails: HybridEncryptedEmail[] = [];\n    for (const recipient of recipients) {\n      const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n      encryptedEmails.push({\n        encEmailBody: encEmailBody,\n        encryptedKey,\n      });\n    }\n    return encryptedEmails;\n  } catch (error) {\n    throw new Error('Failed to encrypt email to multiple recipients with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Decrypts the email using hybrid encryption.\n *\n * @param encEmailBody - The encrypted email.\n * @param recipientPrivateHybridKeys - The private key of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email body\n */\nexport async function decryptEmailHybrid(\n  encEmailBody: HybridEncryptedEmail,\n  recipientPrivateHybridKeys: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await decryptKeysHybrid(encEmailBody.encryptedKey, recipientPrivateHybridKeys);\n    const body = await decryptEmailBody(encEmailBody.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt email with hybrid encryption', { cause: error });\n  }\n}\n","import { PwdProtectedEmail, EmailBody } from '../types';\nimport { decryptEmailBody, passwordProtectKey, removePasswordProtection, encryptEmailBody } from './core';\n\n/**\n * Creates a password-protected email.\n *\n * @param email - The email to password-protect\n * @param password - The secret password shared among recipients\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The password-protected email\n */\nexport async function createPwdProtectedEmail(\n  emailBody: EmailBody,\n  password: string,\n  aux?: Uint8Array,\n): Promise<PwdProtectedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(emailBody, aux);\n    const encryptedKey = await passwordProtectKey(encryptionKey, password);\n\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to password-protect email', { cause: error });\n  }\n}\n\n/**\n * Opens a password-protected email.\n *\n * @param encryptedEmail - The encrypted email\n * @param password - The secret password shared among recipients.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email body\n */\nexport async function decryptPwdProtectedEmail(\n  encryptedEmail: PwdProtectedEmail,\n  password: string,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);\n    const body = await decryptEmailBody(encryptedEmail.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt password-protect email', { cause: error });\n  }\n}\n","import { genHybridKeys } from '../hybrid-crypto';\nimport { HybridKeyPair } from '../types';\nimport { deriveKeyFromMnemonic } from '../derive-key';\nimport { CONTEXT_DATABASE, CONTEXT_DRAFT } from '../constants';\n\n/**\n * Generates public and private keys for email encryption.\n *\n * @returns The user's private and public keys\n */\nexport async function generateEmailKeys(): Promise<HybridKeyPair> {\n  return genHybridKeys();\n}\n\n/**\n * Derives database encryption key for the given user\n *\n * @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)\n * @returns The symmetric key for protecting database\n */\nexport const deriveDatabaseKey = async (mnemonic: string): Promise<Uint8Array> => {\n  return deriveKeyFromMnemonic(mnemonic, CONTEXT_DATABASE);\n};\n\n/**\n * Derives email draft encryption key for the given user\n *\n * @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)\n * @returns The symmetric key for protecting email drafts\n */\nexport const deriveEmailDraftKey = async (mnemonic: string): Promise<Uint8Array> => {\n  return deriveKeyFromMnemonic(mnemonic, CONTEXT_DRAFT);\n};\n"],"mappings":";;;;;;;;;;;;;;;;AASA,eAAsB,UAAU,cAA0B,aAA8C;AACtG,SAAA,GAAA,sBAAA,OAAa,YAAY,CAAC,QAAQ,aAAa;;;;;;;;;AAUjD,eAAsB,QAAQ,KAAiB,aAA8C;AAC3F,SAAA,GAAA,sBAAA,OAAa,YAAY,CAAC,QAAQ,IAAI;;;;;;;;;;;ACPxC,eAAsB,iBACpB,MACA,KAIC;AACD,KAAI;AACF,MAAI,CAAC,KAAK,QAAQ,CAAC,KAAK,QACtB,OAAM,IAAI,MAAM,gBAAgB;EAElC,MAAM,gBAAgBA,yBAAAA,iBAAiB;AAGvC,SAAO;GAAE,cAAA,MAFkB,wBAAwB,MAAM,eAAe,IAAI;GAErD;GAAe;UAC/B,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYnF,eAAsB,wBACpB,MACA,eACA,KAC6B;AAC7B,KAAI;EACF,MAAM,OAAOC,cAAAA,YAAY,KAAK,KAAK;EAEnC,MAAM,aAAa,MAAMC,yBAAAA,qBAAqB,eAD9BD,cAAAA,YAAY,KAAK,QACmC,EAAE,IAAI;EAI1E,MAAM,MAA0B;GAAE,SAFlBE,cAAAA,mBAAmB,MADPD,yBAAAA,qBAAqB,eAAe,MAAM,IAAI,CAGjC;GAAE,YADxBC,cAAAA,mBAAmB,WACe;GAAE;AAEvD,MAAI,KAAK,aAAa;GACpB,MAAM,WAAW,KAAK,YAAY,KAAK,eAAe;AAEpD,WAAOD,yBAAAA,qBAAqB,eADHD,cAAAA,YAAY,WACsB,EAAE,IAAI;KACjE;AAEF,OAAI,kBAAiB,MADc,QAAQ,IAAI,SAAS,GACb,IAAIE,cAAAA,mBAAmB;;AAGpE,SAAO;UACA,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYrE,eAAsB,iBACpB,cACA,eACA,KACoB;AACpB,KAAI;EAGF,MAAM,UAAUC,cAAAA,YAAY,MADDC,yBAAAA,qBAAqB,eAD7BC,cAAAA,mBAAmB,aAAa,WACsB,EAAE,IAAI,CACtC;EAIzC,MAAM,OAAkB;GAAE,MADbF,cAAAA,YAAY,MADDC,yBAAAA,qBAAqB,eAD7BC,cAAAA,mBAAmB,aAAa,QACmB,EAAE,IAAI,CAE3C;GAAE;GAAS;AAEzC,MAAI,aAAa,gBAAgB;GAE/B,MAAM,YADiB,aAAa,gBAAgB,IAAIA,cAAAA,mBAAmB,GAC1C,KAAK,WAAWD,yBAAAA,qBAAqB,eAAe,QAAQ,IAAI,CAAC;AAElG,QAAK,eAAc,MADgB,QAAQ,IAAI,SAAS,GACf,KAAK,QAAQD,cAAAA,YAAY,IAAI,CAAC;;AAGzE,SAAO;UACA,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWnF,eAAsB,kBACpB,oBACA,WACuB;AACvB,KAAI;EACF,MAAM,EAAE,YAAY,iBAAiBG,cAAAA,kBAAkB,UAAU,gBAAgB;AAKjF,SAAO;GACL,cAJyBJ,cAAAA,mBAAmB,MADnB,QAAQ,oBAAoB,aAAa,CAKlC;GAChC,kBAJ4BA,cAAAA,mBAAmB,WAIR;GACvC,mBAAmB,UAAU;GAC9B;UACM,OAAO;AACd,QAAM,IAAI,MAAM,uDAAuD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW5F,eAAsB,kBACpB,cACA,qBACqB;AACrB,KAAI;EACF,MAAM,kBAAkBG,cAAAA,mBAAmB,aAAa,iBAAiB;AAIzE,SAAO,MADqB,UAFbA,cAAAA,mBAAmB,aAAa,aAEH,EADvBE,cAAAA,kBAAkB,iBAAiB,oBACE,CAAC;UAEpD,OAAO;AACd,QAAM,IAAI,MAAM,+DAA+D,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWpG,eAAsB,mBAAmB,oBAAgC,UAA4C;AACnH,KAAI;EACF,MAAM,EAAE,KAAK,SAAS,MAAMC,wBAAAA,mBAAmB,SAAS;EACxD,MAAM,eAAe,MAAM,QAAQ,oBAAoB,IAAI;EAC3D,MAAM,UAAUN,cAAAA,mBAAmB,KAAK;AAExC,SAAO;GAAE,cADeA,cAAAA,mBAAmB,aACL;GAAE,MAAM;GAAS;UAChD,OAAO;AACd,QAAM,IAAI,MAAM,wCAAwC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW7E,eAAsB,yBACpB,oBACA,UACqB;AACrB,KAAI;EACF,MAAM,OAAOG,cAAAA,mBAAmB,mBAAmB,KAAK;AAIxD,SAAO,MADqB,UAFPA,cAAAA,mBAAmB,mBAAmB,aAET,EAAE,MADlCI,wBAAAA,0BAA0B,UAAU,KAAK,CACH;UAEjD,OAAO;AACd,QAAM,IAAI,MAAM,uDAAuD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;ACrL5F,eAAsB,mBACpB,MACA,WACA,KAC+B;AAC/B,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAM,iBAAiB,MAAM,IAAI;AAEzE,SAAO;GAAE;GAAc,cAAA,MADI,kBAAkB,eAAe,UAAU;GACjC;UAC9B,OAAO;AACd,QAAM,IAAI,MAAM,uDAAuD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY5F,eAAsB,wCACpB,MACA,YACA,KACiC;AACjC,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAM,iBAAiB,MAAM,IAAI;EAEzE,MAAM,kBAA0C,EAAE;AAClD,OAAK,MAAM,aAAa,YAAY;GAClC,MAAM,eAAe,MAAM,kBAAkB,eAAe,UAAU;AACtE,mBAAgB,KAAK;IACL;IACd;IACD,CAAC;;AAEJ,SAAO;UACA,OAAO;AACd,QAAM,IAAI,MAAM,yEAAyE,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY9G,eAAsB,mBACpB,cACA,4BACA,KACoB;AACpB,KAAI;EACF,MAAM,gBAAgB,MAAM,kBAAkB,aAAa,cAAc,2BAA2B;AAEpG,SAAO,MADY,iBAAiB,aAAa,cAAc,eAAe,IAAI;UAE3E,OAAO;AACd,QAAM,IAAI,MAAM,kDAAkD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;AC9DvF,eAAsB,wBACpB,WACA,UACA,KAC4B;AAC5B,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAM,iBAAiB,WAAW,IAAI;AAG9E,SAAO;GAAE;GAAc,cAAA,MAFI,mBAAmB,eAAe,SAAS;GAEjC;UAC9B,OAAO;AACd,QAAM,IAAI,MAAM,oCAAoC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYzE,eAAsB,yBACpB,gBACA,UACA,KACoB;AACpB,KAAI;EACF,MAAM,gBAAgB,MAAM,yBAAyB,eAAe,cAAc,SAAS;AAE3F,SAAO,MADY,iBAAiB,eAAe,cAAc,eAAe,IAAI;UAE7E,OAAO;AACd,QAAM,IAAI,MAAM,4CAA4C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AClCjF,eAAsB,oBAA4C;AAChE,QAAOC,cAAAA,eAAe;;;;;;;;AASxB,MAAa,oBAAoB,OAAO,aAA0C;AAChF,QAAOC,mBAAAA,sBAAsB,UAAUC,kBAAAA,iBAAiB;;;;;;;;AAS1D,MAAa,sBAAsB,OAAO,aAA0C;AAClF,QAAOD,mBAAAA,sBAAsB,UAAUE,kBAAAA,cAAc"}

package/dist/{emailKeys-BjIeINfC.mjs → email-crypto-cHDsjSb5.mjs}

@@ -1,11 +1,10 @@
 import { CONTEXT_DATABASE, CONTEXT_DRAFT } from "./constants.mjs";
-import { c as base64ToUint8Array, f as uint8ToUTF8, s as UTF8ToUint8, u as uint8ArrayToBase64 } from "./genID-D08K7JPr.mjs";
-import { t as deriveKeyFromMnemonic } from "./deriveKeysFromMnemonic-DB0UHE-y.mjs";
-import { n as getKeyFromPassword, r as getKeyFromPasswordAndSalt } from "./deriveKeysFromPassword-DFzo2OII.mjs";
-import { n as encryptSymmetrically, r as genSymmetricKey, t as decryptSymmetrically } from "./aes-B8TA-JKq.mjs";
-import { n as encapsulateHybrid, r as genHybridKeys, t as decapsulateHybrid } from "./xwing-CQmQX6hn.mjs";
+import { UTF8ToUint8, base64ToUint8Array, uint8ArrayToBase64, uint8ToUTF8 } from "./utils.mjs";
+import { deriveKeyFromMnemonic } from "./derive-key.mjs";
+import { n as getKeyFromPassword, r as getKeyFromPasswordAndSalt } from "./derive-password-PED-YfwE.mjs";
+import { decryptSymmetrically, encryptSymmetrically, genSymmetricKey } from "./symmetric-crypto.mjs";
+import { n as encapsulateHybrid, r as genHybridKeys, t as decapsulateHybrid } from "./xwing-B34h5e3Z.mjs";
 import { aeskw } from "@noble/ciphers/aes.js";
-
 //#region src/key-wrapper/aesWrapper.ts
 /**
 * Unwraps the given wrapped key
@@ -27,7 +26,6 @@ async function unwrapKey(encryptedKey, wrappingKey) {
 async function wrapKey(key, wrappingKey) {
 	return aeskw(wrappingKey).encrypt(key);
 }
-
 //#endregion
 //#region src/email-crypto/core.ts
 /**
@@ -169,7 +167,6 @@ async function removePasswordProtection(emailEncryptionKey, password) {
 		throw new Error("Failed to remove password-protection from email key", { cause: error });
 	}
 }
-
 //#endregion
 //#region src/email-crypto/hybridEncyptedEmail.ts
 /**
@@ -231,7 +228,6 @@ async function decryptEmailHybrid(encEmailBody, recipientPrivateHybridKeys, aux)
 		throw new Error("Failed to decrypt email with hybrid encryption", { cause: error });
 	}
 }
-
 //#endregion
 //#region src/email-crypto/pwdProtectedEmail.ts
 /**
@@ -269,7 +265,6 @@ async function decryptPwdProtectedEmail(encryptedEmail, password, aux) {
 		throw new Error("Failed to decrypt password-protect email", { cause: error });
 	}
 }
-
 //#endregion
 //#region src/email-crypto/emailKeys.ts
 /**
@@ -298,7 +293,7 @@ const deriveDatabaseKey = async (mnemonic) => {
 const deriveEmailDraftKey = async (mnemonic) => {
 	return deriveKeyFromMnemonic(mnemonic, CONTEXT_DRAFT);
 };
-
 //#endregion
 export { wrapKey as _, decryptPwdProtectedEmail as a, encryptEmailHybridForMultipleRecipients as c, encryptEmailBody as d, encryptEmailBodyWithKey as f, unwrapKey as g, removePasswordProtection as h, createPwdProtectedEmail as i, decryptEmailBody as l, passwordProtectKey as m, deriveEmailDraftKey as n, decryptEmailHybrid as o, encryptKeysHybrid as p, generateEmailKeys as r, encryptEmailHybrid as s, deriveDatabaseKey as t, decryptKeysHybrid as u };
-//# sourceMappingURL=emailKeys-BjIeINfC.mjs.map
+
+//# sourceMappingURL=email-crypto-cHDsjSb5.mjs.map

package/dist/email-crypto-cHDsjSb5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"email-crypto-cHDsjSb5.mjs","names":[],"sources":["../src/key-wrapper/aesWrapper.ts","../src/email-crypto/core.ts","../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/emailKeys.ts"],"sourcesContent":["import { aeskw } from '@noble/ciphers/aes.js';\n\n/**\n * Unwraps the given wrapped key\n *\n * @param encryptedKey - The wrapped key\n * @param wrappingKey - The secret key used for unwrapping\n * @returns The resulting key\n */\nexport async function unwrapKey(encryptedKey: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array> {\n  return aeskw(wrappingKey).decrypt(encryptedKey);\n}\n\n/**\n * Wraps the given key\n *\n * @param key - The key to be wrapped\n * @param wrappingKey - The secret key used for wrapping\n * @returns The resulting ciphertext\n */\nexport async function wrapKey(key: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array> {\n  return aeskw(wrappingKey).encrypt(key);\n}\n","import { HybridEncKey, PwdProtectedKey, EmailBody, EmailBodyEncrypted, RecipientWithPublicKey } from '../types';\nimport { encryptSymmetrically, decryptSymmetrically, genSymmetricKey } from '../symmetric-crypto';\nimport { encapsulateHybrid, decapsulateHybrid } from '../hybrid-crypto';\nimport { wrapKey, unwrapKey } from '../key-wrapper';\nimport { getKeyFromPassword, getKeyFromPasswordAndSalt } from '../derive-password';\nimport { UTF8ToUint8, base64ToUint8Array, uint8ArrayToBase64, uint8ToUTF8 } from '../utils';\n\n/**\n * Symmetrically encrypts email body.\n *\n * @param body - The email body to encrypt.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting encrypted email body and symmetric key used for encryption\n */\nexport async function encryptEmailBody(\n  body: EmailBody,\n  aux?: Uint8Array,\n): Promise<{\n  encEmailBody: EmailBodyEncrypted;\n  encryptionKey: Uint8Array;\n}> {\n  try {\n    if (!body.text || !body.subject) {\n      throw new Error('Invalid input');\n    }\n    const encryptionKey = genSymmetricKey();\n    const encEmailBody = await encryptEmailBodyWithKey(body, encryptionKey, aux);\n\n    return { encEmailBody, encryptionKey };\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email body', { cause: error });\n  }\n}\n\n/**\n * Symmetrically encrypts email body with the given key.\n *\n * @param body - The email body to encrypt.\n * @param encryptionKey - The symmetric key to encrypt the email.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting encrypted email body and symmetric key used for encryption\n */\nexport async function encryptEmailBodyWithKey(\n  body: EmailBody,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBodyEncrypted> {\n  try {\n    const text = UTF8ToUint8(body.text);\n    const subject = UTF8ToUint8(body.subject);\n    const subjectEnc = await encryptSymmetrically(encryptionKey, subject, aux);\n    const encryptedText = await encryptSymmetrically(encryptionKey, text, aux);\n    const encText = uint8ArrayToBase64(encryptedText);\n    const encSubject = uint8ArrayToBase64(subjectEnc);\n    const enc: EmailBodyEncrypted = { encText, encSubject };\n\n    if (body.attachments) {\n      const promises = body.attachments.map((attachment) => {\n        const binaryAttachment = UTF8ToUint8(attachment);\n        return encryptSymmetrically(encryptionKey, binaryAttachment, aux);\n      });\n      const encryptedAttachments = await Promise.all(promises);\n      enc.encAttachments = encryptedAttachments?.map(uint8ArrayToBase64);\n    }\n\n    return enc;\n  } catch (error) {\n    throw new Error('Failed to encrypt email body', { cause: error });\n  }\n}\n\n/**\n * Decrypts symmetrically encrypted email body.\n *\n * @param encEmailBody - The email body to decrypt.\n * @param encryptionKey - The symmetric key to decrypt the email.\n * @param aux - An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting decrypted email body\n */\nexport async function decryptEmailBody(\n  encEmailBody: EmailBodyEncrypted,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encSubject = base64ToUint8Array(encEmailBody.encSubject);\n    const subjectArray = await decryptSymmetrically(encryptionKey, encSubject, aux);\n    const subject = uint8ToUTF8(subjectArray);\n    const encText = base64ToUint8Array(encEmailBody.encText);\n    const textArray = await decryptSymmetrically(encryptionKey, encText, aux);\n    const text = uint8ToUTF8(textArray);\n    const body: EmailBody = { text, subject };\n\n    if (encEmailBody.encAttachments) {\n      const encAttachments = encEmailBody.encAttachments?.map(base64ToUint8Array);\n      const promises = encAttachments?.map((encAtt) => decryptSymmetrically(encryptionKey, encAtt, aux));\n      const decryptedAttachments = await Promise.all(promises);\n      body.attachments = decryptedAttachments?.map((att) => uint8ToUTF8(att));\n    }\n\n    return body;\n  } catch (error) {\n    throw new Error('Failed to symmetrically decrypt email body', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email symmetric key using hybrid encryption.\n *\n * @param emailEncryptionKey - The symmetric key used for email encryption.\n * @param recipient - The recipient with a public hybrid key.\n * @returns The encrypted email symmetric key\n */\nexport async function encryptKeysHybrid(\n  emailEncryptionKey: Uint8Array,\n  recipient: RecipientWithPublicKey,\n): Promise<HybridEncKey> {\n  try {\n    const { cipherText, sharedSecret } = encapsulateHybrid(recipient.publicHybridKey);\n    const encryptedKey = await wrapKey(emailEncryptionKey, sharedSecret);\n    const encryptedKeyBase64 = uint8ArrayToBase64(encryptedKey);\n    const kyberCiphertextBase64 = uint8ArrayToBase64(cipherText);\n\n    return {\n      encryptedKey: encryptedKeyBase64,\n      hybridCiphertext: kyberCiphertextBase64,\n      encryptedForEmail: recipient.email,\n    };\n  } catch (error) {\n    throw new Error('Failed to encrypt email key using hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Decrypts the email symmetric key encrypted via hybrid encryption.\n *\n * @param encryptedKey - The encrypted email key.\n * @param recipientPrivateKey - The private key of the recipient.\n * @returns The email encryption key\n */\nexport async function decryptKeysHybrid(\n  encryptedKey: HybridEncKey,\n  recipientPrivateKey: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const kyberCiphertext = base64ToUint8Array(encryptedKey.hybridCiphertext);\n    const encKey = base64ToUint8Array(encryptedKey.encryptedKey);\n    const sharedSecret = decapsulateHybrid(kyberCiphertext, recipientPrivateKey);\n    const encryptionKey = await unwrapKey(encKey, sharedSecret);\n    return encryptionKey;\n  } catch (error) {\n    throw new Error('Failed to decrypt email key encrypted via hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Password-protects the email symmetric key.\n *\n * @param emailEncryptionKey - The symmetric key used for email encryption.\n * @param password - The secret password for key protection.\n * @returns The password-protected email symmetric key\n */\nexport async function passwordProtectKey(emailEncryptionKey: Uint8Array, password: string): Promise<PwdProtectedKey> {\n  try {\n    const { key, salt } = await getKeyFromPassword(password);\n    const encryptedKey = await wrapKey(emailEncryptionKey, key);\n    const saltStr = uint8ArrayToBase64(salt);\n    const encryptedKeyStr = uint8ArrayToBase64(encryptedKey);\n    return { encryptedKey: encryptedKeyStr, salt: saltStr };\n  } catch (error) {\n    throw new Error('Failed to password-protect email key', { cause: error });\n  }\n}\n\n/**\n * Removes passoword-protection and exposes the email symmetric key.\n *\n * @param emailEncryptionKey -  The password-protected email key.\n * @param password - The secret password for key protection.\n * @returns The email encryption key\n */\nexport async function removePasswordProtection(\n  emailEncryptionKey: PwdProtectedKey,\n  password: string,\n): Promise<Uint8Array> {\n  try {\n    const salt = base64ToUint8Array(emailEncryptionKey.salt);\n    const encryptedKey = base64ToUint8Array(emailEncryptionKey.encryptedKey);\n    const key = await getKeyFromPasswordAndSalt(password, salt);\n    const encryptionKey = await unwrapKey(encryptedKey, key);\n    return encryptionKey;\n  } catch (error) {\n    throw new Error('Failed to remove password-protection from email key', { cause: error });\n  }\n}\n","import { HybridEncryptedEmail, EmailBody, RecipientWithPublicKey } from '../types';\nimport { decryptEmailBody, encryptKeysHybrid, decryptKeysHybrid, encryptEmailBody } from './core';\n\n/**\n * Encrypts the email body using hybrid encryption.\n *\n * @param body - The email body to encrypt.\n * @param recipientPublicKeys - The public keys of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The encrypted email body\n */\nexport async function encryptEmailHybrid(\n  body: EmailBody,\n  recipient: RecipientWithPublicKey,\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n    const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to encrypt email body with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email body using hybrid encryption for multiple recipients.\n *\n * @param body - The email body to encrypt for multiple recipients.\n * @param recipients - The recipients with corresponding public keys.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The set of encrypted email bodies\n */\nexport async function encryptEmailHybridForMultipleRecipients(\n  body: EmailBody,\n  recipients: RecipientWithPublicKey[],\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail[]> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n\n    const encryptedEmails: HybridEncryptedEmail[] = [];\n    for (const recipient of recipients) {\n      const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n      encryptedEmails.push({\n        encEmailBody: encEmailBody,\n        encryptedKey,\n      });\n    }\n    return encryptedEmails;\n  } catch (error) {\n    throw new Error('Failed to encrypt email to multiple recipients with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Decrypts the email using hybrid encryption.\n *\n * @param encEmailBody - The encrypted email.\n * @param recipientPrivateHybridKeys - The private key of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email body\n */\nexport async function decryptEmailHybrid(\n  encEmailBody: HybridEncryptedEmail,\n  recipientPrivateHybridKeys: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await decryptKeysHybrid(encEmailBody.encryptedKey, recipientPrivateHybridKeys);\n    const body = await decryptEmailBody(encEmailBody.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt email with hybrid encryption', { cause: error });\n  }\n}\n","import { PwdProtectedEmail, EmailBody } from '../types';\nimport { decryptEmailBody, passwordProtectKey, removePasswordProtection, encryptEmailBody } from './core';\n\n/**\n * Creates a password-protected email.\n *\n * @param email - The email to password-protect\n * @param password - The secret password shared among recipients\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The password-protected email\n */\nexport async function createPwdProtectedEmail(\n  emailBody: EmailBody,\n  password: string,\n  aux?: Uint8Array,\n): Promise<PwdProtectedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(emailBody, aux);\n    const encryptedKey = await passwordProtectKey(encryptionKey, password);\n\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to password-protect email', { cause: error });\n  }\n}\n\n/**\n * Opens a password-protected email.\n *\n * @param encryptedEmail - The encrypted email\n * @param password - The secret password shared among recipients.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email body\n */\nexport async function decryptPwdProtectedEmail(\n  encryptedEmail: PwdProtectedEmail,\n  password: string,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);\n    const body = await decryptEmailBody(encryptedEmail.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt password-protect email', { cause: error });\n  }\n}\n","import { genHybridKeys } from '../hybrid-crypto';\nimport { HybridKeyPair } from '../types';\nimport { deriveKeyFromMnemonic } from '../derive-key';\nimport { CONTEXT_DATABASE, CONTEXT_DRAFT } from '../constants';\n\n/**\n * Generates public and private keys for email encryption.\n *\n * @returns The user's private and public keys\n */\nexport async function generateEmailKeys(): Promise<HybridKeyPair> {\n  return genHybridKeys();\n}\n\n/**\n * Derives database encryption key for the given user\n *\n * @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)\n * @returns The symmetric key for protecting database\n */\nexport const deriveDatabaseKey = async (mnemonic: string): Promise<Uint8Array> => {\n  return deriveKeyFromMnemonic(mnemonic, CONTEXT_DATABASE);\n};\n\n/**\n * Derives email draft encryption key for the given user\n *\n * @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)\n * @returns The symmetric key for protecting email drafts\n */\nexport const deriveEmailDraftKey = async (mnemonic: string): Promise<Uint8Array> => {\n  return deriveKeyFromMnemonic(mnemonic, CONTEXT_DRAFT);\n};\n"],"mappings":"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"}

package/dist/email-crypto.d.mts

@@ -1,4 +1,4 @@
-import { EmailBody, EmailBodyEncrypted, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey } from "./types.mjs";
+import { a as HybridEncryptedEmail, c as PwdProtectedEmail, i as HybridEncKey, l as PwdProtectedKey, n as EmailBodyEncrypted, o as HybridKeyPair, t as EmailBody, u as RecipientWithPublicKey } from "./types-DAPJQG8U.mjs";
 
 //#region src/email-crypto/hybridEncyptedEmail.d.ts
 /**

package/dist/email-crypto.d.ts

@@ -1,4 +1,4 @@
-import { EmailBody, EmailBodyEncrypted, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey } from "./types.js";
+import { a as HybridEncryptedEmail, c as PwdProtectedEmail, i as HybridEncKey, l as PwdProtectedKey, n as EmailBodyEncrypted, o as HybridKeyPair, t as EmailBody, u as RecipientWithPublicKey } from "./types-4P0WII1D.js";
 
 //#region src/email-crypto/hybridEncyptedEmail.d.ts
 /**

package/dist/email-crypto.js

@@ -1,18 +1,17 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_emailKeys = require('./emailKeys-BFI-paQq.js');
-
-exports.createPwdProtectedEmail = require_emailKeys.createPwdProtectedEmail;
-exports.decryptEmailBody = require_emailKeys.decryptEmailBody;
-exports.decryptEmailHybrid = require_emailKeys.decryptEmailHybrid;
-exports.decryptKeysHybrid = require_emailKeys.decryptKeysHybrid;
-exports.decryptPwdProtectedEmail = require_emailKeys.decryptPwdProtectedEmail;
-exports.deriveDatabaseKey = require_emailKeys.deriveDatabaseKey;
-exports.deriveEmailDraftKey = require_emailKeys.deriveEmailDraftKey;
-exports.encryptEmailBody = require_emailKeys.encryptEmailBody;
-exports.encryptEmailBodyWithKey = require_emailKeys.encryptEmailBodyWithKey;
-exports.encryptEmailHybrid = require_emailKeys.encryptEmailHybrid;
-exports.encryptEmailHybridForMultipleRecipients = require_emailKeys.encryptEmailHybridForMultipleRecipients;
-exports.encryptKeysHybrid = require_emailKeys.encryptKeysHybrid;
-exports.generateEmailKeys = require_emailKeys.generateEmailKeys;
-exports.passwordProtectKey = require_emailKeys.passwordProtectKey;
-exports.removePasswordProtection = require_emailKeys.removePasswordProtection;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_email_crypto = require("./email-crypto-Cr7znO1a.js");
+exports.createPwdProtectedEmail = require_email_crypto.createPwdProtectedEmail;
+exports.decryptEmailBody = require_email_crypto.decryptEmailBody;
+exports.decryptEmailHybrid = require_email_crypto.decryptEmailHybrid;
+exports.decryptKeysHybrid = require_email_crypto.decryptKeysHybrid;
+exports.decryptPwdProtectedEmail = require_email_crypto.decryptPwdProtectedEmail;
+exports.deriveDatabaseKey = require_email_crypto.deriveDatabaseKey;
+exports.deriveEmailDraftKey = require_email_crypto.deriveEmailDraftKey;
+exports.encryptEmailBody = require_email_crypto.encryptEmailBody;
+exports.encryptEmailBodyWithKey = require_email_crypto.encryptEmailBodyWithKey;
+exports.encryptEmailHybrid = require_email_crypto.encryptEmailHybrid;
+exports.encryptEmailHybridForMultipleRecipients = require_email_crypto.encryptEmailHybridForMultipleRecipients;
+exports.encryptKeysHybrid = require_email_crypto.encryptKeysHybrid;
+exports.generateEmailKeys = require_email_crypto.generateEmailKeys;
+exports.passwordProtectKey = require_email_crypto.passwordProtectKey;
+exports.removePasswordProtection = require_email_crypto.removePasswordProtection;

package/dist/email-crypto.mjs

@@ -1,3 +1,2 @@
-import { a as decryptPwdProtectedEmail, c as encryptEmailHybridForMultipleRecipients, d as encryptEmailBody, f as encryptEmailBodyWithKey, h as removePasswordProtection, i as createPwdProtectedEmail, l as decryptEmailBody, m as passwordProtectKey, n as deriveEmailDraftKey, o as decryptEmailHybrid, p as encryptKeysHybrid, r as generateEmailKeys, s as encryptEmailHybrid, t as deriveDatabaseKey, u as decryptKeysHybrid } from "./emailKeys-BjIeINfC.mjs";
-
-export { createPwdProtectedEmail, decryptEmailBody, decryptEmailHybrid, decryptKeysHybrid, decryptPwdProtectedEmail, deriveDatabaseKey, deriveEmailDraftKey, encryptEmailBody, encryptEmailBodyWithKey, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptKeysHybrid, generateEmailKeys, passwordProtectKey, removePasswordProtection };
+import { a as decryptPwdProtectedEmail, c as encryptEmailHybridForMultipleRecipients, d as encryptEmailBody, f as encryptEmailBodyWithKey, h as removePasswordProtection, i as createPwdProtectedEmail, l as decryptEmailBody, m as passwordProtectKey, n as deriveEmailDraftKey, o as decryptEmailHybrid, p as encryptKeysHybrid, r as generateEmailKeys, s as encryptEmailHybrid, t as deriveDatabaseKey, u as decryptKeysHybrid } from "./email-crypto-cHDsjSb5.mjs";
+export { createPwdProtectedEmail, decryptEmailBody, decryptEmailHybrid, decryptKeysHybrid, decryptPwdProtectedEmail, deriveDatabaseKey, deriveEmailDraftKey, encryptEmailBody, encryptEmailBodyWithKey, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptKeysHybrid, generateEmailKeys, passwordProtectKey, removePasswordProtection };

package/dist/hash.js

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_chunk = require('./chunk-EbLFQX5m.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./chunk-C13QxCFV.js");
 let _noble_hashes_blake3_js = require("@noble/hashes/blake3.js");
-
 //#region src/hash/blake3.ts
 /**
 * Hashes the given array of data
@@ -79,7 +78,6 @@ function hashDataWithKey(hashKey, data) {
 function getBytesFromData(data, bytes) {
 	return (0, _noble_hashes_blake3_js.blake3)(data, { dkLen: bytes });
 }
-
 //#endregion
 exports.getBytesFromData = getBytesFromData;
 exports.getBytesFromDataArray = getBytesFromDataArray;
@@ -87,4 +85,5 @@ exports.hashData = hashData;
 exports.hashDataArray = hashDataArray;
 exports.hashDataArrayWithKey = hashDataArrayWithKey;
 exports.hashDataWithKey = hashDataWithKey;
+
 //# sourceMappingURL=hash.js.map

package/dist/hash.js.map

@@ -1 +1 @@
-{"version":3,"file":"hash.js","names":["blake3"],"sources":["../src/hash/blake3.ts"],"sourcesContent":["import { blake3 } from '@noble/hashes/blake3.js';\n\n/**\n * Hashes the given array of data\n *\n * @param data - The array of data\n * @returns The resulting hash\n */\nexport function hashDataArray(data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create();\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data with the given key\n *\n * @param hashKey - The key for keyed hashing\n * @param data - The array of data\n * @returns The resulting keyed hash\n */\nexport function hashDataArrayWithKey(hashKey: Uint8Array, data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create({ key: hashKey });\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data to the desired byte-length\n *\n * @param data - The array of data\n * @param bytes - The desired output byte-length\n * @returns The resulting hash of the desired byte-length\n */\nexport function getBytesFromDataArray(data: Uint8Array[], bytes: number): Uint8Array {\n  try {\n    const hasher = blake3.create({ dkLen: bytes });\n    for (const chunk of data) {\n      hasher.update(chunk);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to get bytes from data', { cause: error });\n  }\n}\n\n/**\n * Hashes the given data\n *\n * @param data - The data\n * @returns The resulting hash\n */\nexport function hashData(data: Uint8Array): Uint8Array {\n  return blake3(data);\n}\n\n/**\n * Hashes the given data with the given key\n *\n * @param hashKey - The key for keyed hashing\n * @param data - The data\n * @returns The resulting keyed hash\n */\nexport function hashDataWithKey(hashKey: Uint8Array, data: Uint8Array): Uint8Array {\n  return blake3(data, { key: hashKey });\n}\n\n/**\n * Hashes the given data to the desired byte-length\n *\n * @param data - The data\n * @param bytes - The desired output byte-length\n * @returns The resulting hash of the desired byte-length\n */\nexport function getBytesFromData(data: Uint8Array, bytes: number): Uint8Array {\n  return blake3(data, { dkLen: bytes });\n}\n"],"mappings":";;;;;;;;;;;AAQA,SAAgB,cAAc,MAAgC;AAC5D,KAAI;EACF,MAAM,SAASA,+BAAO,QAAQ;AAC9B,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW/D,SAAgB,qBAAqB,SAAqB,MAAgC;AACxF,KAAI;EACF,MAAM,SAASA,+BAAO,OAAO,EAAE,KAAK,SAAS,CAAC;AAC9C,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW/D,SAAgB,sBAAsB,MAAoB,OAA2B;AACnF,KAAI;EACF,MAAM,SAASA,+BAAO,OAAO,EAAE,OAAO,OAAO,CAAC;AAC9C,OAAK,MAAM,SAAS,KAClB,QAAO,OAAO,MAAM;AAEtB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgB,SAAS,MAA8B;AACrD,4CAAc,KAAK;;;;;;;;;AAUrB,SAAgB,gBAAgB,SAAqB,MAA8B;AACjF,4CAAc,MAAM,EAAE,KAAK,SAAS,CAAC;;;;;;;;;AAUvC,SAAgB,iBAAiB,MAAkB,OAA2B;AAC5E,4CAAc,MAAM,EAAE,OAAO,OAAO,CAAC"}
+{"version":3,"file":"hash.js","names":["blake3"],"sources":["../src/hash/blake3.ts"],"sourcesContent":["import { blake3 } from '@noble/hashes/blake3.js';\n\n/**\n * Hashes the given array of data\n *\n * @param data - The array of data\n * @returns The resulting hash\n */\nexport function hashDataArray(data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create();\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data with the given key\n *\n * @param hashKey - The key for keyed hashing\n * @param data - The array of data\n * @returns The resulting keyed hash\n */\nexport function hashDataArrayWithKey(hashKey: Uint8Array, data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create({ key: hashKey });\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data to the desired byte-length\n *\n * @param data - The array of data\n * @param bytes - The desired output byte-length\n * @returns The resulting hash of the desired byte-length\n */\nexport function getBytesFromDataArray(data: Uint8Array[], bytes: number): Uint8Array {\n  try {\n    const hasher = blake3.create({ dkLen: bytes });\n    for (const chunk of data) {\n      hasher.update(chunk);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to get bytes from data', { cause: error });\n  }\n}\n\n/**\n * Hashes the given data\n *\n * @param data - The data\n * @returns The resulting hash\n */\nexport function hashData(data: Uint8Array): Uint8Array {\n  return blake3(data);\n}\n\n/**\n * Hashes the given data with the given key\n *\n * @param hashKey - The key for keyed hashing\n * @param data - The data\n * @returns The resulting keyed hash\n */\nexport function hashDataWithKey(hashKey: Uint8Array, data: Uint8Array): Uint8Array {\n  return blake3(data, { key: hashKey });\n}\n\n/**\n * Hashes the given data to the desired byte-length\n *\n * @param data - The data\n * @param bytes - The desired output byte-length\n * @returns The resulting hash of the desired byte-length\n */\nexport function getBytesFromData(data: Uint8Array, bytes: number): Uint8Array {\n  return blake3(data, { dkLen: bytes });\n}\n"],"mappings":";;;;;;;;;;AAQA,SAAgB,cAAc,MAAgC;AAC5D,KAAI;EACF,MAAM,SAASA,wBAAAA,OAAO,QAAQ;AAC9B,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW/D,SAAgB,qBAAqB,SAAqB,MAAgC;AACxF,KAAI;EACF,MAAM,SAASA,wBAAAA,OAAO,OAAO,EAAE,KAAK,SAAS,CAAC;AAC9C,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW/D,SAAgB,sBAAsB,MAAoB,OAA2B;AACnF,KAAI;EACF,MAAM,SAASA,wBAAAA,OAAO,OAAO,EAAE,OAAO,OAAO,CAAC;AAC9C,OAAK,MAAM,SAAS,KAClB,QAAO,OAAO,MAAM;AAEtB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgB,SAAS,MAA8B;AACrD,SAAA,GAAA,wBAAA,QAAc,KAAK;;;;;;;;;AAUrB,SAAgB,gBAAgB,SAAqB,MAA8B;AACjF,SAAA,GAAA,wBAAA,QAAc,MAAM,EAAE,KAAK,SAAS,CAAC;;;;;;;;;AAUvC,SAAgB,iBAAiB,MAAkB,OAA2B;AAC5E,SAAA,GAAA,wBAAA,QAAc,MAAM,EAAE,OAAO,OAAO,CAAC"}