internxt-crypto 0.0.14 → 1.0.1

package/dist/hash.mjs

@@ -1,3 +1,83 @@
-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";
+import { blake3 } from "@noble/hashes/blake3.js";
 
-export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex };
+//#region src/hash/blake3.ts
+/**
+* Hashes the given array of data
+*
+* @param data - The array of data
+* @returns The resulting hash
+*/
+function hashDataArray(data) {
+	try {
+		const hasher = blake3.create();
+		for (const d of data) hasher.update(d);
+		return hasher.digest();
+	} catch (error) {
+		throw new Error("Failed to compute hash", { cause: error });
+	}
+}
+/**
+* Hashes the given array of data with the given key
+*
+* @param hashKey - The key for keyed hashing
+* @param data - The array of data
+* @returns The resulting keyed hash
+*/
+function hashDataArrayWithKey(hashKey, data) {
+	try {
+		const hasher = blake3.create({ key: hashKey });
+		for (const d of data) hasher.update(d);
+		return hasher.digest();
+	} catch (error) {
+		throw new Error("Failed to compute hash", { cause: error });
+	}
+}
+/**
+* Hashes the given array of data to the desired byte-length
+*
+* @param data - The array of data
+* @param bytes - The desired output byte-length
+* @returns The resulting hash of the desired byte-length
+*/
+function getBytesFromDataArray(data, bytes) {
+	try {
+		const hasher = blake3.create({ dkLen: bytes });
+		for (const chunk of data) hasher.update(chunk);
+		return hasher.digest();
+	} catch (error) {
+		throw new Error("Failed to get bytes from data", { cause: error });
+	}
+}
+/**
+* Hashes the given data
+*
+* @param data - The data
+* @returns The resulting hash
+*/
+function hashData(data) {
+	return blake3(data);
+}
+/**
+* Hashes the given data with the given key
+*
+* @param hashKey - The key for keyed hashing
+* @param data - The data
+* @returns The resulting keyed hash
+*/
+function hashDataWithKey(hashKey, data) {
+	return blake3(data, { key: hashKey });
+}
+/**
+* Hashes the given data to the desired byte-length
+*
+* @param data - The data
+* @param bytes - The desired output byte-length
+* @returns The resulting hash of the desired byte-length
+*/
+function getBytesFromData(data, bytes) {
+	return blake3(data, { dkLen: bytes });
+}
+
+//#endregion
+export { getBytesFromData, getBytesFromDataArray, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey };
+//# sourceMappingURL=hash.mjs.map

package/dist/hash.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.mjs","names":[],"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,SAAS,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,SAAS,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,SAAS,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,QAAO,OAAO,KAAK;;;;;;;;;AAUrB,SAAgB,gBAAgB,SAAqB,MAA8B;AACjF,QAAO,OAAO,MAAM,EAAE,KAAK,SAAS,CAAC;;;;;;;;;AAUvC,SAAgB,iBAAiB,MAAkB,OAA2B;AAC5E,QAAO,OAAO,MAAM,EAAE,OAAO,OAAO,CAAC"}

package/dist/index.d.mts

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

package/dist/index.d.mts.map

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

package/dist/index.d.ts

@@ -1,14 +1,15 @@
-import { deriveSecretKey, exportPrivateKey, exportPublicKey, generateEccKeys, importPrivateKey, importPublicKey } from "./asymmetric-crypto.js";
-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.js";
-import { deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, verifyKeyFromPasswordHex } from "./derive-key.js";
-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.js";
+import { deriveSecretKey, generateEccKeys } from "./asymmetric-crypto.js";
+import { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, DB_LABEL, DB_VERSION, IV_LEN_BYTES, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH } from "./constants.js";
+import { deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys } from "./derive-key.js";
+import { getKeyFromPassword, getKeyFromPasswordAndSalt } from "./derive-password.js";
+import { Email, EmailBody, EmailBodyEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, MailCache, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey, StoredEmail, User } from "./types.js";
 import { createPwdProtectedEmail, decryptEmailHybrid, decryptPwdProtectedEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys } from "./email-crypto.js";
 import { addEmailToCache, addEmailToSearchIndex, addEmailsToCache, buildSearchIndexFromCache, closeDatabase, createCacheFromDB, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, encryptAndStoreEmail, encryptAndStoreManyEmail, enforceMaxEmailNumber, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getEmailBatch, getEmailCount, getEmailFromCache, openDatabase, removeEmailFromSearchIndex, searchEmails } from "./email-search.js";
-import { computeMac, getBytesFromData, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex } from "./hash.js";
+import { getBytesFromData, getBytesFromDataArray, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey } from "./hash.js";
 import { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore } from "./keystore-crypto.js";
 import { decapsulateKyber, encapsulateKyber, generateKyberKeys } from "./post-quantum-crypto.js";
