internxt-crypto 1.0.2 → 1.1.1

package/dist/index.mjs

@@ -1,15 +1,13 @@
 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 deriveSymmetricKeyFromContext, r as deriveSymmetricKeyFromTwoKeys, t as deriveDatabaseKey } from "./deriveKeysFromKey-CseBjg0n.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 { a as encryptEmailHybrid, h as wrapKey, i as decryptEmailHybrid, l as encryptEmailBody, m as unwrapKey, n as createPwdProtectedEmail, o as encryptEmailHybridForMultipleRecipients, r as decryptPwdProtectedEmail, s as decryptEmailBody, t as generateEmailKeys, u as encryptEmailBodyWithKey } from "./emailKeys-nzn7U7HQ.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-BtSPYd9M.mjs";
+import { n as openEncryptionKeystore, r as openRecoveryKeystore, t as createEncryptionAndRecoveryKeystores } from "./emailEncryptionKey-kIsseFo6.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_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 };
+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, base64ToUint8Array, bytesToMnemonic, bytesToUuid, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailBody, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deriveDatabaseKey, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptEmailBody, encryptEmailBodyWithKey, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getBytesFromData, getBytesFromDataArray, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openEncryptionKeystore, openRecoveryKeystore, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };

package/dist/keystore-crypto.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_emailEncryptionKey = require('./emailEncryptionKey-C4X1Bwy4.js');
+const require_emailEncryptionKey = require('./emailEncryptionKey-F_YuJu1H.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-BtSPYd9M.mjs";
+import { n as openEncryptionKeystore, r as openRecoveryKeystore, t as createEncryptionAndRecoveryKeystores } from "./emailEncryptionKey-kIsseFo6.mjs";
 
 export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };

package/dist/types.d.mts

@@ -5,10 +5,6 @@ type EncryptedKeystore = {
   publicKey: string;
   privateKeyEncrypted: string;
 };
