internxt-crypto 1.3.0 → 1.4.0

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 FailedToDecryptEmail, C as removePasswordProtection, D as EmailPasswordProtectError, E as EmailPasswordOpenError, M as InvalidInputEmail, O as EmailSymmetricDecryptionError, S as passwordProtectKey, T as EmailHybridEncryptionError, _ as decryptEmail, a as decryptPwdProtectedEmailAndSubject, b as encryptEmailWithKey, c as encryptEmailAndSubjectHybridForMultipleRecipients, d as encryptEmailAndSubjectWithKey, f as createPwdProtectedEmail, g as encryptEmailHybridForMultipleRecipients, h as encryptEmailHybrid, i as createPwdProtectedEmailAndSubject, j as FailedToEncryptEmail, k as EmailSymmetricEncryptionError, l as decryptEmailAndSubject, m as decryptEmailHybrid, n as deriveEmailDraftKey, o as decryptEmailAndSubjectHybrid, p as decryptPwdProtectedEmail, r as generateEmailKeys, s as encryptEmailAndSubjectHybrid, t as deriveDatabaseKey, u as encryptEmailAndSubject, v as decryptKeysHybrid, w as EmailHybridDecryptionError, x as encryptKeysHybrid, y as encryptEmail } from "./email-crypto-DpjfXDes.mjs";
+export { EmailHybridDecryptionError, EmailHybridEncryptionError, EmailPasswordOpenError, EmailPasswordProtectError, EmailSymmetricDecryptionError, EmailSymmetricEncryptionError, FailedToDecryptEmail, FailedToEncryptEmail, InvalidInputEmail, createPwdProtectedEmail, createPwdProtectedEmailAndSubject, decryptEmail, decryptEmailAndSubject, decryptEmailAndSubjectHybrid, decryptEmailHybrid, decryptKeysHybrid, decryptPwdProtectedEmail, decryptPwdProtectedEmailAndSubject, deriveDatabaseKey, deriveEmailDraftKey, encryptEmail, encryptEmailAndSubject, encryptEmailAndSubjectHybrid, encryptEmailAndSubjectHybridForMultipleRecipients, encryptEmailAndSubjectWithKey, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptEmailWithKey, 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"}

package/dist/hash.mjs

@@ -1,5 +1,4 @@
 import { blake3 } from "@noble/hashes/blake3.js";
-
 //#region src/hash/blake3.ts
 /**
 * Hashes the given array of data
@@ -77,7 +76,7 @@ function hashDataWithKey(hashKey, data) {
 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

@@ -1 +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"}
+{"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

@@ -2,8 +2,8 @@ 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_DATABASE, CONTEXT_DRAFT, CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY, CONTEXT_TWO_KEYS, 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 { deriveKeyFromMnemonic, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys } from "./derive-key.mjs";
 import { generateSalt, getKeyFromPassword, getKeyFromPasswordAndSalt } from "./derive-password.mjs";
-import { EmailBody, EmailBodyEncrypted, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey } from "./types.mjs";
-import { createPwdProtectedEmail, decryptEmailBody, decryptEmailHybrid, decryptPwdProtectedEmail, deriveDatabaseKey, deriveEmailDraftKey, encryptEmailBody, encryptEmailBodyWithKey, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys } from "./email-crypto.mjs";
+import { a as EncryptedKeystore, c as HybridEncryptedEmailAndSubject, d as PwdProtectedEmail, f as PwdProtectedEmailAndSubject, i as EmailEncrypted, l as HybridKeyPair, m as RecipientWithPublicKey, n as EmailAndSubject, o as HybridEncKey, p as PwdProtectedKey, r as EmailAndSubjectEncrypted, s as HybridEncryptedEmail, t as Email, u as KeystoreType } from "./types-D6hsUfma.mjs";
+import { EmailHybridDecryptionError, EmailHybridEncryptionError, EmailPasswordOpenError, EmailPasswordProtectError, EmailSymmetricDecryptionError, EmailSymmetricEncryptionError, FailedToDecryptEmail, FailedToEncryptEmail, InvalidInputEmail, createPwdProtectedEmail, createPwdProtectedEmailAndSubject, decryptEmail, decryptEmailAndSubject, decryptEmailAndSubjectHybrid, decryptEmailHybrid, decryptPwdProtectedEmail, decryptPwdProtectedEmailAndSubject, deriveDatabaseKey, deriveEmailDraftKey, encryptEmail, encryptEmailAndSubject, encryptEmailAndSubjectHybrid, encryptEmailAndSubjectHybridForMultipleRecipients, encryptEmailAndSubjectWithKey, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptEmailWithKey, generateEmailKeys } from "./email-crypto.mjs";
 import { getBytesFromData, getBytesFromDataArray, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey } from "./hash.mjs";
 import { FailedToChangeMnemonicForKeyStore, FailedToCreateKeyStores, FailedToOpenEncryptionKeyStore, FailedToOpenRecoveryKeyStore, InvalidInputKeyStore, changeMnemonicForEncryptionKeystore, createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore } from "./keystore-crypto.mjs";
 import { decapsulateKyber, encapsulateKyber, generateKyberKeys } from "./post-quantum-crypto.mjs";
@@ -28,5 +28,5 @@ declare function unwrapKey(encryptedKey: Uint8Array, wrappingKey: Uint8Array): P
  */
 declare function wrapKey(key: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array>;
 //#endregion
-export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DATABASE, CONTEXT_DRAFT, CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY, CONTEXT_TWO_KEYS, DB_LABEL, DB_VERSION, EmailBody, EmailBodyEncrypted, EncryptedKeystore, FailedToChangeMnemonicForKeyStore, FailedToCreateKeyStores, FailedToOpenEncryptionKeyStore, FailedToOpenRecoveryKeyStore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, IV_LEN_BYTES, InvalidInputKeyStore, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey, UTF8ToUint8, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, base64ToUint8Array, bytesToMnemonic, bytesToUuid, changeMnemonicForEncryptionKeystore, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailBody, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deriveDatabaseKey, deriveEmailDraftKey, deriveKeyFromMnemonic, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptEmailBody, encryptEmailBodyWithKey, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateSalt, generateUuid, getBytesFromData, getBytesFromDataArray, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openEncryptionKeystore, openRecoveryKeystore, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };
+export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DATABASE, CONTEXT_DRAFT, CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY, CONTEXT_TWO_KEYS, DB_LABEL, DB_VERSION, Email, EmailAndSubject, EmailAndSubjectEncrypted, EmailEncrypted, EmailHybridDecryptionError, EmailHybridEncryptionError, EmailPasswordOpenError, EmailPasswordProtectError, EmailSymmetricDecryptionError, EmailSymmetricEncryptionError, EncryptedKeystore, FailedToChangeMnemonicForKeyStore, FailedToCreateKeyStores, FailedToDecryptEmail, FailedToEncryptEmail, FailedToOpenEncryptionKeyStore, FailedToOpenRecoveryKeyStore, HybridEncKey, HybridEncryptedEmail, HybridEncryptedEmailAndSubject, HybridKeyPair, IV_LEN_BYTES, InvalidInputEmail, InvalidInputKeyStore, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, PwdProtectedEmail, PwdProtectedEmailAndSubject, PwdProtectedKey, RecipientWithPublicKey, UTF8ToUint8, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, base64ToUint8Array, bytesToMnemonic, bytesToUuid, changeMnemonicForEncryptionKeystore, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, createPwdProtectedEmailAndSubject, decapsulateKyber, decryptEmail, decryptEmailAndSubject, decryptEmailAndSubjectHybrid, decryptEmailHybrid, decryptPwdProtectedEmail, decryptPwdProtectedEmailAndSubject, decryptSymmetrically, deriveDatabaseKey, deriveEmailDraftKey, deriveKeyFromMnemonic, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptEmail, encryptEmailAndSubject, encryptEmailAndSubjectHybrid, encryptEmailAndSubjectHybridForMultipleRecipients, encryptEmailAndSubjectWithKey, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptEmailWithKey, encryptSymmetrically, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateSalt, generateUuid, getBytesFromData, getBytesFromDataArray, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openEncryptionKeystore, openRecoveryKeystore, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.ts

@@ -2,8 +2,8 @@ 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_DATABASE, CONTEXT_DRAFT, CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY, CONTEXT_TWO_KEYS, 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 { deriveKeyFromMnemonic, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys } from "./derive-key.js";
 import { generateSalt, getKeyFromPassword, getKeyFromPasswordAndSalt } from "./derive-password.js";
-import { EmailBody, EmailBodyEncrypted, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey } from "./types.js";
-import { createPwdProtectedEmail, decryptEmailBody, decryptEmailHybrid, decryptPwdProtectedEmail, deriveDatabaseKey, deriveEmailDraftKey, encryptEmailBody, encryptEmailBodyWithKey, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys } from "./email-crypto.js";
+import { a as EncryptedKeystore, c as HybridEncryptedEmailAndSubject, d as PwdProtectedEmail, f as PwdProtectedEmailAndSubject, i as EmailEncrypted, l as HybridKeyPair, m as RecipientWithPublicKey, n as EmailAndSubject, o as HybridEncKey, p as PwdProtectedKey, r as EmailAndSubjectEncrypted, s as HybridEncryptedEmail, t as Email, u as KeystoreType } from "./types-CrAiKyb0.js";
+import { EmailHybridDecryptionError, EmailHybridEncryptionError, EmailPasswordOpenError, EmailPasswordProtectError, EmailSymmetricDecryptionError, EmailSymmetricEncryptionError, FailedToDecryptEmail, FailedToEncryptEmail, InvalidInputEmail, createPwdProtectedEmail, createPwdProtectedEmailAndSubject, decryptEmail, decryptEmailAndSubject, decryptEmailAndSubjectHybrid, decryptEmailHybrid, decryptPwdProtectedEmail, decryptPwdProtectedEmailAndSubject, deriveDatabaseKey, deriveEmailDraftKey, encryptEmail, encryptEmailAndSubject, encryptEmailAndSubjectHybrid, encryptEmailAndSubjectHybridForMultipleRecipients, encryptEmailAndSubjectWithKey, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptEmailWithKey, generateEmailKeys } from "./email-crypto.js";
 import { getBytesFromData, getBytesFromDataArray, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey } from "./hash.js";
 import { FailedToChangeMnemonicForKeyStore, FailedToCreateKeyStores, FailedToOpenEncryptionKeyStore, FailedToOpenRecoveryKeyStore, InvalidInputKeyStore, changeMnemonicForEncryptionKeystore, createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore } from "./keystore-crypto.js";
 import { decapsulateKyber, encapsulateKyber, generateKyberKeys } from "./post-quantum-crypto.js";
@@ -28,5 +28,5 @@ declare function unwrapKey(encryptedKey: Uint8Array, wrappingKey: Uint8Array): P
  */
 declare function wrapKey(key: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array>;
 //#endregion
-export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DATABASE, CONTEXT_DRAFT, CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY, CONTEXT_TWO_KEYS, DB_LABEL, DB_VERSION, EmailBody, EmailBodyEncrypted, EncryptedKeystore, FailedToChangeMnemonicForKeyStore, FailedToCreateKeyStores, FailedToOpenEncryptionKeyStore, FailedToOpenRecoveryKeyStore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, IV_LEN_BYTES, InvalidInputKeyStore, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey, UTF8ToUint8, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, base64ToUint8Array, bytesToMnemonic, bytesToUuid, changeMnemonicForEncryptionKeystore, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailBody, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deriveDatabaseKey, deriveEmailDraftKey, deriveKeyFromMnemonic, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptEmailBody, encryptEmailBodyWithKey, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateSalt, generateUuid, getBytesFromData, getBytesFromDataArray, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openEncryptionKeystore, openRecoveryKeystore, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };
+export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DATABASE, CONTEXT_DRAFT, CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY, CONTEXT_TWO_KEYS, DB_LABEL, DB_VERSION, Email, EmailAndSubject, EmailAndSubjectEncrypted, EmailEncrypted, EmailHybridDecryptionError, EmailHybridEncryptionError, EmailPasswordOpenError, EmailPasswordProtectError, EmailSymmetricDecryptionError, EmailSymmetricEncryptionError, EncryptedKeystore, FailedToChangeMnemonicForKeyStore, FailedToCreateKeyStores, FailedToDecryptEmail, FailedToEncryptEmail, FailedToOpenEncryptionKeyStore, FailedToOpenRecoveryKeyStore, HybridEncKey, HybridEncryptedEmail, HybridEncryptedEmailAndSubject, HybridKeyPair, IV_LEN_BYTES, InvalidInputEmail, InvalidInputKeyStore, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, PwdProtectedEmail, PwdProtectedEmailAndSubject, PwdProtectedKey, RecipientWithPublicKey, UTF8ToUint8, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, base64ToUint8Array, bytesToMnemonic, bytesToUuid, changeMnemonicForEncryptionKeystore, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, createPwdProtectedEmailAndSubject, decapsulateKyber, decryptEmail, decryptEmailAndSubject, decryptEmailAndSubjectHybrid, decryptEmailHybrid, decryptPwdProtectedEmail, decryptPwdProtectedEmailAndSubject, decryptSymmetrically, deriveDatabaseKey, deriveEmailDraftKey, deriveKeyFromMnemonic, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptEmail, encryptEmailAndSubject, encryptEmailAndSubjectHybrid, encryptEmailAndSubjectHybridForMultipleRecipients, encryptEmailAndSubjectWithKey, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptEmailWithKey, encryptSymmetrically, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateSalt, generateUuid, getBytesFromData, getBytesFromDataArray, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openEncryptionKeystore, openRecoveryKeystore, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,16 +1,15 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_asymmetric_crypto = require('./asymmetric-crypto.js');
-const require_constants = require('./constants.js');
-const require_genID = require('./genID-cWOPmspk.js');
-const require_deriveKeysFromMnemonic = require('./deriveKeysFromMnemonic-Dbx7VSBQ.js');
-const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-iMHv-tIA.js');
-const require_aes = require('./aes-CuW_SPl-.js');
-const require_emailKeys = require('./emailKeys-BFI-paQq.js');
-const require_hash = require('./hash.js');
-const require_types = require('./types.js');
-const require_emailEncryptionKey = require('./emailEncryptionKey-Ba95VuFO.js');
-const require_post_quantum_crypto = require('./post-quantum-crypto.js');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_asymmetric_crypto = require("./asymmetric-crypto.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_email_crypto = require("./email-crypto-Di814Pbk.js");
+const require_hash = require("./hash.js");
+const require_types = require("./types.js");
+const require_keystore_crypto = require("./keystore-crypto-CFiiGohl.js");
+const require_post_quantum_crypto = require("./post-quantum-crypto.js");
 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;
@@ -24,68 +23,85 @@ exports.CONTEXT_RECOVERY = require_constants.CONTEXT_RECOVERY;
 exports.CONTEXT_TWO_KEYS = require_constants.CONTEXT_TWO_KEYS;
 exports.DB_LABEL = require_constants.DB_LABEL;
 exports.DB_VERSION = require_constants.DB_VERSION;
-exports.FailedToChangeMnemonicForKeyStore = require_emailEncryptionKey.FailedToChangeMnemonicForKeyStore;
-exports.FailedToCreateKeyStores = require_emailEncryptionKey.FailedToCreateKeyStores;
-exports.FailedToOpenEncryptionKeyStore = require_emailEncryptionKey.FailedToOpenEncryptionKeyStore;
-exports.FailedToOpenRecoveryKeyStore = require_emailEncryptionKey.FailedToOpenRecoveryKeyStore;
+exports.EmailHybridDecryptionError = require_email_crypto.EmailHybridDecryptionError;
+exports.EmailHybridEncryptionError = require_email_crypto.EmailHybridEncryptionError;
+exports.EmailPasswordOpenError = require_email_crypto.EmailPasswordOpenError;
+exports.EmailPasswordProtectError = require_email_crypto.EmailPasswordProtectError;
+exports.EmailSymmetricDecryptionError = require_email_crypto.EmailSymmetricDecryptionError;
+exports.EmailSymmetricEncryptionError = require_email_crypto.EmailSymmetricEncryptionError;
+exports.FailedToChangeMnemonicForKeyStore = require_keystore_crypto.FailedToChangeMnemonicForKeyStore;
+exports.FailedToCreateKeyStores = require_keystore_crypto.FailedToCreateKeyStores;
+exports.FailedToDecryptEmail = require_email_crypto.FailedToDecryptEmail;
+exports.FailedToEncryptEmail = require_email_crypto.FailedToEncryptEmail;
+exports.FailedToOpenEncryptionKeyStore = require_keystore_crypto.FailedToOpenEncryptionKeyStore;
+exports.FailedToOpenRecoveryKeyStore = require_keystore_crypto.FailedToOpenRecoveryKeyStore;
 exports.IV_LEN_BYTES = require_constants.IV_LEN_BYTES;
-exports.InvalidInputKeyStore = require_emailEncryptionKey.InvalidInputKeyStore;
+exports.InvalidInputEmail = require_email_crypto.InvalidInputEmail;
+exports.InvalidInputKeyStore = require_keystore_crypto.InvalidInputKeyStore;
 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;
 exports.KeystoreType = require_types.KeystoreType;
 exports.MAX_CACHE_SIZE = require_constants.MAX_CACHE_SIZE;
 exports.MAX_EMAIL_PER_BATCH = require_constants.MAX_EMAIL_PER_BATCH;
-exports.UTF8ToUint8 = require_genID.UTF8ToUint8;
+exports.UTF8ToUint8 = require_utils.UTF8ToUint8;
 exports.XWING_CIPHERTEXT_BYTE_LENGTH = require_constants.XWING_CIPHERTEXT_BYTE_LENGTH;
 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.base64ToUint8Array = require_genID.base64ToUint8Array;
-exports.bytesToMnemonic = require_genID.bytesToMnemonic;
-exports.bytesToUuid = require_genID.bytesToUuid;
-exports.changeMnemonicForEncryptionKeystore = require_emailEncryptionKey.changeMnemonicForEncryptionKeystore;
-exports.createEncryptionAndRecoveryKeystores = require_emailEncryptionKey.createEncryptionAndRecoveryKeystores;
-exports.createPwdProtectedEmail = require_emailKeys.createPwdProtectedEmail;
+exports.base64ToUint8Array = require_utils.base64ToUint8Array;
+exports.bytesToMnemonic = require_utils.bytesToMnemonic;
+exports.bytesToUuid = require_utils.bytesToUuid;
+exports.changeMnemonicForEncryptionKeystore = require_keystore_crypto.changeMnemonicForEncryptionKeystore;
+exports.createEncryptionAndRecoveryKeystores = require_keystore_crypto.createEncryptionAndRecoveryKeystores;
+exports.createPwdProtectedEmail = require_email_crypto.createPwdProtectedEmail;
+exports.createPwdProtectedEmailAndSubject = require_email_crypto.createPwdProtectedEmailAndSubject;
 exports.decapsulateKyber = require_post_quantum_crypto.decapsulateKyber;
-exports.decryptEmailBody = require_emailKeys.decryptEmailBody;
-exports.decryptEmailHybrid = require_emailKeys.decryptEmailHybrid;
-exports.decryptPwdProtectedEmail = require_emailKeys.decryptPwdProtectedEmail;
-exports.decryptSymmetrically = require_aes.decryptSymmetrically;
-exports.deriveDatabaseKey = require_emailKeys.deriveDatabaseKey;
-exports.deriveEmailDraftKey = require_emailKeys.deriveEmailDraftKey;
-exports.deriveKeyFromMnemonic = require_deriveKeysFromMnemonic.deriveKeyFromMnemonic;
+exports.decryptEmail = require_email_crypto.decryptEmail;
+exports.decryptEmailAndSubject = require_email_crypto.decryptEmailAndSubject;
+exports.decryptEmailAndSubjectHybrid = require_email_crypto.decryptEmailAndSubjectHybrid;
+exports.decryptEmailHybrid = require_email_crypto.decryptEmailHybrid;
+exports.decryptPwdProtectedEmail = require_email_crypto.decryptPwdProtectedEmail;
+exports.decryptPwdProtectedEmailAndSubject = require_email_crypto.decryptPwdProtectedEmailAndSubject;
+exports.decryptSymmetrically = require_symmetric_crypto.decryptSymmetrically;
+exports.deriveDatabaseKey = require_email_crypto.deriveDatabaseKey;
+exports.deriveEmailDraftKey = require_email_crypto.deriveEmailDraftKey;
+exports.deriveKeyFromMnemonic = require_derive_key.deriveKeyFromMnemonic;
 exports.deriveSecretKey = require_asymmetric_crypto.deriveSecretKey;
-exports.deriveSymmetricKeyFromContext = require_deriveKeysFromMnemonic.deriveSymmetricKeyFromContext;
-exports.deriveSymmetricKeyFromTwoKeys = require_deriveKeysFromMnemonic.deriveSymmetricKeyFromTwoKeys;
+exports.deriveSymmetricKeyFromContext = require_derive_key.deriveSymmetricKeyFromContext;
+exports.deriveSymmetricKeyFromTwoKeys = require_derive_key.deriveSymmetricKeyFromTwoKeys;
 exports.encapsulateKyber = require_post_quantum_crypto.encapsulateKyber;
-exports.encryptEmailBody = require_emailKeys.encryptEmailBody;
-exports.encryptEmailBodyWithKey = require_emailKeys.encryptEmailBodyWithKey;
-exports.encryptEmailHybrid = require_emailKeys.encryptEmailHybrid;
-exports.encryptEmailHybridForMultipleRecipients = require_emailKeys.encryptEmailHybridForMultipleRecipients;
-exports.encryptSymmetrically = require_aes.encryptSymmetrically;
-exports.genMnemonic = require_genID.genMnemonic;
-exports.genSymmetricKey = require_aes.genSymmetricKey;
+exports.encryptEmail = require_email_crypto.encryptEmail;
+exports.encryptEmailAndSubject = require_email_crypto.encryptEmailAndSubject;
+exports.encryptEmailAndSubjectHybrid = require_email_crypto.encryptEmailAndSubjectHybrid;
+exports.encryptEmailAndSubjectHybridForMultipleRecipients = require_email_crypto.encryptEmailAndSubjectHybridForMultipleRecipients;
+exports.encryptEmailAndSubjectWithKey = require_email_crypto.encryptEmailAndSubjectWithKey;
+exports.encryptEmailHybrid = require_email_crypto.encryptEmailHybrid;
+exports.encryptEmailHybridForMultipleRecipients = require_email_crypto.encryptEmailHybridForMultipleRecipients;
+exports.encryptEmailWithKey = require_email_crypto.encryptEmailWithKey;
+exports.encryptSymmetrically = require_symmetric_crypto.encryptSymmetrically;
+exports.genMnemonic = require_utils.genMnemonic;
+exports.genSymmetricKey = require_symmetric_crypto.genSymmetricKey;
 exports.generateEccKeys = require_asymmetric_crypto.generateEccKeys;
-exports.generateEmailKeys = require_emailKeys.generateEmailKeys;
+exports.generateEmailKeys = require_email_crypto.generateEmailKeys;
 exports.generateKyberKeys = require_post_quantum_crypto.generateKyberKeys;
-exports.generateSalt = require_deriveKeysFromPassword.generateSalt;
-exports.generateUuid = require_genID.generateUuid;
+exports.generateSalt = require_derive_password.generateSalt;
+exports.generateUuid = require_utils.generateUuid;
 exports.getBytesFromData = require_hash.getBytesFromData;
 exports.getBytesFromDataArray = require_hash.getBytesFromDataArray;
-exports.getKeyFromPassword = require_deriveKeysFromPassword.getKeyFromPassword;
-exports.getKeyFromPasswordAndSalt = require_deriveKeysFromPassword.getKeyFromPasswordAndSalt;
+exports.getKeyFromPassword = require_derive_password.getKeyFromPassword;
+exports.getKeyFromPasswordAndSalt = require_derive_password.getKeyFromPasswordAndSalt;
 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.mnemonicToBytes = require_genID.mnemonicToBytes;
-exports.openEncryptionKeystore = require_emailEncryptionKey.openEncryptionKeystore;
-exports.openRecoveryKeystore = require_emailEncryptionKey.openRecoveryKeystore;
-exports.uint8ArrayToBase64 = require_genID.uint8ArrayToBase64;
-exports.uint8ArrayToHex = require_genID.uint8ArrayToHex;
-exports.uint8ToUTF8 = require_genID.uint8ToUTF8;
-exports.unwrapKey = require_emailKeys.unwrapKey;
-exports.uuidToBytes = require_genID.uuidToBytes;
-exports.wrapKey = require_emailKeys.wrapKey;
+exports.hexToUint8Array = require_utils.hexToUint8Array;
+exports.mnemonicToBytes = require_utils.mnemonicToBytes;
+exports.openEncryptionKeystore = require_keystore_crypto.openEncryptionKeystore;
+exports.openRecoveryKeystore = require_keystore_crypto.openRecoveryKeystore;
+exports.uint8ArrayToBase64 = require_utils.uint8ArrayToBase64;
+exports.uint8ArrayToHex = require_utils.uint8ArrayToHex;
+exports.uint8ToUTF8 = require_utils.uint8ToUTF8;
+exports.unwrapKey = require_email_crypto.unwrapKey;
+exports.uuidToBytes = require_utils.uuidToBytes;
+exports.wrapKey = require_email_crypto.wrapKey;

package/dist/index.mjs

@@ -1,13 +1,12 @@
 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_DATABASE, CONTEXT_DRAFT, CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY, CONTEXT_TWO_KEYS, 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 deriveSymmetricKeyFromContext, r as deriveSymmetricKeyFromTwoKeys, t as deriveKeyFromMnemonic } from "./deriveKeysFromMnemonic-DB0UHE-y.mjs";
-import { n as getKeyFromPassword, r as getKeyFromPasswordAndSalt, t as generateSalt } from "./deriveKeysFromPassword-DFzo2OII.mjs";
-import { n as encryptSymmetrically, r as genSymmetricKey, t as decryptSymmetrically } from "./aes-B8TA-JKq.mjs";
-import { _ as wrapKey, a as decryptPwdProtectedEmail, c as encryptEmailHybridForMultipleRecipients, d as encryptEmailBody, f as encryptEmailBodyWithKey, g as unwrapKey, i as createPwdProtectedEmail, l as decryptEmailBody, n as deriveEmailDraftKey, o as decryptEmailHybrid, r as generateEmailKeys, s as encryptEmailHybrid, t as deriveDatabaseKey } from "./emailKeys-BjIeINfC.mjs";
+import { UTF8ToUint8, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes } from "./utils.mjs";
+import { deriveKeyFromMnemonic, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys } from "./derive-key.mjs";
+import { n as getKeyFromPassword, r as getKeyFromPasswordAndSalt, t as generateSalt } from "./derive-password-PED-YfwE.mjs";
+import { decryptSymmetrically, encryptSymmetrically, genSymmetricKey } from "./symmetric-crypto.mjs";
+import { A as FailedToDecryptEmail, D as EmailPasswordProtectError, E as EmailPasswordOpenError, M as InvalidInputEmail, N as unwrapKey, O as EmailSymmetricDecryptionError, P as wrapKey, T as EmailHybridEncryptionError, _ as decryptEmail, a as decryptPwdProtectedEmailAndSubject, b as encryptEmailWithKey, c as encryptEmailAndSubjectHybridForMultipleRecipients, d as encryptEmailAndSubjectWithKey, f as createPwdProtectedEmail, g as encryptEmailHybridForMultipleRecipients, h as encryptEmailHybrid, i as createPwdProtectedEmailAndSubject, j as FailedToEncryptEmail, k as EmailSymmetricEncryptionError, l as decryptEmailAndSubject, m as decryptEmailHybrid, n as deriveEmailDraftKey, o as decryptEmailAndSubjectHybrid, p as decryptPwdProtectedEmail, r as generateEmailKeys, s as encryptEmailAndSubjectHybrid, t as deriveDatabaseKey, u as encryptEmailAndSubject, w as EmailHybridDecryptionError, y as encryptEmail } from "./email-crypto-DpjfXDes.mjs";
 import { getBytesFromData, getBytesFromDataArray, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey } from "./hash.mjs";
 import { KeystoreType } from "./types.mjs";
-import { a as FailedToChangeMnemonicForKeyStore, c as FailedToOpenRecoveryKeyStore, i as openRecoveryKeystore, l as InvalidInputKeyStore, n as createEncryptionAndRecoveryKeystores, o as FailedToCreateKeyStores, r as openEncryptionKeystore, s as FailedToOpenEncryptionKeyStore, t as changeMnemonicForEncryptionKeystore } from "./emailEncryptionKey-CYvr26FG.mjs";
+import { a as FailedToChangeMnemonicForKeyStore, c as FailedToOpenRecoveryKeyStore, i as openRecoveryKeystore, l as InvalidInputKeyStore, n as createEncryptionAndRecoveryKeystores, o as FailedToCreateKeyStores, r as openEncryptionKeystore, s as FailedToOpenEncryptionKeyStore, t as changeMnemonicForEncryptionKeystore } from "./keystore-crypto-C6F-NQdX.mjs";
 import { decapsulateKyber, encapsulateKyber, generateKyberKeys } from "./post-quantum-crypto.mjs";
-
-export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DATABASE, CONTEXT_DRAFT, CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY, CONTEXT_TWO_KEYS, DB_LABEL, DB_VERSION, FailedToChangeMnemonicForKeyStore, FailedToCreateKeyStores, FailedToOpenEncryptionKeyStore, FailedToOpenRecoveryKeyStore, IV_LEN_BYTES, InvalidInputKeyStore, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, UTF8ToUint8, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, base64ToUint8Array, bytesToMnemonic, bytesToUuid, changeMnemonicForEncryptionKeystore, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailBody, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deriveDatabaseKey, deriveEmailDraftKey, deriveKeyFromMnemonic, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptEmailBody, encryptEmailBodyWithKey, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateSalt, generateUuid, getBytesFromData, getBytesFromDataArray, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openEncryptionKeystore, openRecoveryKeystore, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };
+export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DATABASE, CONTEXT_DRAFT, CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY, CONTEXT_TWO_KEYS, DB_LABEL, DB_VERSION, EmailHybridDecryptionError, EmailHybridEncryptionError, EmailPasswordOpenError, EmailPasswordProtectError, EmailSymmetricDecryptionError, EmailSymmetricEncryptionError, FailedToChangeMnemonicForKeyStore, FailedToCreateKeyStores, FailedToDecryptEmail, FailedToEncryptEmail, FailedToOpenEncryptionKeyStore, FailedToOpenRecoveryKeyStore, IV_LEN_BYTES, InvalidInputEmail, InvalidInputKeyStore, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, UTF8ToUint8, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, base64ToUint8Array, bytesToMnemonic, bytesToUuid, changeMnemonicForEncryptionKeystore, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, createPwdProtectedEmailAndSubject, decapsulateKyber, decryptEmail, decryptEmailAndSubject, decryptEmailAndSubjectHybrid, decryptEmailHybrid, decryptPwdProtectedEmail, decryptPwdProtectedEmailAndSubject, decryptSymmetrically, deriveDatabaseKey, deriveEmailDraftKey, deriveKeyFromMnemonic, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptEmail, encryptEmailAndSubject, encryptEmailAndSubjectHybrid, encryptEmailAndSubjectHybridForMultipleRecipients, encryptEmailAndSubjectWithKey, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptEmailWithKey, encryptSymmetrically, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateSalt, generateUuid, getBytesFromData, getBytesFromDataArray, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openEncryptionKeystore, openRecoveryKeystore, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };

package/dist/{emailEncryptionKey-CYvr26FG.mjs → keystore-crypto-C6F-NQdX.mjs}

@@ -1,10 +1,9 @@
 import { CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY } from "./constants.mjs";
-import { a as genMnemonic, c as base64ToUint8Array, s as UTF8ToUint8, u as uint8ArrayToBase64 } from "./genID-D08K7JPr.mjs";
-import { t as deriveKeyFromMnemonic } from "./deriveKeysFromMnemonic-DB0UHE-y.mjs";
-import { n as encryptSymmetrically, t as decryptSymmetrically } from "./aes-B8TA-JKq.mjs";
-import { r as genHybridKeys } from "./xwing-CQmQX6hn.mjs";
-import { KeystoreType } from "./types.mjs";
-
+import { UTF8ToUint8, base64ToUint8Array, genMnemonic, uint8ArrayToBase64 } from "./utils.mjs";
+import { deriveKeyFromMnemonic } from "./derive-key.mjs";
+import { decryptSymmetrically, encryptSymmetrically } from "./symmetric-crypto.mjs";
+import { r as genHybridKeys } from "./xwing-B34h5e3Z.mjs";
+import "./types.mjs";
 //#region src/keystore-crypto/core.ts
 /**
 * Encrypts the user's hybrid key using symmetric encryption to get a keystore
@@ -65,7 +64,6 @@ async function deriveRecoveryKey(recoveryCodes) {
 async function deriveEncryptionKeystoreKeyFromMnemonic(mnemonic) {
 	return deriveKeyFromMnemonic(mnemonic, CONTEXT_ENC_KEYSTORE);
 }
-
 //#endregion
 //#region src/keystore-crypto/errors.ts
 var FailedToCreateKeyStores = class FailedToCreateKeyStores extends Error {
@@ -98,7 +96,6 @@ var FailedToChangeMnemonicForKeyStore = class FailedToChangeMnemonicForKeyStore
 		Object.setPrototypeOf(this, FailedToChangeMnemonicForKeyStore.prototype);
 	}
 };
-
 //#endregion
 //#region src/keystore-crypto/emailEncryptionKey.ts
 /**
@@ -115,11 +112,11 @@ var FailedToChangeMnemonicForKeyStore = class FailedToChangeMnemonicForKeyStore
 async function createEncryptionAndRecoveryKeystores(userEmail, mnemonic) {
 	try {
 		const keys = genHybridKeys();
-		const encryptionKeystore = await encryptKeystoreContent(await deriveEncryptionKeystoreKeyFromMnemonic(mnemonic), keys, userEmail, KeystoreType.ENCRYPTION);
+		const encryptionKeystore = await encryptKeystoreContent(await deriveEncryptionKeystoreKeyFromMnemonic(mnemonic), keys, userEmail, "Encryption");
 		const recoveryCodes = genMnemonic();
 		return {
 			encryptionKeystore,
-			recoveryKeystore: await encryptKeystoreContent(await deriveRecoveryKey(recoveryCodes), keys, userEmail, KeystoreType.RECOVERY),
+			recoveryKeystore: await encryptKeystoreContent(await deriveRecoveryKey(recoveryCodes), keys, userEmail, "Recovery"),
 			recoveryCodes,
 			keys
 		};
@@ -137,7 +134,7 @@ async function createEncryptionAndRecoveryKeystores(userEmail, mnemonic) {
 */
 async function openEncryptionKeystore(encryptedKeystore, mnemonic) {
 	try {
-		if (encryptedKeystore.type !== KeystoreType.ENCRYPTION) throw new InvalidInputKeyStore();
+		if (encryptedKeystore.type !== "Encryption") throw new InvalidInputKeyStore();
 		return await decryptKeystoreContent(await deriveEncryptionKeystoreKeyFromMnemonic(mnemonic), encryptedKeystore);
 	} catch (error) {
 		if (error instanceof InvalidInputKeyStore) throw error;
@@ -154,7 +151,7 @@ async function openEncryptionKeystore(encryptedKeystore, mnemonic) {
 */
 async function openRecoveryKeystore(recoveryCodes, encryptedKeystore) {
 	try {
-		if (encryptedKeystore.type !== KeystoreType.RECOVERY) throw new InvalidInputKeyStore();
+		if (encryptedKeystore.type !== "Recovery") throw new InvalidInputKeyStore();
 		return await decryptKeystoreContent(await deriveRecoveryKey(recoveryCodes), encryptedKeystore);
 	} catch (error) {
 		if (error instanceof InvalidInputKeyStore) throw error;
@@ -174,7 +171,7 @@ async function changeMnemonicForEncryptionKeystore(encryptedKeystore, oldMnemoni
 	try {
 		const keys = await openEncryptionKeystore(encryptedKeystore, oldMnemonic);
 		return {
-			newKeystore: await encryptKeystoreContent(await deriveEncryptionKeystoreKeyFromMnemonic(newMnemonic), keys, encryptedKeystore.userEmail, KeystoreType.ENCRYPTION),
+			newKeystore: await encryptKeystoreContent(await deriveEncryptionKeystoreKeyFromMnemonic(newMnemonic), keys, encryptedKeystore.userEmail, "Encryption"),
 			keys
 		};
 	} catch (error) {
@@ -182,7 +179,7 @@ async function changeMnemonicForEncryptionKeystore(encryptedKeystore, oldMnemoni
 		throw new FailedToChangeMnemonicForKeyStore(error instanceof Error ? error.message : String(error));
 	}
 }
-
 //#endregion
 export { FailedToChangeMnemonicForKeyStore as a, FailedToOpenRecoveryKeyStore as c, openRecoveryKeystore as i, InvalidInputKeyStore as l, createEncryptionAndRecoveryKeystores as n, FailedToCreateKeyStores as o, openEncryptionKeystore as r, FailedToOpenEncryptionKeyStore as s, changeMnemonicForEncryptionKeystore as t };
-//# sourceMappingURL=emailEncryptionKey-CYvr26FG.mjs.map
+
+//# sourceMappingURL=keystore-crypto-C6F-NQdX.mjs.map

package/dist/keystore-crypto-C6F-NQdX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keystore-crypto-C6F-NQdX.mjs","names":[],"sources":["../src/keystore-crypto/core.ts","../src/keystore-crypto/errors.ts","../src/keystore-crypto/emailEncryptionKey.ts"],"sourcesContent":["import { encryptSymmetrically, decryptSymmetrically } from '../symmetric-crypto';\nimport { base64ToUint8Array, uint8ArrayToBase64, UTF8ToUint8 } from '../utils';\nimport { deriveKeyFromMnemonic } from '../derive-key';\nimport { CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY } from '../constants';\nimport { EncryptedKeystore, HybridKeyPair, KeystoreType } from '../types';\n\n/**\n * Encrypts the user's hybrid key using symmetric encryption to get a keystore\n *\n * @param secretKey - The symmetric key to encrypt the keystore content\n * @param key - The hybrid key pair\n * @param userEmail - The email of the user\n * @param type - The keystore type\n * @returns The encrypted keystore\n */\nexport async function encryptKeystoreContent(\n  secretKey: Uint8Array,\n  keys: HybridKeyPair,\n  userEmail: string,\n  type: KeystoreType,\n): Promise<EncryptedKeystore> {\n  try {\n    const publicKey = uint8ArrayToBase64(keys.publicKey);\n\n    const aux = UTF8ToUint8(userEmail + type + publicKey);\n    const secretKeyEncrypted = await encryptSymmetrically(secretKey, keys.secretKey, aux);\n\n    const keystore: EncryptedKeystore = {\n      userEmail,\n      type,\n      publicKey,\n      privateKeyEncrypted: uint8ArrayToBase64(secretKeyEncrypted),\n    };\n    return keystore;\n  } catch (error) {\n    throw new Error('Failed to encrypt keystore content', { cause: error });\n  }\n}\n\n/**\n * Decrypts the keystore content using symmetric encryption\n *\n * @param kesytoreOpeningKey - The symmetric key to decrypt the keystore content\n * @param encryptedKeys - The encrypted keystore content\n * @returns The decrypted hybrid key pair contained in the keystore\n */\nexport async function decryptKeystoreContent(\n  kesytoreOpeningKey: Uint8Array,\n  encryptedKeystore: EncryptedKeystore,\n): Promise<HybridKeyPair> {\n  try {\n    const aux = UTF8ToUint8(encryptedKeystore.userEmail + encryptedKeystore.type + encryptedKeystore.publicKey);\n    const publicKey = base64ToUint8Array(encryptedKeystore.publicKey);\n    const ciphertext = base64ToUint8Array(encryptedKeystore.privateKeyEncrypted);\n    const secretKey = await decryptSymmetrically(kesytoreOpeningKey, ciphertext, aux);\n    return {\n      publicKey,\n      secretKey,\n    };\n  } catch (error) {\n    throw new Error('Failed to decrypt keystore content', { cause: error });\n  }\n}\n\n/**\n * Derives a secret key for protecting the recovery keystore\n *\n * @param recoveryCodes - The recovery codes (machine-generated with secure PRNG)\n * @returns The derived secret key for protecting the recovery keystore\n */\nexport async function deriveRecoveryKey(recoveryCodes: string): Promise<Uint8Array> {\n  return deriveKeyFromMnemonic(recoveryCodes, CONTEXT_RECOVERY);\n}\n\n/**\n * Derives a secret key for protecting the encryption keystore from user's mnemonic\n *\n * @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)\n * @returns The derived secret key for protecting the encryption keystore\n */\nexport async function deriveEncryptionKeystoreKeyFromMnemonic(mnemonic: string): Promise<Uint8Array> {\n  return deriveKeyFromMnemonic(mnemonic, CONTEXT_ENC_KEYSTORE);\n}\n","export class FailedToCreateKeyStores extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to create encryption and recovery keystores: ' + errorMsg);\n\n    Object.setPrototypeOf(this, FailedToCreateKeyStores.prototype);\n  }\n}\n\nexport class InvalidInputKeyStore extends Error {\n  constructor() {\n    super('Invalid input');\n\n    Object.setPrototypeOf(this, InvalidInputKeyStore.prototype);\n  }\n}\n\nexport class FailedToOpenEncryptionKeyStore extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to open encryption keystore: ' + errorMsg);\n\n    Object.setPrototypeOf(this, FailedToOpenEncryptionKeyStore.prototype);\n  }\n}\n\nexport class FailedToOpenRecoveryKeyStore extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to open recovery keystore: ' + errorMsg);\n\n    Object.setPrototypeOf(this, FailedToOpenRecoveryKeyStore.prototype);\n  }\n}\n\nexport class FailedToChangeMnemonicForKeyStore extends Error {\n  constructor(errorMsg?: string) {\n    super('Error while fetching message: ' + errorMsg);\n\n    Object.setPrototypeOf(this, FailedToChangeMnemonicForKeyStore.prototype);\n  }\n}\n","import { EncryptedKeystore, KeystoreType, HybridKeyPair } from '../types';\nimport { genMnemonic } from '../utils';\nimport {\n  encryptKeystoreContent,\n  decryptKeystoreContent,\n  deriveEncryptionKeystoreKeyFromMnemonic,\n  deriveRecoveryKey,\n} from './core';\nimport { genHybridKeys } from '../hybrid-crypto';\nimport {\n  FailedToOpenEncryptionKeyStore,\n  FailedToCreateKeyStores,\n  FailedToOpenRecoveryKeyStore,\n  FailedToChangeMnemonicForKeyStore,\n  InvalidInputKeyStore,\n} from './errors';\n\n/**\n * Generates hybrid keys and creates encrypted main and recovery keystores\n * The main keystore encryption key is derived from the user's mnemonic\n * The recovery keystore encryption key is derived from the recovery codes\n *\n * @param userEmail - The user's email\n * @param mnemonic - The user's mnemonic\n * @returns The encryption keys\n *\n * @returns The encryption and recovery keystores, recovery codes and hybrid keys\n */\nexport async function createEncryptionAndRecoveryKeystores(\n  userEmail: string,\n  mnemonic: string,\n): Promise<{\n  encryptionKeystore: EncryptedKeystore;\n  recoveryKeystore: EncryptedKeystore;\n  recoveryCodes: string;\n  keys: HybridKeyPair;\n}> {\n  try {\n    const keys = genHybridKeys();\n\n    const secretKey = await deriveEncryptionKeystoreKeyFromMnemonic(mnemonic);\n    const encryptionKeystore = await encryptKeystoreContent(secretKey, keys, userEmail, KeystoreType.ENCRYPTION);\n\n    const recoveryCodes = genMnemonic();\n    const recoveryKey = await deriveRecoveryKey(recoveryCodes);\n    const recoveryKeystore = await encryptKeystoreContent(recoveryKey, keys, userEmail, KeystoreType.RECOVERY);\n\n    return { encryptionKeystore, recoveryKeystore, recoveryCodes, keys };\n  } catch (error) {\n    throw new FailedToCreateKeyStores(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Opens the encryption keystore and returns the email encryption keys\n * The decryption key is derived from the user mnemonic\n *\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @param mnemonic - The user's mnemonic\n * @returns The encryption keys\n */\nexport async function openEncryptionKeystore(\n  encryptedKeystore: EncryptedKeystore,\n  mnemonic: string,\n): Promise<HybridKeyPair> {\n  try {\n    if (encryptedKeystore.type !== KeystoreType.ENCRYPTION) {\n      throw new InvalidInputKeyStore();\n    }\n    const secretKey = await deriveEncryptionKeystoreKeyFromMnemonic(mnemonic);\n    const keys = await decryptKeystoreContent(secretKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    if (error instanceof InvalidInputKeyStore) throw error;\n    throw new FailedToOpenEncryptionKeyStore(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Opens the recovery keystore and returns the email encryption keys\n * The decryption key is derived from the recovery codes (machine-generated mnemonic)\n *\n * @param recoveryCodes - The user's recovery codes\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @returns The encryption keys\n */\nexport async function openRecoveryKeystore(\n  recoveryCodes: string,\n  encryptedKeystore: EncryptedKeystore,\n): Promise<HybridKeyPair> {\n  try {\n    if (encryptedKeystore.type !== KeystoreType.RECOVERY) {\n      throw new InvalidInputKeyStore();\n    }\n    const recoveryKey = await deriveRecoveryKey(recoveryCodes);\n    const keys = await decryptKeystoreContent(recoveryKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    if (error instanceof InvalidInputKeyStore) throw error;\n    throw new FailedToOpenRecoveryKeyStore(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Re-encrypts the encryption keystore with a new mnemonic\n * The decryption key is derived from the user mnemonic\n *\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @param oldMnemonic - The user's old mnemonic\n * @param newMnemonic - The user's new mnemonic\n * @returns The keys and new re-encrypted keystore\n */\nexport async function changeMnemonicForEncryptionKeystore(\n  encryptedKeystore: EncryptedKeystore,\n  oldMnemonic: string,\n  newMnemonic: string,\n): Promise<{ keys: HybridKeyPair; newKeystore: EncryptedKeystore }> {\n  try {\n    const keys = await openEncryptionKeystore(encryptedKeystore, oldMnemonic);\n\n    const secretKey = await deriveEncryptionKeystoreKeyFromMnemonic(newMnemonic);\n    const newKeystore = await encryptKeystoreContent(\n      secretKey,\n      keys,\n      encryptedKeystore.userEmail,\n      KeystoreType.ENCRYPTION,\n    );\n\n    return { newKeystore, keys };\n  } catch (error) {\n    if (error instanceof InvalidInputKeyStore) throw error;\n    throw new FailedToChangeMnemonicForKeyStore(error instanceof Error ? error.message : String(error));\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,eAAsB,uBACpB,WACA,MACA,WACA,MAC4B;AAC5B,KAAI;EACF,MAAM,YAAY,mBAAmB,KAAK,UAAU;EAEpD,MAAM,MAAM,YAAY,YAAY,OAAO,UAAU;AASrD,SAAO;GALL;GACA;GACA;GACA,qBAAqB,mBAAmB,MANT,qBAAqB,WAAW,KAAK,WAAW,IAAI,CAMxB;GAE9C;UACR,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW3E,eAAsB,uBACpB,oBACA,mBACwB;AACxB,KAAI;EACF,MAAM,MAAM,YAAY,kBAAkB,YAAY,kBAAkB,OAAO,kBAAkB,UAAU;AAI3G,SAAO;GACL,WAJgB,mBAAmB,kBAAkB,UAI5C;GACT,WAAA,MAHsB,qBAAqB,oBAD1B,mBAAmB,kBAAkB,oBACmB,EAAE,IAAI;GAIhF;UACM,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU3E,eAAsB,kBAAkB,eAA4C;AAClF,QAAO,sBAAsB,eAAe,iBAAiB;;;;;;;;AAS/D,eAAsB,wCAAwC,UAAuC;AACnG,QAAO,sBAAsB,UAAU,qBAAqB;;;;ACjF9D,IAAa,0BAAb,MAAa,gCAAgC,MAAM;CACjD,YAAY,UAAmB;AAC7B,QAAM,yDAAyD,SAAS;AAExE,SAAO,eAAe,MAAM,wBAAwB,UAAU;;;AAIlE,IAAa,uBAAb,MAAa,6BAA6B,MAAM;CAC9C,cAAc;AACZ,QAAM,gBAAgB;AAEtB,SAAO,eAAe,MAAM,qBAAqB,UAAU;;;AAI/D,IAAa,iCAAb,MAAa,uCAAuC,MAAM;CACxD,YAAY,UAAmB;AAC7B,QAAM,yCAAyC,SAAS;AAExD,SAAO,eAAe,MAAM,+BAA+B,UAAU;;;AAIzE,IAAa,+BAAb,MAAa,qCAAqC,MAAM;CACtD,YAAY,UAAmB;AAC7B,QAAM,uCAAuC,SAAS;AAEtD,SAAO,eAAe,MAAM,6BAA6B,UAAU;;;AAIvE,IAAa,oCAAb,MAAa,0CAA0C,MAAM;CAC3D,YAAY,UAAmB;AAC7B,QAAM,mCAAmC,SAAS;AAElD,SAAO,eAAe,MAAM,kCAAkC,UAAU;;;;;;;;;;;;;;;;ACR5E,eAAsB,qCACpB,WACA,UAMC;AACD,KAAI;EACF,MAAM,OAAO,eAAe;EAG5B,MAAM,qBAAqB,MAAM,uBAAuB,MADhC,wCAAwC,SAAS,EACN,MAAM,WAAA,aAAmC;EAE5G,MAAM,gBAAgB,aAAa;AAInC,SAAO;GAAE;GAAoB,kBAAA,MAFE,uBAAuB,MAD5B,kBAAkB,cAAc,EACS,MAAM,WAAA,WAAiC;GAE3D;GAAe;GAAM;UAC7D,OAAO;AACd,QAAM,IAAI,wBAAwB,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM,CAAC;;;;;;;;;;;AAY7F,eAAsB,uBACpB,mBACA,UACwB;AACxB,KAAI;AACF,MAAI,kBAAkB,SAAA,aACpB,OAAM,IAAI,sBAAsB;AAIlC,SAAO,MADY,uBAAuB,MADlB,wCAAwC,SAAS,EACpB,kBAAkB;UAEhE,OAAO;AACd,MAAI,iBAAiB,qBAAsB,OAAM;AACjD,QAAM,IAAI,+BAA+B,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM,CAAC;;;;;;;;;;;AAYpG,eAAsB,qBACpB,eACA,mBACwB;AACxB,KAAI;AACF,MAAI,kBAAkB,SAAA,WACpB,OAAM,IAAI,sBAAsB;AAIlC,SAAO,MADY,uBAAuB,MADhB,kBAAkB,cAAc,EACH,kBAAkB;UAElE,OAAO;AACd,MAAI,iBAAiB,qBAAsB,OAAM;AACjD,QAAM,IAAI,6BAA6B,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM,CAAC;;;;;;;;;;;;AAalG,eAAsB,oCACpB,mBACA,aACA,aACkE;AAClE,KAAI;EACF,MAAM,OAAO,MAAM,uBAAuB,mBAAmB,YAAY;AAUzE,SAAO;GAAE,aAAA,MAPiB,uBACxB,MAFsB,wCAAwC,YAAY,EAG1E,MACA,kBAAkB,WAAA,aAEnB;GAEqB;GAAM;UACrB,OAAO;AACd,MAAI,iBAAiB,qBAAsB,OAAM;AACjD,QAAM,IAAI,kCAAkC,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM,CAAC"}