-import { decryptSymmetrically, deriveSymmetricCryptoKey, encryptSymmetrically, exportSymmetricCryptoKey, genSymmetricCryptoKey, genSymmetricKey, importSymmetricCryptoKey } from "./symmetric-crypto.js";
-import { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes } from "./utils.js";
+import { decryptSymmetrically, encryptSymmetrically, genSymmetricKey } from "./symmetric-crypto.js";
+import { UTF8ToUint8, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes } from "./utils.js";
 
 //#region src/key-wrapper/aesWrapper.d.ts
 /**
@@ -28,5 +29,5 @@ declare function unwrapKey(encryptedKey: Uint8Array, wrappingKey: Uint8Array): P
  */
 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, 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 };
+export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, DB_LABEL, DB_VERSION, Email, EmailBody, EmailBodyEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, IV_LEN_BYTES, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, MailCache, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey, StoredEmail, UTF8ToUint8, User, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, addEmailToCache, addEmailToSearchIndex, addEmailsToCache, base64ToUint8Array, buildSearchIndexFromCache, bytesToMnemonic, bytesToUuid, closeDatabase, createCacheFromDB, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptAndStoreEmail, encryptAndStoreManyEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, enforceMaxEmailNumber, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getBytesFromData, getBytesFromDataArray, getEmailBatch, getEmailCount, getEmailFromCache, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openDatabase, openEncryptionKeystore, openRecoveryKeystore, removeEmailFromSearchIndex, searchEmails, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -1,36 +1,31 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_asymmetric_crypto = require('./asymmetric-crypto.js');
 const require_constants = require('./constants.js');
-const require_keys = require('./keys-CinT7kEY.js');
-const require_genID = require('./genID-YJSl3YhL.js');
-const require_mac = require('./mac-BMb1F0dN.js');
-const require_aes = require('./aes-DQo1MyCz.js');
-const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-BYaiSGKL.js');
-const require_kyber768 = require('./kyber768-WUVc2fIR.js');
-const require_emailKeys = require('./emailKeys-C0KhtfNP.js');
-const require_email_search = require('./email-search.js');
+const require_genID = require('./genID-cWOPmspk.js');
+const require_deriveKeysFromKey = require('./deriveKeysFromKey-C4McqO6_.js');
+const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-C7xAGGsh.js');
+const require_aes = require('./aes-CuW_SPl-.js');
+const require_core = require('./core-Bj26rNdA.js');
+const require_email_crypto = require('./email-crypto.js');
+const require_search = require('./search-DUTm4-rN.js');
+const require_hash = require('./hash.js');
 const require_types = require('./types.js');
-const require_emailEncryptionKey = require('./emailEncryptionKey-CQNe5W_T.js');
+const require_emailEncryptionKey = require('./emailEncryptionKey-C4X1Bwy4.js');
+const require_post_quantum_crypto = require('./post-quantum-crypto.js');
 
-exports.AES_ALGORITHM = require_constants.AES_ALGORITHM;
-exports.AES_KEY_BIT_LENGTH = require_constants.AES_KEY_BIT_LENGTH;
+exports.AES_KEY_BYTE_LENGTH = require_constants.AES_KEY_BYTE_LENGTH;
 exports.ARGON2ID_ITERATIONS = require_constants.ARGON2ID_ITERATIONS;
 exports.ARGON2ID_MEMORY_SIZE = require_constants.ARGON2ID_MEMORY_SIZE;
 exports.ARGON2ID_OUTPUT_BYTE_LENGTH = require_constants.ARGON2ID_OUTPUT_BYTE_LENGTH;
 exports.ARGON2ID_PARALLELISM = require_constants.ARGON2ID_PARALLELISM;
 exports.ARGON2ID_SALT_BYTE_LENGTH = require_constants.ARGON2ID_SALT_BYTE_LENGTH;
-exports.AUX_BYTE_LEN = require_constants.AUX_BYTE_LEN;
 exports.CONTEXT_DERIVE = require_constants.CONTEXT_DERIVE;
 exports.CONTEXT_ENC_KEYSTORE = require_constants.CONTEXT_ENC_KEYSTORE;
 exports.CONTEXT_INDEX = require_constants.CONTEXT_INDEX;
 exports.CONTEXT_RECOVERY = require_constants.CONTEXT_RECOVERY;
-exports.CONTEXT_WRAPPING = require_constants.CONTEXT_WRAPPING;
 exports.DB_LABEL = require_constants.DB_LABEL;
 exports.DB_VERSION = require_constants.DB_VERSION;
-exports.ECC_ALGORITHM = require_constants.ECC_ALGORITHM;
-exports.HASH_BIT_LEN = require_constants.HASH_BIT_LEN;
 exports.IV_LEN_BYTES = require_constants.IV_LEN_BYTES;
-exports.KEY_FORMAT = require_constants.KEY_FORMAT;
-exports.KEY_WRAPPING_ALGORITHM = require_constants.KEY_WRAPPING_ALGORITHM;
 exports.KYBER768_PUBLIC_KEY_LENGTH = require_constants.KYBER768_PUBLIC_KEY_LENGTH;
 exports.KYBER768_SECRET_KEY_LENGTH = require_constants.KYBER768_SECRET_KEY_LENGTH;
 exports.KYBER_SEED_LENGTH = require_constants.KYBER_SEED_LENGTH;