-type User = {
-  email: string;
-  name: string;
-};
 type RecipientWithPublicKey = {
   email: string;
   publicHybridKey: Uint8Array;
@@ -25,11 +21,6 @@ type PwdProtectedEmail = {
   encryptedKey: PwdProtectedKey;
   encEmailBody: EmailBodyEncrypted;
 };
-type StoredEmail = {
-  params: EmailPublicParameters;
-  encEmailBody: EmailBodyEncrypted;
-  id: string;
-};
 type HybridEncKey = {
   hybridCiphertext: string;
   encryptedKey: string;
@@ -49,34 +40,10 @@ type EmailBody = {
   subject: string;
   attachments?: string[];
 };
-type EmailPublicParameters = {
-  createdAt: string;
-  sender: User;
-  recipients: User[];
-  ccs?: User[];
-  bccs?: User[];
-  replyToEmailID?: string;
-  labels?: string[];
-};
-type Email = {
-  id: string;
-  body: EmailBody;
-  params: EmailPublicParameters;
-};
-interface MailCache<Email> {
-  esCache: Map<string, Email>;
-  cacheSize: number;
-  isCacheLimited: boolean;
-  isCacheReady: boolean;
-}
-interface EmailSearchResult {
-  email: Email;
-  score?: number;
-}
 declare enum KeystoreType {
   ENCRYPTION = "Encryption",
   RECOVERY = "Recovery"
 }
 //#endregion
-export { Email, EmailBody, EmailBodyEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, MailCache, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey, StoredEmail, User };
+export { EmailBody, EmailBodyEncrypted, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey };
 //# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";KAAY,iBAAA;EACV,SAAA;EACA,IAAA,EAAM,YAAA;EACN,SAAA;EACA,mBAAA;AAAA;AAAA,KAGU,IAAA;EACV,KAAA;EACA,IAAA;AAAA;AAAA,KAGU,sBAAA;EACV,KAAA;EACA,eAAA,EAAiB,UAAA;AAAA;AAAA,KAGP,aAAA;EACV,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;AAAA,KAGD,oBAAA;EACV,YAAA,EAAc,YAAA;EACd,YAAA,EAAc,kBAAA;AAAA;AAAA,KAGJ,iBAAA;EACV,YAAA,EAAc,eAAA;EACd,YAAA,EAAc,kBAAA;AAAA;AAAA,KAGJ,WAAA;EACV,MAAA,EAAQ,qBAAA;EACR,YAAA,EAAc,kBAAA;EACd,EAAA;AAAA;AAAA,KAGU,YAAA;EACV,gBAAA;EACA,YAAA;EACA,iBAAA;AAAA;AAAA,KAGU,eAAA;EACV,YAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA;EACV,OAAA;EACA,UAAA;EACA,cAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA;EACA,OAAA;EACA,WAAA;AAAA;AAAA,KAGU,qBAAA;EACV,SAAA;EACA,MAAA,EAAQ,IAAA;EACR,UAAA,EAAY,IAAA;EACZ,GAAA,GAAM,IAAA;EACN,IAAA,GAAO,IAAA;EACP,cAAA;EACA,MAAA;AAAA;AAAA,KAGU,KAAA;EACV,EAAA;EACA,IAAA,EAAM,SAAA;EACN,MAAA,EAAQ,qBAAA;AAAA;AAAA,UAGO,SAAA;EACf,OAAA,EAAS,GAAA,SAAY,KAAA;EACrB,SAAA;EACA,cAAA;EACA,YAAA;AAAA;AAAA,UAEe,iBAAA;EACf,KAAA,EAAO,KAAA;EACP,KAAA;AAAA;AAAA,aAGU,YAAA;EACV,UAAA;EACA,QAAA;AAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";KAAY,iBAAA;EACV,SAAA;EACA,IAAA,EAAM,YAAA;EACN,SAAA;EACA,mBAAA;AAAA;AAAA,KAGU,sBAAA;EACV,KAAA;EACA,eAAA,EAAiB,UAAA;AAAA;AAAA,KAGP,aAAA;EACV,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;AAAA,KAGD,oBAAA;EACV,YAAA,EAAc,YAAA;EACd,YAAA,EAAc,kBAAA;AAAA;AAAA,KAGJ,iBAAA;EACV,YAAA,EAAc,eAAA;EACd,YAAA,EAAc,kBAAA;AAAA;AAAA,KAGJ,YAAA;EACV,gBAAA;EACA,YAAA;EACA,iBAAA;AAAA;AAAA,KAGU,eAAA;EACV,YAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA;EACV,OAAA;EACA,UAAA;EACA,cAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA;EACA,OAAA;EACA,WAAA;AAAA;AAAA,aAGU,YAAA;EACV,UAAA;EACA,QAAA;AAAA"}

package/dist/types.d.ts

@@ -5,10 +5,6 @@ type EncryptedKeystore = {
   publicKey: string;
   privateKeyEncrypted: string;
 };
-type User = {
-  email: string;
-  name: string;
-};
 type RecipientWithPublicKey = {
   email: string;
   publicHybridKey: Uint8Array;
@@ -25,11 +21,6 @@ type PwdProtectedEmail = {
   encryptedKey: PwdProtectedKey;
   encEmailBody: EmailBodyEncrypted;
 };
-type StoredEmail = {
-  params: EmailPublicParameters;
-  encEmailBody: EmailBodyEncrypted;
-  id: string;
-};
 type HybridEncKey = {
   hybridCiphertext: string;
   encryptedKey: string;
@@ -49,34 +40,10 @@ type EmailBody = {
   subject: string;
   attachments?: string[];
 };
-type EmailPublicParameters = {
-  createdAt: string;
-  sender: User;
-  recipients: User[];
-  ccs?: User[];
-  bccs?: User[];
-  replyToEmailID?: string;
-  labels?: string[];
-};
-type Email = {
-  id: string;
-  body: EmailBody;
-  params: EmailPublicParameters;
-};
-interface MailCache<Email> {
-  esCache: Map<string, Email>;
-  cacheSize: number;
-  isCacheLimited: boolean;
-  isCacheReady: boolean;
-}
-interface EmailSearchResult {
-  email: Email;
-  score?: number;
-}
 declare enum KeystoreType {
   ENCRYPTION = "Encryption",
   RECOVERY = "Recovery"
 }
 //#endregion
-export { Email, EmailBody, EmailBodyEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, MailCache, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey, StoredEmail, User };
+export { EmailBody, EmailBodyEncrypted, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey };
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";KAAY,iBAAA;EACV,SAAA;EACA,IAAA,EAAM,YAAA;EACN,SAAA;EACA,mBAAA;AAAA;AAAA,KAGU,IAAA;EACV,KAAA;EACA,IAAA;AAAA;AAAA,KAGU,sBAAA;EACV,KAAA;EACA,eAAA,EAAiB,UAAA;AAAA;AAAA,KAGP,aAAA;EACV,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;AAAA,KAGD,oBAAA;EACV,YAAA,EAAc,YAAA;EACd,YAAA,EAAc,kBAAA;AAAA;AAAA,KAGJ,iBAAA;EACV,YAAA,EAAc,eAAA;EACd,YAAA,EAAc,kBAAA;AAAA;AAAA,KAGJ,WAAA;EACV,MAAA,EAAQ,qBAAA;EACR,YAAA,EAAc,kBAAA;EACd,EAAA;AAAA;AAAA,KAGU,YAAA;EACV,gBAAA;EACA,YAAA;EACA,iBAAA;AAAA;AAAA,KAGU,eAAA;EACV,YAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA;EACV,OAAA;EACA,UAAA;EACA,cAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA;EACA,OAAA;EACA,WAAA;AAAA;AAAA,KAGU,qBAAA;EACV,SAAA;EACA,MAAA,EAAQ,IAAA;EACR,UAAA,EAAY,IAAA;EACZ,GAAA,GAAM,IAAA;EACN,IAAA,GAAO,IAAA;EACP,cAAA;EACA,MAAA;AAAA;AAAA,KAGU,KAAA;EACV,EAAA;EACA,IAAA,EAAM,SAAA;EACN,MAAA,EAAQ,qBAAA;AAAA;AAAA,UAGO,SAAA;EACf,OAAA,EAAS,GAAA,SAAY,KAAA;EACrB,SAAA;EACA,cAAA;EACA,YAAA;AAAA;AAAA,UAEe,iBAAA;EACf,KAAA,EAAO,KAAA;EACP,KAAA;AAAA;AAAA,aAGU,YAAA;EACV,UAAA;EACA,QAAA;AAAA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";KAAY,iBAAA;EACV,SAAA;EACA,IAAA,EAAM,YAAA;EACN,SAAA;EACA,mBAAA;AAAA;AAAA,KAGU,sBAAA;EACV,KAAA;EACA,eAAA,EAAiB,UAAA;AAAA;AAAA,KAGP,aAAA;EACV,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;AAAA,KAGD,oBAAA;EACV,YAAA,EAAc,YAAA;EACd,YAAA,EAAc,kBAAA;AAAA;AAAA,KAGJ,iBAAA;EACV,YAAA,EAAc,eAAA;EACd,YAAA,EAAc,kBAAA;AAAA;AAAA,KAGJ,YAAA;EACV,gBAAA;EACA,YAAA;EACA,iBAAA;AAAA;AAAA,KAGU,eAAA;EACV,YAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA;EACV,OAAA;EACA,UAAA;EACA,cAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA;EACA,OAAA;EACA,WAAA;AAAA;AAAA,aAGU,YAAA;EACV,UAAA;EACA,QAAA;AAAA"}

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["export type EncryptedKeystore = {\n  userEmail: string;\n  type: KeystoreType;\n  publicKey: string;\n  privateKeyEncrypted: string;\n};\n\nexport type User = {\n  email: string;\n  name: string;\n};\n\nexport type RecipientWithPublicKey = {\n  email: string;\n  publicHybridKey: Uint8Array;\n};\n\nexport type HybridKeyPair = {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n};\n\nexport type HybridEncryptedEmail = {\n  encryptedKey: HybridEncKey;\n  encEmailBody: EmailBodyEncrypted;\n};\n\nexport type PwdProtectedEmail = {\n  encryptedKey: PwdProtectedKey;\n  encEmailBody: EmailBodyEncrypted;\n};\n\nexport type StoredEmail = {\n  params: EmailPublicParameters;\n  encEmailBody: EmailBodyEncrypted;\n  id: string;\n};\n\nexport type HybridEncKey = {\n  hybridCiphertext: string;\n  encryptedKey: string;\n  encryptedForEmail: string;\n};\n\nexport type PwdProtectedKey = {\n  encryptedKey: string;\n  salt: string;\n};\n\nexport type EmailBodyEncrypted = {\n  encText: string;\n  encSubject: string;\n  encAttachments?: string[];\n};\n\nexport type EmailBody = {\n  text: string;\n  subject: string;\n  attachments?: string[];\n};\n\nexport type EmailPublicParameters = {\n  createdAt: string;\n  sender: User;\n  recipients: User[];\n  ccs?: User[];\n  bccs?: User[];\n  replyToEmailID?: string;\n  labels?: string[];\n};\n\nexport type Email = {\n  id: string;\n  body: EmailBody;\n  params: EmailPublicParameters;\n};\n\nexport interface MailCache<Email> {\n  esCache: Map<string, Email>;\n  cacheSize: number;\n  isCacheLimited: boolean;\n  isCacheReady: boolean;\n}\nexport interface EmailSearchResult {\n  email: Email;\n  score?: number;\n}\n\nexport enum KeystoreType {\n  ENCRYPTION = 'Encryption',\n  RECOVERY = 'Recovery',\n}\n"],"mappings":";;;AAwFA,IAAY,sDAAL;AACL;AACA"}
+{"version":3,"file":"types.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["export type EncryptedKeystore = {\n  userEmail: string;\n  type: KeystoreType;\n  publicKey: string;\n  privateKeyEncrypted: string;\n};\n\nexport type RecipientWithPublicKey = {\n  email: string;\n  publicHybridKey: Uint8Array;\n};\n\nexport type HybridKeyPair = {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n};\n\nexport type HybridEncryptedEmail = {\n  encryptedKey: HybridEncKey;\n  encEmailBody: EmailBodyEncrypted;\n};\n\nexport type PwdProtectedEmail = {\n  encryptedKey: PwdProtectedKey;\n  encEmailBody: EmailBodyEncrypted;\n};\n\nexport type HybridEncKey = {\n  hybridCiphertext: string;\n  encryptedKey: string;\n  encryptedForEmail: string;\n};\n\nexport type PwdProtectedKey = {\n  encryptedKey: string;\n  salt: string;\n};\n\nexport type EmailBodyEncrypted = {\n  encText: string;\n  encSubject: string;\n  encAttachments?: string[];\n};\n\nexport type EmailBody = {\n  text: string;\n  subject: string;\n  attachments?: string[];\n};\n\nexport enum KeystoreType {\n  ENCRYPTION = 'Encryption',\n  RECOVERY = 'Recovery',\n}\n"],"mappings":";;;AAkDA,IAAY,sDAAL;AACL;AACA"}

package/dist/types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["export type EncryptedKeystore = {\n  userEmail: string;\n  type: KeystoreType;\n  publicKey: string;\n  privateKeyEncrypted: string;\n};\n\nexport type User = {\n  email: string;\n  name: string;\n};\n\nexport type RecipientWithPublicKey = {\n  email: string;\n  publicHybridKey: Uint8Array;\n};\n\nexport type HybridKeyPair = {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n};\n\nexport type HybridEncryptedEmail = {\n  encryptedKey: HybridEncKey;\n  encEmailBody: EmailBodyEncrypted;\n};\n\nexport type PwdProtectedEmail = {\n  encryptedKey: PwdProtectedKey;\n  encEmailBody: EmailBodyEncrypted;\n};\n\nexport type StoredEmail = {\n  params: EmailPublicParameters;\n  encEmailBody: EmailBodyEncrypted;\n  id: string;\n};\n\nexport type HybridEncKey = {\n  hybridCiphertext: string;\n  encryptedKey: string;\n  encryptedForEmail: string;\n};\n\nexport type PwdProtectedKey = {\n  encryptedKey: string;\n  salt: string;\n};\n\nexport type EmailBodyEncrypted = {\n  encText: string;\n  encSubject: string;\n  encAttachments?: string[];\n};\n\nexport type EmailBody = {\n  text: string;\n  subject: string;\n  attachments?: string[];\n};\n\nexport type EmailPublicParameters = {\n  createdAt: string;\n  sender: User;\n  recipients: User[];\n  ccs?: User[];\n  bccs?: User[];\n  replyToEmailID?: string;\n  labels?: string[];\n};\n\nexport type Email = {\n  id: string;\n  body: EmailBody;\n  params: EmailPublicParameters;\n};\n\nexport interface MailCache<Email> {\n  esCache: Map<string, Email>;\n  cacheSize: number;\n  isCacheLimited: boolean;\n  isCacheReady: boolean;\n}\nexport interface EmailSearchResult {\n  email: Email;\n  score?: number;\n}\n\nexport enum KeystoreType {\n  ENCRYPTION = 'Encryption',\n  RECOVERY = 'Recovery',\n}\n"],"mappings":";AAwFA,IAAY,sDAAL;AACL;AACA"}
+{"version":3,"file":"types.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["export type EncryptedKeystore = {\n  userEmail: string;\n  type: KeystoreType;\n  publicKey: string;\n  privateKeyEncrypted: string;\n};\n\nexport type RecipientWithPublicKey = {\n  email: string;\n  publicHybridKey: Uint8Array;\n};\n\nexport type HybridKeyPair = {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n};\n\nexport type HybridEncryptedEmail = {\n  encryptedKey: HybridEncKey;\n  encEmailBody: EmailBodyEncrypted;\n};\n\nexport type PwdProtectedEmail = {\n  encryptedKey: PwdProtectedKey;\n  encEmailBody: EmailBodyEncrypted;\n};\n\nexport type HybridEncKey = {\n  hybridCiphertext: string;\n  encryptedKey: string;\n  encryptedForEmail: string;\n};\n\nexport type PwdProtectedKey = {\n  encryptedKey: string;\n  salt: string;\n};\n\nexport type EmailBodyEncrypted = {\n  encText: string;\n  encSubject: string;\n  encAttachments?: string[];\n};\n\nexport type EmailBody = {\n  text: string;\n  subject: string;\n  attachments?: string[];\n};\n\nexport enum KeystoreType {\n  ENCRYPTION = 'Encryption',\n  RECOVERY = 'Recovery',\n}\n"],"mappings":";AAkDA,IAAY,sDAAL;AACL;AACA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "internxt-crypto",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/index.js",
@@ -41,10 +41,8 @@
     "@noble/hashes": "^2.0.1",
     "@noble/post-quantum": "^0.5.2",
     "@scure/bip39": "^2.0.1",
-    "flexsearch": "^0.8.205",
     "hash-wasm": "^4.12.0",
     "husky": "^9.1.7",
-    "idb": "^8.0.3",
     "uuid": "^13.0.0"
   },
   "exports": {

package/dist/core-Bj26rNdA.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"core-Bj26rNdA.js","names":["genSymmetricKey","UTF8ToUint8","encryptSymmetrically","uint8ArrayToBase64","uint8ToUTF8","decryptSymmetrically","base64ToUint8Array","encapsulateHybrid","decapsulateHybrid","getKeyFromPassword","getKeyFromPasswordAndSalt"],"sources":["../src/key-wrapper/aesWrapper.ts","../src/email-crypto/core.ts"],"sourcesContent":["import { aeskw } from '@noble/ciphers/aes.js';\n\n/**\n * Unwraps the given wrapped key\n *\n * @param encryptedKey - The wrapped key\n * @param wrappingKey - The secret key used for unwrapping\n * @returns The resulting key\n */\nexport async function unwrapKey(encryptedKey: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array> {\n  return aeskw(wrappingKey).decrypt(encryptedKey);\n}\n\n/**\n * Wraps the given key\n *\n * @param key - The key to be wrapped\n * @param wrappingKey - The secret key used for wrapping\n * @returns The resulting ciphertext\n */\nexport async function wrapKey(key: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array> {\n  return aeskw(wrappingKey).encrypt(key);\n}\n","import { HybridEncKey, PwdProtectedKey, EmailBody, EmailBodyEncrypted, RecipientWithPublicKey } from '../types';\nimport { encryptSymmetrically, decryptSymmetrically, genSymmetricKey } from '../symmetric-crypto';\nimport { encapsulateHybrid, decapsulateHybrid } from '../hybrid-crypto';\nimport { wrapKey, unwrapKey } from '../key-wrapper';\nimport { getKeyFromPassword, getKeyFromPasswordAndSalt } from '../derive-password';\nimport { UTF8ToUint8, base64ToUint8Array, uint8ArrayToBase64, uint8ToUTF8 } from '../utils';\n\n/**\n * Symmetrically encrypts email body.\n *\n * @param body - The email body to encrypt.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting encrypted email body and symmetric key used for encryption\n */\nexport async function encryptEmailBody(\n  body: EmailBody,\n  aux?: Uint8Array,\n): Promise<{\n  encEmailBody: EmailBodyEncrypted;\n  encryptionKey: Uint8Array;\n}> {\n  try {\n    if (!body.text || !body.subject) {\n      throw new Error('Invalid input');\n    }\n    const encryptionKey = genSymmetricKey();\n    const encEmailBody = await encryptEmailBodyWithKey(body, encryptionKey, aux);\n\n    return { encEmailBody, encryptionKey };\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email body', { cause: error });\n  }\n}\n\n/**\n * Symmetrically encrypts email body with the given key.\n *\n * @param body - The email body to encrypt.\n * @param encryptionKey - The symmetric key to encrypt the email.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting encrypted email body and symmetric key used for encryption\n */\nexport async function encryptEmailBodyWithKey(\n  body: EmailBody,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBodyEncrypted> {\n  try {\n    const text = UTF8ToUint8(body.text);\n    const subject = UTF8ToUint8(body.subject);\n    const subjectEnc = await encryptSymmetrically(encryptionKey, subject, aux);\n    const encryptedText = await encryptSymmetrically(encryptionKey, text, aux);\n    const encText = uint8ArrayToBase64(encryptedText);\n    const encSubject = uint8ArrayToBase64(subjectEnc);\n    const enc: EmailBodyEncrypted = { encText, encSubject };\n\n    if (body.attachments) {\n      const promises = body.attachments.map((attachment) => {\n        const binaryAttachment = UTF8ToUint8(attachment);\n        return encryptSymmetrically(encryptionKey, binaryAttachment, aux);\n      });\n      const encryptedAttachments = await Promise.all(promises);\n      enc.encAttachments = encryptedAttachments?.map(uint8ArrayToBase64);\n    }\n\n    return enc;\n  } catch (error) {\n    throw new Error('Failed to encrypt email body', { cause: error });\n  }\n}\n\n/**\n * Decrypts symmetrically encrypted email body.\n *\n * @param encEmailBody - The email body to decrypt.\n * @param encryptionKey - The symmetric key to decrypt the email.\n * @param aux - An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting decrypted email body\n */\nexport async function decryptEmailBody(\n  encEmailBody: EmailBodyEncrypted,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encSubject = base64ToUint8Array(encEmailBody.encSubject);\n    const subjectArray = await decryptSymmetrically(encryptionKey, encSubject, aux);\n    const subject = uint8ToUTF8(subjectArray);\n    const encText = base64ToUint8Array(encEmailBody.encText);\n    const textArray = await decryptSymmetrically(encryptionKey, encText, aux);\n    const text = uint8ToUTF8(textArray);\n    const body: EmailBody = { text, subject };\n\n    if (encEmailBody.encAttachments) {\n      const encAttachments = encEmailBody.encAttachments?.map(base64ToUint8Array);\n      const promises = encAttachments?.map((encAtt) => decryptSymmetrically(encryptionKey, encAtt, aux));\n      const decryptedAttachments = await Promise.all(promises);\n      body.attachments = decryptedAttachments?.map((att) => uint8ToUTF8(att));\n    }\n\n    return body;\n  } catch (error) {\n    throw new Error('Failed to symmetrically decrypt email body', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email symmetric key using hybrid encryption.\n *\n * @param emailEncryptionKey - The symmetric key used for email encryption.\n * @param recipient - The recipient with a public hybrid key.\n * @returns The encrypted email symmetric key\n */\nexport async function encryptKeysHybrid(\n  emailEncryptionKey: Uint8Array,\n  recipient: RecipientWithPublicKey,\n): Promise<HybridEncKey> {\n  try {\n    const { cipherText, sharedSecret } = encapsulateHybrid(recipient.publicHybridKey);\n    const encryptedKey = await wrapKey(emailEncryptionKey, sharedSecret);\n    const encryptedKeyBase64 = uint8ArrayToBase64(encryptedKey);\n    const kyberCiphertextBase64 = uint8ArrayToBase64(cipherText);\n\n    return {\n      encryptedKey: encryptedKeyBase64,\n      hybridCiphertext: kyberCiphertextBase64,\n      encryptedForEmail: recipient.email,\n    };\n  } catch (error) {\n    throw new Error('Failed to encrypt email key using hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Decrypts the email symmetric key encrypted via hybrid encryption.\n *\n * @param encryptedKey - The encrypted email key.\n * @param recipientPrivateKey - The private key of the recipient.\n * @returns The email encryption key\n */\nexport async function decryptKeysHybrid(\n  encryptedKey: HybridEncKey,\n  recipientPrivateKey: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const kyberCiphertext = base64ToUint8Array(encryptedKey.hybridCiphertext);\n    const encKey = base64ToUint8Array(encryptedKey.encryptedKey);\n    const sharedSecret = decapsulateHybrid(kyberCiphertext, recipientPrivateKey);\n    const encryptionKey = await unwrapKey(encKey, sharedSecret);\n    return encryptionKey;\n  } catch (error) {\n    throw new Error('Failed to decrypt email key encrypted via hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Password-protects the email symmetric key.\n *\n * @param emailEncryptionKey - The symmetric key used for email encryption.\n * @param password - The secret password for key protection.\n * @returns The password-protected email symmetric key\n */\nexport async function passwordProtectKey(emailEncryptionKey: Uint8Array, password: string): Promise<PwdProtectedKey> {\n  try {\n    const { key, salt } = await getKeyFromPassword(password);\n    const encryptedKey = await wrapKey(emailEncryptionKey, key);\n    const saltStr = uint8ArrayToBase64(salt);\n    const encryptedKeyStr = uint8ArrayToBase64(encryptedKey);\n    return { encryptedKey: encryptedKeyStr, salt: saltStr };\n  } catch (error) {\n    throw new Error('Failed to password-protect email key', { cause: error });\n  }\n}\n\n/**\n * Removes passoword-protection and exposes the email symmetric key.\n *\n * @param emailEncryptionKey -  The password-protected email key.\n * @param password - The secret password for key protection.\n * @returns The email encryption key\n */\nexport async function removePasswordProtection(\n  emailEncryptionKey: PwdProtectedKey,\n  password: string,\n): Promise<Uint8Array> {\n  try {\n    const salt = base64ToUint8Array(emailEncryptionKey.salt);\n    const encryptedKey = base64ToUint8Array(emailEncryptionKey.encryptedKey);\n    const key = await getKeyFromPasswordAndSalt(password, salt);\n    const encryptionKey = await unwrapKey(encryptedKey, key);\n    return encryptionKey;\n  } catch (error) {\n    throw new Error('Failed to remove password-protection from email key', { cause: error });\n  }\n}\n"],"mappings":"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"}

package/dist/core-pEGygy6S.mjs.map

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

package/dist/deriveKeysFromKey-C4McqO6_.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"deriveKeysFromKey-C4McqO6_.js","names":["UTF8ToUint8","AES_KEY_BYTE_LENGTH","CONTEXT_DERIVE"],"sources":["../src/derive-key/deriveKeysFromKey.ts"],"sourcesContent":["import { blake3 } from '@noble/hashes/blake3.js';\nimport { AES_KEY_BYTE_LENGTH, CONTEXT_DERIVE } from '../constants';\nimport { UTF8ToUint8 } from '../utils';\n\n/**\n * Derives a symmetric key from the base key and context string\n *\n * @param context - The context string.\n * The context string should be hardcoded, globally unique, and application-specific.\n * @param baseKey - The base key (NOT PASSWORD!)\n * @returns The derived secret key\n */\nexport function deriveSymmetricKeyFromContext(context: string, baseKey: Uint8Array): Uint8Array {\n  return blake3(baseKey, { context: UTF8ToUint8(context) });\n}\n\n/**\n * Derives a symmetric key from two keys\n *\n * @param key1 - The 32-bytes key\n * @param key2 - The 32-bytes key\n * @returns The derived secret key\n */\nexport function deriveSymmetricKeyFromTwoKeys(key1: Uint8Array, key2: Uint8Array): Uint8Array {\n  try {\n    if (key2.length != AES_KEY_BYTE_LENGTH || key1.length != AES_KEY_BYTE_LENGTH) {\n      throw new Error(`Input key length must be exactly ${AES_KEY_BYTE_LENGTH} bytes`);\n    }\n    const key = blake3(key1, { key: key2 });\n    return deriveSymmetricKeyFromContext(CONTEXT_DERIVE, key);\n  } catch (error) {\n    throw new Error('Failed to derive symmetric key from two keys and context', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAYA,SAAgB,8BAA8B,SAAiB,SAAiC;AAC9F,4CAAc,SAAS,EAAE,SAASA,0BAAY,QAAQ,EAAE,CAAC;;;;;;;;;AAU3D,SAAgB,8BAA8B,MAAkB,MAA8B;AAC5F,KAAI;AACF,MAAI,KAAK,UAAUC,yCAAuB,KAAK,UAAUA,sCACvD,OAAM,IAAI,MAAM,oCAAoCA,sCAAoB,QAAQ;AAGlF,SAAO,8BAA8BC,sEADlB,MAAM,EAAE,KAAK,MAAM,CAAC,CACkB;UAClD,OAAO;AACd,QAAM,IAAI,MAAM,4DAA4D,EAAE,OAAO,OAAO,CAAC"}

package/dist/deriveKeysFromKey-DPU_h7wr.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"deriveKeysFromKey-DPU_h7wr.mjs","names":[],"sources":["../src/derive-key/deriveKeysFromKey.ts"],"sourcesContent":["import { blake3 } from '@noble/hashes/blake3.js';\nimport { AES_KEY_BYTE_LENGTH, CONTEXT_DERIVE } from '../constants';\nimport { UTF8ToUint8 } from '../utils';\n\n/**\n * Derives a symmetric key from the base key and context string\n *\n * @param context - The context string.\n * The context string should be hardcoded, globally unique, and application-specific.\n * @param baseKey - The base key (NOT PASSWORD!)\n * @returns The derived secret key\n */\nexport function deriveSymmetricKeyFromContext(context: string, baseKey: Uint8Array): Uint8Array {\n  return blake3(baseKey, { context: UTF8ToUint8(context) });\n}\n\n/**\n * Derives a symmetric key from two keys\n *\n * @param key1 - The 32-bytes key\n * @param key2 - The 32-bytes key\n * @returns The derived secret key\n */\nexport function deriveSymmetricKeyFromTwoKeys(key1: Uint8Array, key2: Uint8Array): Uint8Array {\n  try {\n    if (key2.length != AES_KEY_BYTE_LENGTH || key1.length != AES_KEY_BYTE_LENGTH) {\n      throw new Error(`Input key length must be exactly ${AES_KEY_BYTE_LENGTH} bytes`);\n    }\n    const key = blake3(key1, { key: key2 });\n    return deriveSymmetricKeyFromContext(CONTEXT_DERIVE, key);\n  } catch (error) {\n    throw new Error('Failed to derive symmetric key from two keys and context', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAYA,SAAgB,8BAA8B,SAAiB,SAAiC;AAC9F,QAAO,OAAO,SAAS,EAAE,SAAS,YAAY,QAAQ,EAAE,CAAC;;;;;;;;;AAU3D,SAAgB,8BAA8B,MAAkB,MAA8B;AAC5F,KAAI;AACF,MAAI,KAAK,UAAU,uBAAuB,KAAK,UAAU,oBACvD,OAAM,IAAI,MAAM,oCAAoC,oBAAoB,QAAQ;AAGlF,SAAO,8BAA8B,gBADzB,OAAO,MAAM,EAAE,KAAK,MAAM,CAAC,CACkB;UAClD,OAAO;AACd,QAAM,IAAI,MAAM,4DAA4D,EAAE,OAAO,OAAO,CAAC"}

package/dist/email-crypto.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"email-crypto.js","names":["encryptEmailBody","encryptKeysHybrid","decryptKeysHybrid","decryptEmailBody","encryptEmailBody","passwordProtectKey","removePasswordProtection","decryptEmailBody","genHybridKeys"],"sources":["../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/emailKeys.ts"],"sourcesContent":["import { HybridEncryptedEmail, EmailBody, RecipientWithPublicKey } from '../types';\nimport { decryptEmailBody, encryptKeysHybrid, decryptKeysHybrid, encryptEmailBody } from './core';\n\n/**\n * Encrypts the email body using hybrid encryption.\n *\n * @param body - The email body to encrypt.\n * @param recipientPublicKeys - The public keys of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The encrypted email body\n */\nexport async function encryptEmailHybrid(\n  body: EmailBody,\n  recipient: RecipientWithPublicKey,\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n    const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to encrypt email body with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email body using hybrid encryption for multiple recipients.\n *\n * @param body - The email body to encrypt for multiple recipients.\n * @param recipients - The recipients with corresponding public keys.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The set of encrypted email bodies\n */\nexport async function encryptEmailHybridForMultipleRecipients(\n  body: EmailBody,\n  recipients: RecipientWithPublicKey[],\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail[]> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n\n    const encryptedEmails: HybridEncryptedEmail[] = [];\n    for (const recipient of recipients) {\n      const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n      encryptedEmails.push({\n        encEmailBody: encEmailBody,\n        encryptedKey,\n      });\n    }\n    return encryptedEmails;\n  } catch (error) {\n    throw new Error('Failed to encrypt email to multiple recipients with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Decrypts the email using hybrid encryption.\n *\n * @param encEmailBody - The encrypted email.\n * @param recipientPrivateHybridKeys - The private key of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email body\n */\nexport async function decryptEmailHybrid(\n  encEmailBody: HybridEncryptedEmail,\n  recipientPrivateHybridKeys: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await decryptKeysHybrid(encEmailBody.encryptedKey, recipientPrivateHybridKeys);\n    const body = await decryptEmailBody(encEmailBody.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt email with hybrid encryption', { cause: error });\n  }\n}\n","import { PwdProtectedEmail, EmailBody } from '../types';\nimport { decryptEmailBody, passwordProtectKey, removePasswordProtection, encryptEmailBody } from './core';\n\n/**\n * Creates a password-protected email.\n *\n * @param email - The email to password-protect\n * @param password - The secret password shared among recipients\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The password-protected email\n */\nexport async function createPwdProtectedEmail(\n  emailBody: EmailBody,\n  password: string,\n  aux?: Uint8Array,\n): Promise<PwdProtectedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(emailBody, aux);\n    const encryptedKey = await passwordProtectKey(encryptionKey, password);\n\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to password-protect email', { cause: error });\n  }\n}\n\n/**\n * Opens a password-protected email.\n *\n * @param encryptedEmail - The encrypted email\n * @param password - The secret password shared among recipients.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email body\n */\nexport async function decryptPwdProtectedEmail(\n  encryptedEmail: PwdProtectedEmail,\n  password: string,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);\n    const body = await decryptEmailBody(encryptedEmail.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt password-protect email', { cause: error });\n  }\n}\n","import { genHybridKeys } from '../hybrid-crypto';\nimport { HybridKeyPair } from '../types';\n\n/**\n * Generates public and private keys for email encryption.\n *\n * @returns The user's private and public keys\n */\nexport async function generateEmailKeys(): Promise<HybridKeyPair> {\n  return genHybridKeys();\n}\n"],"mappings":";;;;;;;;;;;;;AAWA,eAAsB,mBACpB,MACA,WACA,KAC+B;AAC/B,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAMA,8BAAiB,MAAM,IAAI;AAEzE,SAAO;GAAE;GAAc,cADF,MAAMC,+BAAkB,eAAe,UAAU;GACjC;UAC9B,OAAO;AACd,QAAM,IAAI,MAAM,uDAAuD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY5F,eAAsB,wCACpB,MACA,YACA,KACiC;AACjC,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAMD,8BAAiB,MAAM,IAAI;EAEzE,MAAM,kBAA0C,EAAE;AAClD,OAAK,MAAM,aAAa,YAAY;GAClC,MAAM,eAAe,MAAMC,+BAAkB,eAAe,UAAU;AACtE,mBAAgB,KAAK;IACL;IACd;IACD,CAAC;;AAEJ,SAAO;UACA,OAAO;AACd,QAAM,IAAI,MAAM,yEAAyE,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY9G,eAAsB,mBACpB,cACA,4BACA,KACoB;AACpB,KAAI;EACF,MAAM,gBAAgB,MAAMC,+BAAkB,aAAa,cAAc,2BAA2B;AAEpG,SADa,MAAMC,8BAAiB,aAAa,cAAc,eAAe,IAAI;UAE3E,OAAO;AACd,QAAM,IAAI,MAAM,kDAAkD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;AC9DvF,eAAsB,wBACpB,WACA,UACA,KAC4B;AAC5B,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAMC,8BAAiB,WAAW,IAAI;AAG9E,SAAO;GAAE;GAAc,cAFF,MAAMC,gCAAmB,eAAe,SAAS;GAEjC;UAC9B,OAAO;AACd,QAAM,IAAI,MAAM,oCAAoC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYzE,eAAsB,yBACpB,gBACA,UACA,KACoB;AACpB,KAAI;EACF,MAAM,gBAAgB,MAAMC,sCAAyB,eAAe,cAAc,SAAS;AAE3F,SADa,MAAMC,8BAAiB,eAAe,cAAc,eAAe,IAAI;UAE7E,OAAO;AACd,QAAM,IAAI,MAAM,4CAA4C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;ACpCjF,eAAsB,oBAA4C;AAChE,QAAOC,6BAAe"}

package/dist/email-crypto.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"email-crypto.mjs","names":[],"sources":["../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/emailKeys.ts"],"sourcesContent":["import { HybridEncryptedEmail, EmailBody, RecipientWithPublicKey } from '../types';\nimport { decryptEmailBody, encryptKeysHybrid, decryptKeysHybrid, encryptEmailBody } from './core';\n\n/**\n * Encrypts the email body using hybrid encryption.\n *\n * @param body - The email body to encrypt.\n * @param recipientPublicKeys - The public keys of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The encrypted email body\n */\nexport async function encryptEmailHybrid(\n  body: EmailBody,\n  recipient: RecipientWithPublicKey,\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n    const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to encrypt email body with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email body using hybrid encryption for multiple recipients.\n *\n * @param body - The email body to encrypt for multiple recipients.\n * @param recipients - The recipients with corresponding public keys.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The set of encrypted email bodies\n */\nexport async function encryptEmailHybridForMultipleRecipients(\n  body: EmailBody,\n  recipients: RecipientWithPublicKey[],\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail[]> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n\n    const encryptedEmails: HybridEncryptedEmail[] = [];\n    for (const recipient of recipients) {\n      const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n      encryptedEmails.push({\n        encEmailBody: encEmailBody,\n        encryptedKey,\n      });\n    }\n    return encryptedEmails;\n  } catch (error) {\n    throw new Error('Failed to encrypt email to multiple recipients with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Decrypts the email using hybrid encryption.\n *\n * @param encEmailBody - The encrypted email.\n * @param recipientPrivateHybridKeys - The private key of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email body\n */\nexport async function decryptEmailHybrid(\n  encEmailBody: HybridEncryptedEmail,\n  recipientPrivateHybridKeys: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await decryptKeysHybrid(encEmailBody.encryptedKey, recipientPrivateHybridKeys);\n    const body = await decryptEmailBody(encEmailBody.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt email with hybrid encryption', { cause: error });\n  }\n}\n","import { PwdProtectedEmail, EmailBody } from '../types';\nimport { decryptEmailBody, passwordProtectKey, removePasswordProtection, encryptEmailBody } from './core';\n\n/**\n * Creates a password-protected email.\n *\n * @param email - The email to password-protect\n * @param password - The secret password shared among recipients\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The password-protected email\n */\nexport async function createPwdProtectedEmail(\n  emailBody: EmailBody,\n  password: string,\n  aux?: Uint8Array,\n): Promise<PwdProtectedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(emailBody, aux);\n    const encryptedKey = await passwordProtectKey(encryptionKey, password);\n\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to password-protect email', { cause: error });\n  }\n}\n\n/**\n * Opens a password-protected email.\n *\n * @param encryptedEmail - The encrypted email\n * @param password - The secret password shared among recipients.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email body\n */\nexport async function decryptPwdProtectedEmail(\n  encryptedEmail: PwdProtectedEmail,\n  password: string,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);\n    const body = await decryptEmailBody(encryptedEmail.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt password-protect email', { cause: error });\n  }\n}\n","import { genHybridKeys } from '../hybrid-crypto';\nimport { HybridKeyPair } from '../types';\n\n/**\n * Generates public and private keys for email encryption.\n *\n * @returns The user's private and public keys\n */\nexport async function generateEmailKeys(): Promise<HybridKeyPair> {\n  return genHybridKeys();\n}\n"],"mappings":";;;;;;;;;;;;AAWA,eAAsB,mBACpB,MACA,WACA,KAC+B;AAC/B,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAM,iBAAiB,MAAM,IAAI;AAEzE,SAAO;GAAE;GAAc,cADF,MAAM,kBAAkB,eAAe,UAAU;GACjC;UAC9B,OAAO;AACd,QAAM,IAAI,MAAM,uDAAuD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY5F,eAAsB,wCACpB,MACA,YACA,KACiC;AACjC,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAM,iBAAiB,MAAM,IAAI;EAEzE,MAAM,kBAA0C,EAAE;AAClD,OAAK,MAAM,aAAa,YAAY;GAClC,MAAM,eAAe,MAAM,kBAAkB,eAAe,UAAU;AACtE,mBAAgB,KAAK;IACL;IACd;IACD,CAAC;;AAEJ,SAAO;UACA,OAAO;AACd,QAAM,IAAI,MAAM,yEAAyE,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY9G,eAAsB,mBACpB,cACA,4BACA,KACoB;AACpB,KAAI;EACF,MAAM,gBAAgB,MAAM,kBAAkB,aAAa,cAAc,2BAA2B;AAEpG,SADa,MAAM,iBAAiB,aAAa,cAAc,eAAe,IAAI;UAE3E,OAAO;AACd,QAAM,IAAI,MAAM,kDAAkD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;AC9DvF,eAAsB,wBACpB,WACA,UACA,KAC4B;AAC5B,KAAI;EACF,MAAM,EAAE,eAAe,iBAAiB,MAAM,iBAAiB,WAAW,IAAI;AAG9E,SAAO;GAAE;GAAc,cAFF,MAAM,mBAAmB,eAAe,SAAS;GAEjC;UAC9B,OAAO;AACd,QAAM,IAAI,MAAM,oCAAoC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYzE,eAAsB,yBACpB,gBACA,UACA,KACoB;AACpB,KAAI;EACF,MAAM,gBAAgB,MAAM,yBAAyB,eAAe,cAAc,SAAS;AAE3F,SADa,MAAM,iBAAiB,eAAe,cAAc,eAAe,IAAI;UAE7E,OAAO;AACd,QAAM,IAAI,MAAM,4CAA4C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;ACpCjF,eAAsB,oBAA4C;AAChE,QAAO,eAAe"}

package/dist/email-search.d.mts

@@ -1,232 +0,0 @@
-import { Email, EmailSearchResult, MailCache, StoredEmail } from "./types.mjs";
-import { DBSchema, IDBPDatabase } from "idb";
-import { Index } from "flexsearch";
-
-//#region src/email-search/indexedDB.d.ts
-type MailDB = IDBPDatabase<EncryptedSearchDB>;
-interface EncryptedSearchDB extends DBSchema {
-  email: {
-    key: string;
-    value: StoredEmail;
-    indexes: {
-      byTime: number[];
-    };
-  };
-}
-/**
- * Opens IndexedDB database for the given user
- *
- * @param userID - The user ID
- * @returns The database
- */
-declare const openDatabase: (userID: string) => Promise<MailDB>;
-/**
- * Closes the IndexedDB database
- *
- * @param esDB - The database
- */
-declare const closeDatabase: (esDB: MailDB) => void;
-/**
- * Deletes IndexedDB database for the given user
- *
- * @param userID - The user ID
- * @returns The database
- */
-declare const deleteDatabase: (userID: string) => Promise<void>;
-/**
- * Derives database encryption key for the given user
- *
- * @param userID - The user ID
- * @returns The symmetric key for protecting database
- */
-declare const deriveIndexKey: (baseKey: Uint8Array) => Promise<Uint8Array>;
-/**
- * Encrypts the given email and stores it in the IndexedDB database
- *
- * @param newEmailToStore - The email for storing
- * @param indexKey - The symmetric key for protecting database
- * @param esDB - The database
- */
-declare const encryptAndStoreEmail: (newEmailToStore: Email, indexKey: Uint8Array, esDB: MailDB) => Promise<void>;
-/**
- * Encrypts the given set of emails and stores it in the IndexedDB database
- *
- * @param newEmailsToStore - The set of emails for storing
- * @param indexKey - The symmetric key key for protecting database
- * @param esDB - The database
- */
-declare const encryptAndStoreManyEmail: (newEmailsToStore: Email[], indexKey: Uint8Array, esDB: MailDB) => Promise<void>;
-/**
- * Fetches the email from the database and decrypts it
- *
- * @param emailID - The email identifier
- * @param indexKey - The symmetric key key for protecting database
- * @param encryptedEmail - The encrypted email
- * @returns The decrypted email
- */
-declare const getAndDecryptEmail: (emailID: string, indexKey: Uint8Array, esDB: MailDB) => Promise<Email>;
-/**
- * Fetches all email from the database and decrypts them
- *
- * @param indexKey - The symmetric key key for protecting database
- * @param esDB - The database
- * @returns The decrypted emails
- */
-declare const getAndDecryptAllEmails: (indexKey: Uint8Array, esDB: MailDB) => Promise<Email[]>;
-/**
- * Deletes the email from the database
- *
- * @param emailID - The email identifier
- * @param esDB - The database
- */
-declare const deleteEmail: (emailID: string, esDB: MailDB) => Promise<void>;
-/**
- * Returns the number of stored email
- *
- * @param esDB - The database
- * @returns The number of stored emails
- */
-declare const getEmailCount: (esDB: MailDB) => Promise<number>;
-/**
- * Removes the given number of oldests emails from the database
- *
- * @param emailsToDelete - The number of emails to delete
- * @param esDB - The database
- */
-declare const deleteOldestEmails: (emailsToDelete: number, esDB: MailDB) => Promise<void>;
-/**
- * Enforces the maximum email number in the database
- *
- * @param esDB - The database
- * @param max - The maximum allowed number of emails
- */
-declare const enforceMaxEmailNumber: (esDB: MailDB, max: number) => Promise<void>;
-/**
- * Fetches all emails from the database, decrypts them and sortes the results based on the creation time (newest first)
- *
- * @param esDB - The database
- * @param indexKey - The symmetric Uint8Array key for protecting database
- * @returns The number of stored emails
- */
-declare const getAllEmailsSortedNewestFirst: (esDB: MailDB, indexKey: Uint8Array) => Promise<Email[]>;
-/**
- * Fetches all emails from the database, decrypts them and sortes the results based on the creation time (oldest first)
- *
- * @param esDB - The database
- * @param indexKey - The symmetric key for protecting database
- * @returns The number of stored emails
- */
-declare const getAllEmailsSortedOldestFirst: (esDB: MailDB, indexKey: Uint8Array) => Promise<Email[]>;
-/**
- * Fetches a batch of emails from the database, decrypts them and sortes the results based on the creation time (newest first)
- *
- * @param esDB - The database
- * @param indexKey - The symmetric key for protecting database
- * @param batchSize - The size of the batch
- * @param startCursor - The starting point (optional). If not given, starts from the beginning
- * @returns The number of stored emails
- */
-declare const getEmailBatch: (esDB: MailDB, indexKey: Uint8Array, batchSize: number, startCursor?: IDBValidKey) => Promise<{
-  emails: Email[];
-  nextCursor?: IDBValidKey;
-}>;
-//#endregion
-//#region src/email-search/mailCache.d.ts
-/**
- * Fetches all emails from the database in batches and cahces them
- *
- * @param indexKey - The symmetric key for protecting database
- * @param esCache - The cache to add emails too
- * @param esDB - The database
- */
-declare const createCacheFromDB: (indexKey: Uint8Array, esDB: MailDB) => Promise<MailCache<Email>>;
-/**
- * Gets an email from the cache
- *
- * @param emailID - The email identifier
- * @param esCache - The email cache
- * @returns The found email or throws an error
- */
-declare const getEmailFromCache: (emailID: string, esCache: MailCache<Email>) => Promise<Email>;
-/**
- * Removes the email from cache
- *
- * @param emailID - The email identifier
- * @param esCache - The email cache
- */
-declare const deleteEmailFromCache: (emailID: string, esCache: MailCache<Email>) => Promise<void>;
-/**
- * Adds emails to the cache
- *
- * @param emails - The emails to add
- * @param esCache - The email cache
- * @returns TRUE if all emails were added sucessfully, or FALSE and error reason.
- */
-declare function addEmailsToCache(emails: Email[], esCache: MailCache<Email>): {
-  success: boolean;
-  reason?: string;
-};
-/**
- * Adds email to the cache
- *
- * @param email - The email to add
- * @param esCache - The email cache
- * @returns TRUE if the email was added sucessfully, or FALSE and error reason.
- */
-declare const addEmailToCache: (email: Email, esCache: MailCache<Email>) => {
-  success: boolean;
-  reason?: string;
-};
-//#endregion
-//#region src/email-search/search.d.ts
-interface EmailSearchIndex {
-  subjectIndex: Index;
-  bodyIndex: Index;
-  fromIndex: Index;
-  toIndex: Index;
-  isReady: boolean;
-}
-/**
- * Adds the given email to the email search index
- *
- * @param email - The email to add
- * @param searchIndex - The email search index
- */
-declare const addEmailToSearchIndex: (email: Email, searchIndex: EmailSearchIndex) => void;
-/**
- * Removes the email from the email search index
- *
- * @param emailID - The email identifier
- * @param searchIndex - The email search index
- */
-declare const removeEmailFromSearchIndex: (emailID: string, searchIndex: EmailSearchIndex) => void;
-/**
- * Buils the email search index from the email cache
- *
- * @param esCache - The email cache
- * @returns  The email search index
- */
-declare const buildSearchIndexFromCache: (esCache: MailCache<Email>) => Promise<EmailSearchIndex>;
-interface SearchOptions {
-  fields?: ('subject' | 'body' | 'from' | 'to')[];
-  limit?: number;
-  boost?: {
-    subject?: number;
-    body?: number;
-    from?: number;
-    to?: number;
-  };
-}
-/**
- * Searches in teh
- *
- * @param query - The string to search for
- * @param esCache - The email cache
- * @param searchIndex - The email search index
- * @param opetions - The optional search limitations
- * @returns The result of the email search (emails ans their corresponding result weights)
- */
-declare const searchEmails: (query: string, esCache: MailCache<Email>, searchIndex: EmailSearchIndex, options?: SearchOptions) => Promise<EmailSearchResult[]>;
-//#endregion
-export { EmailSearchIndex, EncryptedSearchDB, MailDB, SearchOptions, addEmailToCache, addEmailToSearchIndex, addEmailsToCache, buildSearchIndexFromCache, closeDatabase, createCacheFromDB, deleteDatabase, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, encryptAndStoreEmail, encryptAndStoreManyEmail, enforceMaxEmailNumber, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getEmailBatch, getEmailCount, getEmailFromCache, openDatabase, removeEmailFromSearchIndex, searchEmails };
-//# sourceMappingURL=email-search.d.mts.map

package/dist/email-search.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"email-search.d.mts","names":[],"sources":["../src/email-search/indexedDB.ts","../src/email-search/mailCache.ts","../src/email-search/search.ts"],"mappings":"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"}