@@ -42,84 +37,66 @@ exports.XWING_CIPHERTEXT_BYTE_LENGTH = require_constants.XWING_CIPHERTEXT_BYTE_L
 exports.XWING_PUBLIC_KEY_LENGTH = require_constants.XWING_PUBLIC_KEY_LENGTH;
 exports.XWING_SECRET_KEY_LENGTH = require_constants.XWING_SECRET_KEY_LENGTH;
 exports.XWING_SEED_BYTE_LENGTH = require_constants.XWING_SEED_BYTE_LENGTH;
-exports.addEmailToCache = require_email_search.addEmailToCache;
-exports.addEmailToSearchIndex = require_email_search.addEmailToSearchIndex;
-exports.addEmailsToCache = require_email_search.addEmailsToCache;
-exports.base64ToPublicKey = require_genID.base64ToPublicKey;
+exports.addEmailToCache = require_search.addEmailToCache;
+exports.addEmailToSearchIndex = require_search.addEmailToSearchIndex;
+exports.addEmailsToCache = require_search.addEmailsToCache;
 exports.base64ToUint8Array = require_genID.base64ToUint8Array;
-exports.buildSearchIndexFromCache = require_email_search.buildSearchIndexFromCache;
+exports.buildSearchIndexFromCache = require_search.buildSearchIndexFromCache;
 exports.bytesToMnemonic = require_genID.bytesToMnemonic;
 exports.bytesToUuid = require_genID.bytesToUuid;
-exports.closeDatabase = require_email_search.closeDatabase;
-exports.computeMac = require_mac.computeMac;
-exports.createCacheFromDB = require_email_search.createCacheFromDB;
+exports.closeDatabase = require_search.closeDatabase;
+exports.createCacheFromDB = require_search.createCacheFromDB;
 exports.createEncryptionAndRecoveryKeystores = require_emailEncryptionKey.createEncryptionAndRecoveryKeystores;
-exports.createPwdProtectedEmail = require_emailKeys.createPwdProtectedEmail;
-exports.decapsulateKyber = require_kyber768.decapsulateKyber;
-exports.decryptEmailHybrid = require_emailKeys.decryptEmailHybrid;
-exports.decryptPwdProtectedEmail = require_emailKeys.decryptPwdProtectedEmail;
+exports.createPwdProtectedEmail = require_email_crypto.createPwdProtectedEmail;
+exports.decapsulateKyber = require_post_quantum_crypto.decapsulateKyber;
+exports.decryptEmailHybrid = require_email_crypto.decryptEmailHybrid;
+exports.decryptPwdProtectedEmail = require_email_crypto.decryptPwdProtectedEmail;
 exports.decryptSymmetrically = require_aes.decryptSymmetrically;
-exports.deleteEmail = require_email_search.deleteEmail;
-exports.deleteEmailFromCache = require_email_search.deleteEmailFromCache;
-exports.deleteOldestEmails = require_email_search.deleteOldestEmails;
-exports.deriveIndexKey = require_email_search.deriveIndexKey;
-exports.deriveSecretKey = require_keys.deriveSecretKey;
-exports.deriveSymmetricCryptoKey = require_aes.deriveSymmetricCryptoKey;
-exports.deriveSymmetricCryptoKeyFromContext = require_deriveKeysFromPassword.deriveSymmetricCryptoKeyFromContext;
-exports.deriveSymmetricCryptoKeyFromTwoKeys = require_deriveKeysFromPassword.deriveSymmetricCryptoKeyFromTwoKeys;
-exports.deriveSymmetricKeyFromContext = require_deriveKeysFromPassword.deriveSymmetricKeyFromContext;
-exports.deriveSymmetricKeyFromTwoKeys = require_deriveKeysFromPassword.deriveSymmetricKeyFromTwoKeys;
-exports.deriveSymmetricKeyFromTwoKeysAndContext = require_deriveKeysFromPassword.deriveSymmetricKeyFromTwoKeysAndContext;
-exports.encapsulateKyber = require_kyber768.encapsulateKyber;
-exports.encryptAndStoreEmail = require_email_search.encryptAndStoreEmail;
-exports.encryptAndStoreManyEmail = require_email_search.encryptAndStoreManyEmail;
-exports.encryptEmailHybrid = require_emailKeys.encryptEmailHybrid;
-exports.encryptEmailHybridForMultipleRecipients = require_emailKeys.encryptEmailHybridForMultipleRecipients;
+exports.deleteEmail = require_search.deleteEmail;
+exports.deleteEmailFromCache = require_search.deleteEmailFromCache;
+exports.deleteOldestEmails = require_search.deleteOldestEmails;
+exports.deriveIndexKey = require_search.deriveIndexKey;
+exports.deriveSecretKey = require_asymmetric_crypto.deriveSecretKey;
+exports.deriveSymmetricKeyFromContext = require_deriveKeysFromKey.deriveSymmetricKeyFromContext;
+exports.deriveSymmetricKeyFromTwoKeys = require_deriveKeysFromKey.deriveSymmetricKeyFromTwoKeys;
+exports.encapsulateKyber = require_post_quantum_crypto.encapsulateKyber;
+exports.encryptAndStoreEmail = require_search.encryptAndStoreEmail;
+exports.encryptAndStoreManyEmail = require_search.encryptAndStoreManyEmail;
+exports.encryptEmailHybrid = require_email_crypto.encryptEmailHybrid;
+exports.encryptEmailHybridForMultipleRecipients = require_email_crypto.encryptEmailHybridForMultipleRecipients;
 exports.encryptSymmetrically = require_aes.encryptSymmetrically;
-exports.enforceMaxEmailNumber = require_email_search.enforceMaxEmailNumber;
-exports.exportPrivateKey = require_keys.exportPrivateKey;
-exports.exportPublicKey = require_keys.exportPublicKey;
-exports.exportSymmetricCryptoKey = require_aes.exportSymmetricCryptoKey;
+exports.enforceMaxEmailNumber = require_search.enforceMaxEmailNumber;
 exports.genMnemonic = require_genID.genMnemonic;
-exports.genSymmetricCryptoKey = require_aes.genSymmetricCryptoKey;
 exports.genSymmetricKey = require_aes.genSymmetricKey;
-exports.generateEccKeys = require_keys.generateEccKeys;
-exports.generateEmailKeys = require_emailKeys.generateEmailKeys;
-exports.generateKyberKeys = require_kyber768.generateKyberKeys;
+exports.generateEccKeys = require_asymmetric_crypto.generateEccKeys;
+exports.generateEmailKeys = require_email_crypto.generateEmailKeys;
+exports.generateKyberKeys = require_post_quantum_crypto.generateKyberKeys;
 exports.generateUuid = require_genID.generateUuid;
-exports.getAllEmailsSortedNewestFirst = require_email_search.getAllEmailsSortedNewestFirst;
-exports.getAllEmailsSortedOldestFirst = require_email_search.getAllEmailsSortedOldestFirst;
-exports.getAndDecryptAllEmails = require_email_search.getAndDecryptAllEmails;
-exports.getAndDecryptEmail = require_email_search.getAndDecryptEmail;
-exports.getBytesFromData = require_mac.getBytesFromData;
-exports.getBytesFromDataArrayHex = require_mac.getBytesFromDataArrayHex;
-exports.getBytesFromDataHex = require_mac.getBytesFromDataHex;
-exports.getEmailBatch = require_email_search.getEmailBatch;
-exports.getEmailCount = require_email_search.getEmailCount;
-exports.getEmailFromCache = require_email_search.getEmailFromCache;
+exports.getAllEmailsSortedNewestFirst = require_search.getAllEmailsSortedNewestFirst;
+exports.getAllEmailsSortedOldestFirst = require_search.getAllEmailsSortedOldestFirst;
+exports.getAndDecryptAllEmails = require_search.getAndDecryptAllEmails;
+exports.getAndDecryptEmail = require_search.getAndDecryptEmail;
+exports.getBytesFromData = require_hash.getBytesFromData;
+exports.getBytesFromDataArray = require_hash.getBytesFromDataArray;
+exports.getEmailBatch = require_search.getEmailBatch;
+exports.getEmailCount = require_search.getEmailCount;
+exports.getEmailFromCache = require_search.getEmailFromCache;
 exports.getKeyFromPassword = require_deriveKeysFromPassword.getKeyFromPassword;
 exports.getKeyFromPasswordAndSalt = require_deriveKeysFromPassword.getKeyFromPasswordAndSalt;
-exports.getKeyFromPasswordAndSaltHex = require_deriveKeysFromPassword.getKeyFromPasswordAndSaltHex;
-exports.getKeyFromPasswordHex = require_deriveKeysFromPassword.getKeyFromPasswordHex;
-exports.hashDataArray = require_mac.hashDataArray;
-exports.hashDataArrayHex = require_mac.hashDataArrayHex;
-exports.hashDataArrayWithKey = require_mac.hashDataArrayWithKey;
-exports.hashDataArrayWithKeyHex = require_mac.hashDataArrayWithKeyHex;
+exports.hashData = require_hash.hashData;
+exports.hashDataArray = require_hash.hashDataArray;
+exports.hashDataArrayWithKey = require_hash.hashDataArrayWithKey;
+exports.hashDataWithKey = require_hash.hashDataWithKey;
 exports.hexToUint8Array = require_genID.hexToUint8Array;
-exports.importPrivateKey = require_keys.importPrivateKey;
-exports.importPublicKey = require_keys.importPublicKey;
-exports.importSymmetricCryptoKey = require_aes.importSymmetricCryptoKey;
 exports.mnemonicToBytes = require_genID.mnemonicToBytes;
-exports.openDatabase = require_email_search.openDatabase;
+exports.openDatabase = require_search.openDatabase;
 exports.openEncryptionKeystore = require_emailEncryptionKey.openEncryptionKeystore;
 exports.openRecoveryKeystore = require_emailEncryptionKey.openRecoveryKeystore;
-exports.publicKeyToBase64 = require_genID.publicKeyToBase64;
-exports.removeEmailFromSearchIndex = require_email_search.removeEmailFromSearchIndex;
-exports.searchEmails = require_email_search.searchEmails;
+exports.removeEmailFromSearchIndex = require_search.removeEmailFromSearchIndex;
+exports.searchEmails = require_search.searchEmails;
 exports.uint8ArrayToBase64 = require_genID.uint8ArrayToBase64;
 exports.uint8ArrayToHex = require_genID.uint8ArrayToHex;
 exports.uint8ToUTF8 = require_genID.uint8ToUTF8;
-exports.unwrapKey = require_emailKeys.unwrapKey;
+exports.unwrapKey = require_core.unwrapKey;
 exports.uuidToBytes = require_genID.uuidToBytes;
-exports.verifyKeyFromPasswordHex = require_deriveKeysFromPassword.verifyKeyFromPasswordHex;
-exports.wrapKey = require_emailKeys.wrapKey;
+exports.wrapKey = require_core.wrapKey;

package/dist/index.mjs

@@ -1,13 +1,15 @@
-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 { a as importPublicKey, i as importPrivateKey, n as exportPublicKey, o as deriveSecretKey, r as generateEccKeys, t as exportPrivateKey } from "./keys-BfcaiAOv.mjs";
-import { a as genMnemonic, c as publicKeyToBase64, d as hexToUint8Array, f as uint8ArrayToBase64, i as bytesToMnemonic, l as UTF8ToUint8, m as uint8ToUTF8, n as generateUuid, o as mnemonicToBytes, p as uint8ArrayToHex, r as uuidToBytes, s as base64ToPublicKey, t as bytesToUuid, u as base64ToUint8Array } from "./genID-3Er5IowC.mjs";
-import { a as getBytesFromDataHex, c as hashDataArrayWithKey, i as getBytesFromDataArrayHex, l as hashDataArrayWithKeyHex, n as getBytesFromData, o as hashDataArray, s as hashDataArrayHex, t as computeMac } from "./mac-ZpRlx8Fs.mjs";
-import { a as genSymmetricCryptoKey, i as exportSymmetricCryptoKey, n as encryptSymmetrically, o as genSymmetricKey, r as deriveSymmetricCryptoKey, s as importSymmetricCryptoKey, t as decryptSymmetrically } from "./aes-DCb9dJqb.mjs";
-import { a as verifyKeyFromPasswordHex, c as deriveSymmetricKeyFromContext, i as getKeyFromPasswordHex, l as deriveSymmetricKeyFromTwoKeys, n as getKeyFromPasswordAndSalt, o as deriveSymmetricCryptoKeyFromContext, r as getKeyFromPasswordAndSaltHex, s as deriveSymmetricCryptoKeyFromTwoKeys, 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 { a as encryptEmailHybrid, i as decryptEmailHybrid, m as wrapKey, n as createPwdProtectedEmail, o as encryptEmailHybridForMultipleRecipients, p as unwrapKey, r as decryptPwdProtectedEmail, t as generateEmailKeys } from "./emailKeys-D4lp9NRv.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 { deriveSecretKey, generateEccKeys } from "./asymmetric-crypto.mjs";
+import { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, DB_LABEL, DB_VERSION, IV_LEN_BYTES, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH } from "./constants.mjs";
+import { a as genMnemonic, c as base64ToUint8Array, d as uint8ArrayToHex, f as uint8ToUTF8, i as bytesToMnemonic, l as hexToUint8Array, n as generateUuid, o as mnemonicToBytes, r as uuidToBytes, s as UTF8ToUint8, t as bytesToUuid, u as uint8ArrayToBase64 } from "./genID-D08K7JPr.mjs";
+import { n as deriveSymmetricKeyFromTwoKeys, t as deriveSymmetricKeyFromContext } from "./deriveKeysFromKey-DPU_h7wr.mjs";
+import { n as getKeyFromPasswordAndSalt, t as getKeyFromPassword } from "./deriveKeysFromPassword-DXgSvTNC.mjs";
+import { n as encryptSymmetrically, r as genSymmetricKey, t as decryptSymmetrically } from "./aes-B8TA-JKq.mjs";
+import { c as unwrapKey, l as wrapKey } from "./core-pEGygy6S.mjs";
+import { createPwdProtectedEmail, decryptEmailHybrid, decryptPwdProtectedEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys } from "./email-crypto.mjs";
+import { C as getEmailCount, S as getEmailBatch, _ as enforceMaxEmailNumber, a as addEmailToCache, b as getAndDecryptAllEmails, c as deleteEmailFromCache, f as deleteEmail, g as encryptAndStoreManyEmail, h as encryptAndStoreEmail, i as searchEmails, l as getEmailFromCache, m as deriveIndexKey, n as buildSearchIndexFromCache, o as addEmailsToCache, p as deleteOldestEmails, r as removeEmailFromSearchIndex, s as createCacheFromDB, t as addEmailToSearchIndex, u as closeDatabase, v as getAllEmailsSortedNewestFirst, w as openDatabase, x as getAndDecryptEmail, y as getAllEmailsSortedOldestFirst } from "./search-B9YM3XAA.mjs";
+import { getBytesFromData, getBytesFromDataArray, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey } from "./hash.mjs";
 import { KeystoreType } from "./types.mjs";
-import { n as openEncryptionKeystore, r as openRecoveryKeystore, t as createEncryptionAndRecoveryKeystores } from "./emailEncryptionKey-B9xHw1h_.mjs";
+import { n as openEncryptionKeystore, r as openRecoveryKeystore, t as createEncryptionAndRecoveryKeystores } from "./emailEncryptionKey-BtSPYd9M.mjs";
+import { decapsulateKyber, encapsulateKyber, generateKyberKeys } from "./post-quantum-crypto.mjs";
 
-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, HASH_BIT_LEN, 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, UTF8ToUint8, 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 };
+export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, DB_LABEL, DB_VERSION, IV_LEN_BYTES, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, UTF8ToUint8, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, addEmailToCache, addEmailToSearchIndex, addEmailsToCache, base64ToUint8Array, buildSearchIndexFromCache, bytesToMnemonic, bytesToUuid, closeDatabase, createCacheFromDB, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptAndStoreEmail, encryptAndStoreManyEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, enforceMaxEmailNumber, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getBytesFromData, getBytesFromDataArray, getEmailBatch, getEmailCount, getEmailFromCache, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openDatabase, openEncryptionKeystore, openRecoveryKeystore, removeEmailFromSearchIndex, searchEmails, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };

package/dist/keystore-crypto.d.mts

@@ -1,18 +1,18 @@
-import { EmailKeys, EncryptedKeystore } from "./types.mjs";
+import { EncryptedKeystore, HybridKeyPair } from "./types.mjs";
 
 //#region src/keystore-crypto/emailEncryptionKey.d.ts
 /**
- * Generates email keys and creates encrypted main and recovery keystores
+ * Generates hybrid keys and creates encrypted main and recovery keystores
  * The main keystore encryption key is derived from the base key (stored in session storage)
  * The recovery keystore encryption key is derived from the recovery codes
  *
- * @returns The encryption and recovery keystores, recovery codes and email keys
+ * @returns The encryption and recovery keystores, recovery codes and hybrid keys
  */
 declare function createEncryptionAndRecoveryKeystores(userEmail: string, baseKey: Uint8Array): Promise<{
   encryptionKeystore: EncryptedKeystore;
   recoveryKeystore: EncryptedKeystore;
   recoveryCodes: string;
-  keys: EmailKeys;
+  keys: HybridKeyPair;
 }>;
 /**
  * Opens the encryption keystore and returns the email encryption keys
@@ -22,7 +22,7 @@ declare function createEncryptionAndRecoveryKeystores(userEmail: string, baseKey
  * @param baseKey - The base key from which the decryption key will be derived
  * @returns The encryption keys
  */
-declare function openEncryptionKeystore(encryptedKeystore: EncryptedKeystore, baseKey: Uint8Array): Promise<EmailKeys>;
+declare function openEncryptionKeystore(encryptedKeystore: EncryptedKeystore, baseKey: Uint8Array): Promise<HybridKeyPair>;
 /**
  * Opens the recovery keystore and returns the email encryption keys
  * The decryption key is derived from the base key (stored in session storage)
@@ -31,7 +31,7 @@ declare function openEncryptionKeystore(encryptedKeystore: EncryptedKeystore, ba
  * @param encryptedKeystore - The encrypted keystore containing encryption keys
  * @returns The encryption keys
  */
-declare function openRecoveryKeystore(recoveryCodes: string, encryptedKeystore: EncryptedKeystore): Promise<EmailKeys>;
+declare function openRecoveryKeystore(recoveryCodes: string, encryptedKeystore: EncryptedKeystore): Promise<HybridKeyPair>;
 //#endregion
 export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };
 //# sourceMappingURL=keystore-crypto.d.mts.map

package/dist/keystore-crypto.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"keystore-crypto.d.mts","names":[],"sources":["../src/keystore-crypto/emailEncryptionKey.ts"],"mappings":";;;;;AAYA;;;;;iBAAsB,oCAAA,CACpB,SAAA,UACA,OAAA,EAAS,UAAA,GACR,OAAA;EACD,kBAAA,EAAoB,iBAAA;EACpB,gBAAA,EAAkB,iBAAA;EAClB,aAAA;EACA,IAAA,EAAM,SAAA;AAAA;;;;;;;;;iBA0Bc,sBAAA,CACpB,iBAAA,EAAmB,iBAAA,EACnB,OAAA,EAAS,UAAA,GACR,OAAA,CAAQ,SAAA;;;;AAHX;;;;;iBAwBsB,oBAAA,CACpB,aAAA,UACA,iBAAA,EAAmB,iBAAA,GAClB,OAAA,CAAQ,SAAA"}
+{"version":3,"file":"keystore-crypto.d.mts","names":[],"sources":["../src/keystore-crypto/emailEncryptionKey.ts"],"mappings":";;;;;AAYA;;;;;iBAAsB,oCAAA,CACpB,SAAA,UACA,OAAA,EAAS,UAAA,GACR,OAAA;EACD,kBAAA,EAAoB,iBAAA;EACpB,gBAAA,EAAkB,iBAAA;EAClB,aAAA;EACA,IAAA,EAAM,aAAA;AAAA;;;;;;;;;iBA0Bc,sBAAA,CACpB,iBAAA,EAAmB,iBAAA,EACnB,OAAA,EAAS,UAAA,GACR,OAAA,CAAQ,aAAA;;;;AAHX;;;;;iBAwBsB,oBAAA,CACpB,aAAA,UACA,iBAAA,EAAmB,iBAAA,GAClB,OAAA,CAAQ,aAAA"}

package/dist/keystore-crypto.d.ts

@@ -1,18 +1,18 @@
-import { EmailKeys, EncryptedKeystore } from "./types.js";
+import { EncryptedKeystore, HybridKeyPair } from "./types.js";
 
 //#region src/keystore-crypto/emailEncryptionKey.d.ts
 /**
- * Generates email keys and creates encrypted main and recovery keystores
+ * Generates hybrid keys and creates encrypted main and recovery keystores
  * The main keystore encryption key is derived from the base key (stored in session storage)
  * The recovery keystore encryption key is derived from the recovery codes
  *
- * @returns The encryption and recovery keystores, recovery codes and email keys
+ * @returns The encryption and recovery keystores, recovery codes and hybrid keys
  */
 declare function createEncryptionAndRecoveryKeystores(userEmail: string, baseKey: Uint8Array): Promise<{
   encryptionKeystore: EncryptedKeystore;
   recoveryKeystore: EncryptedKeystore;
   recoveryCodes: string;
-  keys: EmailKeys;
+  keys: HybridKeyPair;
 }>;
 /**
  * Opens the encryption keystore and returns the email encryption keys
@@ -22,7 +22,7 @@ declare function createEncryptionAndRecoveryKeystores(userEmail: string, baseKey
  * @param baseKey - The base key from which the decryption key will be derived
  * @returns The encryption keys
  */
-declare function openEncryptionKeystore(encryptedKeystore: EncryptedKeystore, baseKey: Uint8Array): Promise<EmailKeys>;
+declare function openEncryptionKeystore(encryptedKeystore: EncryptedKeystore, baseKey: Uint8Array): Promise<HybridKeyPair>;
 /**
  * Opens the recovery keystore and returns the email encryption keys
  * The decryption key is derived from the base key (stored in session storage)
@@ -31,7 +31,7 @@ declare function openEncryptionKeystore(encryptedKeystore: EncryptedKeystore, ba
  * @param encryptedKeystore - The encrypted keystore containing encryption keys
  * @returns The encryption keys
  */
-declare function openRecoveryKeystore(recoveryCodes: string, encryptedKeystore: EncryptedKeystore): Promise<EmailKeys>;
+declare function openRecoveryKeystore(recoveryCodes: string, encryptedKeystore: EncryptedKeystore): Promise<HybridKeyPair>;
 //#endregion
 export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };
 //# sourceMappingURL=keystore-crypto.d.ts.map

package/dist/keystore-crypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keystore-crypto.d.ts","names":[],"sources":["../src/keystore-crypto/emailEncryptionKey.ts"],"mappings":";;;;;AAYA;;;;;iBAAsB,oCAAA,CACpB,SAAA,UACA,OAAA,EAAS,UAAA,GACR,OAAA;EACD,kBAAA,EAAoB,iBAAA;EACpB,gBAAA,EAAkB,iBAAA;EAClB,aAAA;EACA,IAAA,EAAM,SAAA;AAAA;;;;;;;;;iBA0Bc,sBAAA,CACpB,iBAAA,EAAmB,iBAAA,EACnB,OAAA,EAAS,UAAA,GACR,OAAA,CAAQ,SAAA;;;;AAHX;;;;;iBAwBsB,oBAAA,CACpB,aAAA,UACA,iBAAA,EAAmB,iBAAA,GAClB,OAAA,CAAQ,SAAA"}
+{"version":3,"file":"keystore-crypto.d.ts","names":[],"sources":["../src/keystore-crypto/emailEncryptionKey.ts"],"mappings":";;;;;AAYA;;;;;iBAAsB,oCAAA,CACpB,SAAA,UACA,OAAA,EAAS,UAAA,GACR,OAAA;EACD,kBAAA,EAAoB,iBAAA;EACpB,gBAAA,EAAkB,iBAAA;EAClB,aAAA;EACA,IAAA,EAAM,aAAA;AAAA;;;;;;;;;iBA0Bc,sBAAA,CACpB,iBAAA,EAAmB,iBAAA,EACnB,OAAA,EAAS,UAAA,GACR,OAAA,CAAQ,aAAA;;;;AAHX;;;;;iBAwBsB,oBAAA,CACpB,aAAA,UACA,iBAAA,EAAmB,iBAAA,GAClB,OAAA,CAAQ,aAAA"}

package/dist/keystore-crypto.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_emailEncryptionKey = require('./emailEncryptionKey-CQNe5W_T.js');
+const require_emailEncryptionKey = require('./emailEncryptionKey-C4X1Bwy4.js');
 
 exports.createEncryptionAndRecoveryKeystores = require_emailEncryptionKey.createEncryptionAndRecoveryKeystores;
 exports.openEncryptionKeystore = require_emailEncryptionKey.openEncryptionKeystore;

package/dist/keystore-crypto.mjs

@@ -1,3 +1,3 @@
-import { n as openEncryptionKeystore, r as openRecoveryKeystore, t as createEncryptionAndRecoveryKeystores } from "./emailEncryptionKey-B9xHw1h_.mjs";
+import { n as openEncryptionKeystore, r as openRecoveryKeystore, t as createEncryptionAndRecoveryKeystores } from "./emailEncryptionKey-BtSPYd9M.mjs";
 
 export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };

package/dist/post-quantum-crypto.js

@@ -1,6 +1,51 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_kyber768 = require('./kyber768-WUVc2fIR.js');
+const require_chunk = require('./chunk-EbLFQX5m.js');
+let _noble_post_quantum_ml_kem_js = require("@noble/post-quantum/ml-kem.js");
 
-exports.decapsulateKyber = require_kyber768.decapsulateKyber;
-exports.encapsulateKyber = require_kyber768.encapsulateKyber;
-exports.generateKyberKeys = require_kyber768.generateKyberKeys;
+//#region src/post-quantum-crypto/kyber768.ts
+/**
+* Generates public and secret Kyber keys
+*
+* @param seed - The optional seed
+* @returns The generated Kyber key pair.
+*/
+function generateKyberKeys(seed) {
+	try {
+		return _noble_post_quantum_ml_kem_js.ml_kem768.keygen(seed);
+	} catch (error) {
+		throw new Error("Failed to generate Kyber keys", { cause: error });
+	}
+}
+/**
+* Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
+*
+* @param publicKey - The public Kyber key
+* @returns The resulting encapsulation and the generated shared secret.
+*/
+function encapsulateKyber(publicKey) {
+	try {
+		return _noble_post_quantum_ml_kem_js.ml_kem768.encapsulate(publicKey);
+	} catch (error) {
+		throw new Error("Failed to encapsulate", { cause: error });
+	}
+}
+/**
+* Decapsulates the encapsulated shared secret using Kyber algorithms
+*
+* @param cipherText - The encapsulated key
+* @param secretKey - The private Kyber key
+* @returns The resulting decapsulated shared secret.
+*/
+function decapsulateKyber(cipherText, secretKey) {
+	try {
+		return _noble_post_quantum_ml_kem_js.ml_kem768.decapsulate(cipherText, secretKey);
+	} catch (error) {
+		throw new Error("Failed to decapsulate", { cause: error });
+	}
+}
+
+//#endregion
+exports.decapsulateKyber = decapsulateKyber;
+exports.encapsulateKyber = encapsulateKyber;
+exports.generateKyberKeys = generateKyberKeys;
+//# sourceMappingURL=post-quantum-crypto.js.map

package/dist/post-quantum-crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-quantum-crypto.js","names":["kyber"],"sources":["../src/post-quantum-crypto/kyber768.ts"],"sourcesContent":["import { ml_kem768 as kyber } from '@noble/post-quantum/ml-kem.js';\n\n/**\n * Generates public and secret Kyber keys\n *\n * @param seed - The optional seed\n * @returns The generated Kyber key pair.\n */\nexport function generateKyberKeys(seed?: Uint8Array): {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n} {\n  try {\n    return kyber.keygen(seed);\n  } catch (error) {\n    throw new Error('Failed to generate Kyber keys', { cause: error });\n  }\n}\n\n/**\n * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms\n *\n * @param publicKey - The public Kyber key\n * @returns The resulting encapsulation and the generated shared secret.\n */\nexport function encapsulateKyber(publicKey: Uint8Array): {\n  cipherText: Uint8Array;\n  sharedSecret: Uint8Array;\n} {\n  try {\n    return kyber.encapsulate(publicKey);\n  } catch (error) {\n    throw new Error('Failed to encapsulate', { cause: error });\n  }\n}\n\n/**\n * Decapsulates the encapsulated shared secret using Kyber algorithms\n *\n * @param cipherText - The encapsulated key\n * @param secretKey - The private Kyber key\n * @returns The resulting decapsulated shared secret.\n */\nexport function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array {\n  try {\n    return kyber.decapsulate(cipherText, secretKey);\n  } catch (error) {\n    throw new Error('Failed to decapsulate', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;;AAQA,SAAgB,kBAAkB,MAGhC;AACA,KAAI;AACF,SAAOA,wCAAM,OAAO,KAAK;UAClB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgB,iBAAiB,WAG/B;AACA,KAAI;AACF,SAAOA,wCAAM,YAAY,UAAU;UAC5B,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW9D,SAAgB,iBAAiB,YAAwB,WAAmC;AAC1F,KAAI;AACF,SAAOA,wCAAM,YAAY,YAAY,UAAU;UACxC,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC"}