internxt-crypto 0.0.10-alpha → 0.0.13

package/dist/email-search.js

@@ -1,582 +1,577 @@
-'use strict';
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('./chunk-EbLFQX5m.js');
+const require_constants = require('./constants.js');
+const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-Ko7NxkHM.js');
+const require_emailKeys = require('./emailKeys-BJGdkLrg.js');
+let idb = require("idb");
+let flexsearch = require("flexsearch");
 
-var idb = require('idb');
-var blake3_js = require('@noble/hashes/blake3.js');
-var utils_js$1 = require('@noble/hashes/utils.js');
-var utils_js = require('@noble/post-quantum/utils.js');
-require('uuid');
-var flexsearch = require('flexsearch');
-
-// src/email-search/indexedDB.ts
-
-// src/constants.ts
-var AES_ALGORITHM = "AES-GCM";
-var AES_KEY_BIT_LENGTH = 256;
-var AUX_LEN = 128;
-var IV_LEN_BYTES = 16;
-var KEY_FORMAT = "raw";
-var CONTEXT_INDEX = "CRYPTO library 2025-07-30 17:20:00 key for protecting current search indices";
-var MAX_CACHE_SIZE = 6e8;
-var MAX_EMAIL_PER_BATCH = 100;
-var DB_LABEL = "email";
-var DB_VERSION = 1;
-function getBytesFromString(bytes, value) {
-  return blake3_js.blake3(utils_js$1.utf8ToBytes(value), { dkLen: bytes });
-}
-
-// src/symmetric-crypto/keys.ts
-async function importSymmetricCryptoKey(keyData) {
-  return crypto.subtle.importKey(
-    KEY_FORMAT,
-    new Uint8Array(keyData),
-    {
-      name: AES_ALGORITHM,
-      length: AES_KEY_BIT_LENGTH
-    },
-    true,
-    ["encrypt", "decrypt"]
-  );
-}
-async function createNISTbasedIV(freeField) {
-  try {
-    if (!freeField) {
-      return utils_js.randomBytes(IV_LEN_BYTES);
-    }
-    const iv = new Uint8Array(16);
-    const randFiled = utils_js.randomBytes(12);
-    iv.set(randFiled, 0);
-    const freeFiledFixedLength = await getBytesFromString(4, freeField);
-    iv.set(freeFiledFixedLength, 12);
-    return iv;
-  } catch (error) {
-    throw new Error("Failed to create IV", { cause: error });
-  }
-}
-async function makeAuxFixedLength(aux) {
-  return getBytesFromString(AUX_LEN / 8, aux);
-}
-async function encryptMessage(message, encryptionKey, iv, additionalData) {
-  try {
-    const encrypted = await crypto.subtle.encrypt(
-      { name: AES_ALGORITHM, iv, additionalData },
-      encryptionKey,
-      message
-    );
-    return new Uint8Array(encrypted);
-  } catch (error) {
-    throw new Error("Failed to encrypt symmetrically", { cause: error });
-  }
-}
-async function decryptMessage(ciphertext, iv, encryptionKey, additionalData) {
-  try {
-    const decrypted = await crypto.subtle.decrypt(
-      { name: AES_ALGORITHM, iv, additionalData },
-      encryptionKey,
-      ciphertext
-    );
-    return new Uint8Array(decrypted);
-  } catch (error) {
-    throw new Error("Failed to decrypt symmetrically", { cause: error });
-  }
-}
-
-// src/symmetric-crypto/aes.ts
-async function encryptSymmetrically(encryptionKey, message, aux, freeField) {
-  try {
-    const iv = await createNISTbasedIV(freeField);
-    const additionalData = await makeAuxFixedLength(aux);
-    const ciphertext = await encryptMessage(message, encryptionKey, iv, additionalData);
-    return { ciphertext, iv };
-  } catch (error) {
-    throw new Error("Failed to encrypt symmetrically", { cause: error });
-  }
-}
-async function decryptSymmetrically(encryptionKey, encryptedMessage, aux) {
-  try {
-    const additionalData = await makeAuxFixedLength(aux);
-    const result = await decryptMessage(
-      encryptedMessage.ciphertext,
-      encryptedMessage.iv,
-      encryptionKey,
-      additionalData
-    );
-    return result;
-  } catch (error) {
-    throw new Error("Failed to decrypt symmetrically", { cause: error });
-  }
-}
-function UTF8ToUint8(str) {
-  return new TextEncoder().encode(str);
-}
-function uint8ToUTF8(array) {
-  return new TextDecoder().decode(array);
-}
-
-// src/email-crypto/converters.ts
-function emailBodyToBinary(body) {
-  try {
-    const json = JSON.stringify(body);
-    return UTF8ToUint8(json);
-  } catch (error) {
-    throw new Error("Failed to convert EmailBody to Uint8Array", { cause: error });
-  }
-}
-function binaryToEmailBody(array) {
-  try {
-    const json = uint8ToUTF8(array);
-    const email = JSON.parse(json);
-    return email;
-  } catch (error) {
-    throw new Error("Failed to convert Uint8Array to EmailBody", { cause: error });
-  }
-}
-function emailToBinary(email) {
-  try {
-    const json = JSON.stringify(email);
-    return UTF8ToUint8(json);
-  } catch (error) {
-    throw new Error("Failed to convert EmailBody to Uint8Array", { cause: error });
-  }
-}
-function deriveSymmetricKeyFromContext(context, baseKey) {
-  return blake3_js.blake3(baseKey, { context: UTF8ToUint8(context) });
-}
-async function deriveSymmetricCryptoKeyFromContext(context, baseKey) {
-  try {
-    if (baseKey.length != AES_KEY_BIT_LENGTH / 8) {
-      throw new Error(`Base key length must be exactly ${AES_KEY_BIT_LENGTH / 8} bytes`);
-    }
-    if (!context) ;
-    const keyBytes = deriveSymmetricKeyFromContext(context, baseKey);
-    const key = await importSymmetricCryptoKey(keyBytes);
-    return key;
-  } catch (error) {
-    throw new Error("Failed to derive CryptoKey from base key and context", { cause: error });
-  }
-}
-
-// src/email-crypto/core.ts
-async function encryptEmailContentSymmetricallyWithKey(emailBody, encryptionKey, aux, emailID) {
-  try {
-    const binaryEmail = emailBodyToBinary(emailBody);
-    const ciphertext = await encryptSymmetrically(encryptionKey, binaryEmail, aux, emailID);
-    return ciphertext;
-  } catch (error) {
-    throw new Error("Failed to symmetrically encrypt email with the given key", { cause: error });
-  }
-}
-async function decryptEmailSymmetrically(emailCiphertext, encryptionKey, aux) {
-  try {
-    const binaryEmail = await decryptSymmetrically(encryptionKey, emailCiphertext, aux);
-    const body = binaryToEmailBody(binaryEmail);
-    return body;
-  } catch (error) {
-    throw new Error("Failed to symmetrically decrypt email", { cause: error });
-  }
-}
-function getAux(params) {
-  try {
-    const { subject, replyToEmailID, sender, recipients } = params;
-    const aux = JSON.stringify({ subject, replyToEmailID, sender, recipients });
-    return aux;
-  } catch (error) {
-    throw new Error("Failed to create aux", { cause: error });
-  }
-}
-
-// src/email-search/indexedDB.ts
-var getDatabaseName = (userID) => {
-  return `ES:${userID}:DB`;
+//#region src/email-search/indexedDB.ts
+/**
+* Returns IndexedDB database name for the given user
+*
+* @param userID - The user ID
+* @returns The database name
+*/
+const getDatabaseName = (userID) => {
+	return `ES:${userID}:DB`;
 };
-var openDatabase = async (userID) => {
-  try {
-    const dbName = getDatabaseName(userID);
-    return idb.openDB(dbName, DB_VERSION, {
-      upgrade(db) {
-        if (!db.objectStoreNames.contains(DB_LABEL)) {
-          const store = db.createObjectStore(DB_LABEL, { keyPath: "id" });
-          store.createIndex("byTime", "params.createdAt");
-        }
-      }
-    });
-  } catch (error) {
-    throw new Error(`Cannot open a database for the user ${userID}`, { cause: error });
-  }
+/**
+* Opens IndexedDB database for the given user
+*
+* @param userID - The user ID
+* @returns The database
+*/
+const openDatabase = async (userID) => {
+	try {
+		return (0, idb.openDB)(getDatabaseName(userID), require_constants.DB_VERSION, { upgrade(db) {
+			if (!db.objectStoreNames.contains(require_constants.DB_LABEL)) db.createObjectStore(require_constants.DB_LABEL, { keyPath: "id" }).createIndex("byTime", "params.createdAt");
+		} });
+	} catch (error) {
+		throw new Error(`Cannot open a database for the user ${userID}`, { cause: error });
+	}
 };
-var closeDatabase = (esDB) => {
-  return esDB.close();
+/**
+* Closes the IndexedDB database
+*
+* @param esDB - The database
+*/
+const closeDatabase = (esDB) => {
+	return esDB.close();
 };
-var deleteDatabase = async (userID) => {
-  const dbName = getDatabaseName(userID);
-  return idb.deleteDB(dbName);
+/**
+* Deletes IndexedDB database for the given user
+*
+* @param userID - The user ID
+* @returns The database
+*/
+const deleteDatabase = async (userID) => {
+	return (0, idb.deleteDB)(getDatabaseName(userID));
 };
-var deriveIndexKey = async (baseKey) => {
-  return deriveSymmetricCryptoKeyFromContext(CONTEXT_INDEX, baseKey);
+/**
+* Derives database encryption key for the given user
+*
+* @param userID - The user ID
+* @returns The symmetric CryptoKey for protecting database
+*/
+const deriveIndexKey = async (baseKey) => {
+	return require_deriveKeysFromPassword.deriveSymmetricCryptoKeyFromContext(require_constants.CONTEXT_INDEX, baseKey);
 };
-var encryptAndStoreEmail = async (newEmailToStore, indexKey, esDB) => {
-  try {
-    const aux = getAux(newEmailToStore.params);
-    const ciphertext = await encryptEmailContentSymmetricallyWithKey(
-      newEmailToStore.body,
-      indexKey,
-      aux,
-      newEmailToStore.id
-    );
-    const encryptedEmail = { content: ciphertext, params: newEmailToStore.params, id: newEmailToStore.id };
-    await esDB.put(DB_LABEL, encryptedEmail);
-  } catch (error) {
-    throw new Error("Cannot encrypt and add the given email to the database", { cause: error });
-  }
+/**
+* Encrypts the given email and stores it in the IndexedDB database
+*
+* @param newEmailToStore - The email for storing
+* @param indexKey - The symmetric CryptoKey key for protecting database
+* @param esDB - The database
+*/
+const encryptAndStoreEmail = async (newEmailToStore, indexKey, esDB) => {
+	try {
+		const aux = require_emailKeys.getAux(newEmailToStore.params, false);
+		const encryptedEmail = {
+			enc: await require_emailKeys.encryptEmailContentSymmetricallyWithKey(newEmailToStore.body, indexKey, aux, newEmailToStore.id),
+			params: newEmailToStore.params,
+			id: newEmailToStore.id
+		};
+		await esDB.put(require_constants.DB_LABEL, encryptedEmail);
+	} catch (error) {
+		throw new Error("Cannot encrypt and add the given email to the database", { cause: error });
+	}
 };
-var encryptAndStoreManyEmail = async (newEmailsToStore, indexKey, esDB) => {
-  try {
-    const encryptedEmails = await Promise.all(
-      newEmailsToStore.map(async (email) => {
-        const aux = getAux(email.params);
-        const ciphertext = await encryptEmailContentSymmetricallyWithKey(email.body, indexKey, aux, email.id);
-        return { content: ciphertext, params: email.params, id: email.id };
-      })
-    );
-    const tr = esDB.transaction(DB_LABEL, "readwrite");
-    await Promise.all([...encryptedEmails.map((encEmail) => tr.store.put(encEmail)), tr.done]);
-  } catch (error) {
-    throw new Error("Cannot encrypt and add emails to the database", { cause: error });
-  }
+/**
+* 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 CryptoKey key for protecting database
+* @param esDB - The database
+*/
+const encryptAndStoreManyEmail = async (newEmailsToStore, indexKey, esDB) => {
+	try {
+		const encryptedEmails = await Promise.all(newEmailsToStore.map(async (email) => {
+			const aux = require_emailKeys.getAux(email.params, false);
+			return {
+				enc: await require_emailKeys.encryptEmailContentSymmetricallyWithKey(email.body, indexKey, aux, email.id),
+				params: email.params,
+				id: email.id
+			};
+		}));
+		const tr = esDB.transaction(require_constants.DB_LABEL, "readwrite");
+		await Promise.all([...encryptedEmails.map((encEmail) => tr.store.put(encEmail)), tr.done]);
+	} catch (error) {
+		throw new Error("Cannot encrypt and add emails to the database", { cause: error });
+	}
 };
-var decryptEmail = async (indexKey, encryptedEmail) => {
-  try {
-    const aux = getAux(encryptedEmail.params);
-    const email = await decryptEmailSymmetrically(encryptedEmail.content, indexKey, aux);
-    return { body: email, params: encryptedEmail.params, id: encryptedEmail.id };
-  } catch (error) {
-    throw new Error("Cannot decrypt the given email", { cause: error });
-  }
+/**
+* Decrypts the given email
+*
+* @param indexKey - The symmetric CryptoKey key for protecting database
+* @param encryptedEmail - The encrypted email
+* @returns The decrypted email
+*/
+const decryptEmail = async (indexKey, encryptedEmail) => {
+	try {
+		return {
+			body: await require_emailKeys.decryptEmailSymmetrically(indexKey, require_emailKeys.getAux(encryptedEmail.params, false), encryptedEmail.enc),
+			params: encryptedEmail.params,
+			id: encryptedEmail.id
+		};
+	} catch (error) {
+		throw new Error("Cannot decrypt the given email", { cause: error });
+	}
 };
-var getAndDecryptEmail = async (emailID, indexKey, esDB) => {
-  try {
-    const encryptedEmail = await esDB.get(DB_LABEL, emailID);
-    if (!encryptedEmail) {
-      throw new Error(`DB cannot find email with id ${emailID}`);
-    }
-    return decryptEmail(indexKey, encryptedEmail);
-  } catch (error) {
-    throw new Error(`Cannot fetch the email ${emailID} from the database`, { cause: error });
-  }
+/**
+* Fetches the email from the database and decrypts it
+*
+* @param emailID - The email identifier
+* @param indexKey - The symmetric CryptoKey key for protecting database
+* @param encryptedEmail - The encrypted email
+* @returns The decrypted email
+*/
+const getAndDecryptEmail = async (emailID, indexKey, esDB) => {
+	try {
+		const encryptedEmail = await esDB.get(require_constants.DB_LABEL, emailID);
+		if (!encryptedEmail) throw new Error(`DB cannot find email with id ${emailID}`);
+		return decryptEmail(indexKey, encryptedEmail);
+	} catch (error) {
+		throw new Error(`Cannot fetch the email ${emailID} from the database`, { cause: error });
+	}
 };
-var getAndDecryptAllEmails = async (indexKey, esDB) => {
-  try {
-    const encryptedEmails = await esDB.getAll(DB_LABEL);
-    const decryptedEmails = await Promise.all(
-      encryptedEmails.map(async (encEmail) => {
-        const aux = getAux(encEmail.params);
-        const body = await decryptEmailSymmetrically(encEmail.content, indexKey, aux);
-        return { body, params: encEmail.params, id: encEmail.id };
-      })
-    );
-    return decryptedEmails.filter((email) => email !== null);
-  } catch (error) {
-    throw new Error("Cannot fetch and decrypt all emails from the database", { cause: error });
-  }
+/**
+* Fetches all email from the database and decrypts them
+*
+* @param indexKey - The symmetric CryptoKey key for protecting database
+* @param esDB - The database
+* @returns The decrypted emails
+*/
+const getAndDecryptAllEmails = async (indexKey, esDB) => {
+	try {
+		const encryptedEmails = await esDB.getAll(require_constants.DB_LABEL);
+		return (await Promise.all(encryptedEmails.map(async (encEmail) => {
+			return {
+				body: await require_emailKeys.decryptEmailSymmetrically(indexKey, require_emailKeys.getAux(encEmail.params, false), encEmail.enc),
+				params: encEmail.params,
+				id: encEmail.id
+			};
+		}))).filter((email) => email !== null);
+	} catch (error) {
+		throw new Error("Cannot fetch and decrypt all emails from the database", { cause: error });
+	}
 };
-var deleteEmail = async (emailID, esDB) => {
-  await esDB.delete(DB_LABEL, emailID);
+/**
+* Deletes the email from the database
+*
+* @param emailID - The email identifier
+* @param esDB - The database
+*/
+const deleteEmail = async (emailID, esDB) => {
+	await esDB.delete(require_constants.DB_LABEL, emailID);
 };
-var getEmailCount = async (esDB) => {
-  return await esDB.count(DB_LABEL);
+/**
+* Returns the number of stored email
+*
+* @param esDB - The database
+* @returns The number of stored emails
+*/
+const getEmailCount = async (esDB) => {
+	return await esDB.count(require_constants.DB_LABEL);
 };
-var deleteOldestEmails = async (emailsToDelete, esDB) => {
-  try {
-    const tx = esDB.transaction(DB_LABEL, "readwrite");
-    const index = tx.store.index("byTime");
-    let cursor = await index.openCursor();
-    let deletedCount = 0;
-    while (cursor && deletedCount < emailsToDelete) {
-      await cursor.delete();
-      deletedCount++;
-      cursor = await cursor.continue();
-    }
-    await tx.done;
-  } catch (error) {
-    throw new Error(`Cannot delete ${emailsToDelete} oldests emails from the database`, { cause: error });
-  }
+/**
+* Removes the given number of oldests emails from the database
+*
+* @param emailsToDelete - The number of emails to delete
+* @param esDB - The database
+*/
+const deleteOldestEmails = async (emailsToDelete, esDB) => {
+	try {
+		const tx = esDB.transaction(require_constants.DB_LABEL, "readwrite");
+		let cursor = await tx.store.index("byTime").openCursor();
+		let deletedCount = 0;
+		while (cursor && deletedCount < emailsToDelete) {
+			await cursor.delete();
+			deletedCount++;
+			cursor = await cursor.continue();
+		}
+		await tx.done;
+	} catch (error) {
+		throw new Error(`Cannot delete ${emailsToDelete} oldests emails from the database`, { cause: error });
+	}
 };
-var enforceMaxEmailNumber = async (esDB, max) => {
-  try {
-    const currentCount = await getEmailCount(esDB);
-    if (currentCount <= max) {
-      return;
-    }
-    await deleteOldestEmails(currentCount - max, esDB);
-  } catch (error) {
-    throw new Error(`Cannot enforce the maximum of ${max} emails on the database`, { cause: error });
-  }
+/**
+* Enforces the maximum email number in the database
+*
+* @param esDB - The database
+* @param max - The maximum allowed number of emails
+*/
+const enforceMaxEmailNumber = async (esDB, max) => {
+	try {
+		const currentCount = await getEmailCount(esDB);
+		if (currentCount <= max) return;
+		await deleteOldestEmails(currentCount - max, esDB);
+	} catch (error) {
+		throw new Error(`Cannot enforce the maximum of ${max} emails on the database`, { cause: error });
+	}
 };
-var fetchEmails = async (esDB, indexKey, direction) => {
-  try {
-    const tx = esDB.transaction(DB_LABEL, "readonly");
-    const index = tx.store.index("byTime");
-    const encryptedEmails = [];
-    let cursor = await index.openCursor(null, direction);
-    while (cursor) {
-      encryptedEmails.push(cursor.value);
-      cursor = await cursor.continue();
-    }
-    const emails = await Promise.all(encryptedEmails.map((encryptedEmail) => decryptEmail(indexKey, encryptedEmail)));
-    return emails;
-  } catch (error) {
-    throw new Error("Cannot fetch emails from database", { cause: error });
-  }
+/**
+* Fetches all emails from the database, decrypts them and sortes the results in the specified order
+*
+* @param esDB - The database
+* @param indexKey - The symmetric CryptoKey key for protecting database
+* @param direction - The order of sorting. If 'next' - oldest first, if 'prev' - newest first
+* @returns Decryped emails in the specified order
+*/
+const fetchEmails = async (esDB, indexKey, direction) => {
+	try {
+		const index = esDB.transaction(require_constants.DB_LABEL, "readonly").store.index("byTime");
+		const encryptedEmails = [];
+		let cursor = await index.openCursor(null, direction);
+		while (cursor) {
+			encryptedEmails.push(cursor.value);
+			cursor = await cursor.continue();
+		}
+		return await Promise.all(encryptedEmails.map((encryptedEmail) => decryptEmail(indexKey, encryptedEmail)));
+	} catch (error) {
+		throw new Error("Cannot fetch emails from database", { cause: error });
+	}
 };
-var getAllEmailsSortedNewestFirst = async (esDB, indexKey) => {
-  return fetchEmails(esDB, indexKey, "prev");
+/**
+* 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 CryptoKey key for protecting database
+* @returns The number of stored emails
+*/
+const getAllEmailsSortedNewestFirst = async (esDB, indexKey) => {
+	return fetchEmails(esDB, indexKey, "prev");
 };
-var getAllEmailsSortedOldestFirst = async (esDB, indexKey) => {
-  return fetchEmails(esDB, indexKey, "next");
+/**
+* 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 CryptoKey key for protecting database
+* @returns The number of stored emails
+*/
+const getAllEmailsSortedOldestFirst = async (esDB, indexKey) => {
+	return fetchEmails(esDB, indexKey, "next");
 };
-var getEmailBatch = async (esDB, indexKey, batchSize, startCursor) => {
-  try {
-    const tx = esDB.transaction(DB_LABEL, "readonly");
-    const index = tx.store.index("byTime");
-    const encryptedEmails = [];
-    let cursor;
-    if (startCursor) {
-      const range = IDBKeyRange.upperBound(startCursor, true);
-      cursor = await index.openCursor(range, "prev");
-    } else {
-      cursor = await index.openCursor(null, "prev");
-    }
-    let count = 0;
-    let nextCursor;
-    while (cursor && count < batchSize) {
-      encryptedEmails.push(cursor.value);
-      nextCursor = cursor.key;
-      count++;
-      cursor = await cursor.continue();
-    }
-    const emails = await Promise.all(encryptedEmails.map((encryptedEmail) => decryptEmail(indexKey, encryptedEmail)));
-    return {
-      emails,
-      nextCursor: count === batchSize ? nextCursor : void 0
-    };
-  } catch (error) {
-    throw new Error(`Cannot fetch email batch of ${batchSize} from the database`, { cause: error });
-  }
+/**
+* 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 CryptoKey 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
+*/
+const getEmailBatch = async (esDB, indexKey, batchSize, startCursor) => {
+	try {
+		const index = esDB.transaction(require_constants.DB_LABEL, "readonly").store.index("byTime");
+		const encryptedEmails = [];
+		let cursor;
+		if (startCursor) {
+			const range = IDBKeyRange.upperBound(startCursor, true);
+			cursor = await index.openCursor(range, "prev");
+		} else cursor = await index.openCursor(null, "prev");
+		let count = 0;
+		let nextCursor;
+		while (cursor && count < batchSize) {
+			encryptedEmails.push(cursor.value);
+			nextCursor = cursor.key;
+			count++;
+			cursor = await cursor.continue();
+		}
+		return {
+			emails: await Promise.all(encryptedEmails.map((encryptedEmail) => decryptEmail(indexKey, encryptedEmail))),
+			nextCursor: count === batchSize ? nextCursor : void 0
+		};
+	} catch (error) {
+		throw new Error(`Cannot fetch email batch of ${batchSize} from the database`, { cause: error });
+	}
 };
 
-// src/email-search/mailCache.ts
+//#endregion
+//#region src/email-search/mailCache.ts
+/**
+* Estimates the email size in the memory
+*
+* @param email - The email
+* @returns The estimation of the email size
+*/
 function sizeOfEmail(email) {
-  return emailToBinary(email).byteLength;
+	return require_emailKeys.emailToBinary(email).byteLength;
 }
+/**
+* Creates an empty cache variable
+*
+* @returns The empty cache
+*/
 function createEmptyCache() {
-  return {
-    esCache: /* @__PURE__ */ new Map(),
-    cacheSize: 0,
-    isCacheLimited: false,
-    isCacheReady: true
-  };
+	return {
+		esCache: /* @__PURE__ */ new Map(),
+		cacheSize: 0,
+		isCacheLimited: false,
+		isCacheReady: true
+	};
 }
-var createCacheFromDB = async (indexKey, esDB) => {
-  const esCache = createEmptyCache();
-  esCache.isCacheReady = false;
-  try {
-    const count = await getEmailCount(esDB);
-    if (!count) {
-      esCache.isCacheReady = true;
-      return esCache;
-    }
-    if (count <= MAX_EMAIL_PER_BATCH) {
-      const emails = await getAllEmailsSortedNewestFirst(esDB, indexKey);
-      addEmailsToCache(emails, esCache);
-    } else {
-      let nextCursor = void 0;
-      let cacheFull = false;
-      while (!cacheFull) {
-        const { emails, nextCursor: newCursor } = await getEmailBatch(
-          esDB,
-          indexKey,
-          MAX_EMAIL_PER_BATCH,
-          nextCursor
-        );
-        if (!newCursor || !emails.length) break;
-        nextCursor = newCursor;
-        const success = addEmailsToCache(emails, esCache);
-        if (!success) cacheFull = true;
-      }
-    }
-    return esCache;
-  } catch (error) {
-    throw new Error(`Email caching failed: ${error}`);
-  }
+/**
+* Fetches all emails from the database in batches and cahces them
+*
+* @param indexKey - The symmetric CryptoKey key for protecting database
+* @param esCache - The cache to add emails too
+* @param esDB - The database
+*/
+const createCacheFromDB = async (indexKey, esDB) => {
+	const esCache = createEmptyCache();
+	esCache.isCacheReady = false;
+	try {
+		const count = await getEmailCount(esDB);
+		if (!count) {
+			esCache.isCacheReady = true;
+			return esCache;
+		}
+		if (count <= require_constants.MAX_EMAIL_PER_BATCH) addEmailsToCache(await getAllEmailsSortedNewestFirst(esDB, indexKey), esCache);
+		else {
+			let nextCursor = void 0;
+			let cacheFull = false;
+			while (!cacheFull) {
+				const { emails, nextCursor: newCursor } = await getEmailBatch(esDB, indexKey, require_constants.MAX_EMAIL_PER_BATCH, nextCursor);
+				if (!newCursor || !emails.length) break;
+				nextCursor = newCursor;
+				if (!addEmailsToCache(emails, esCache)) cacheFull = true;
+			}
+		}
+		return esCache;
+	} catch (error) {
+		throw new Error(`Email caching failed: ${error}`, { cause: error });
+	}
 };
-var getEmailFromCache = async (emailID, esCache) => {
-  const email = esCache.esCache.get(emailID);
-  if (!email) {
-    throw new Error(`Email not found in cache for ID: ${emailID}`);
-  }
-  return 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
+*/
+const getEmailFromCache = async (emailID, esCache) => {
+	const email = esCache.esCache.get(emailID);
+	if (!email) throw new Error(`Email not found in cache for ID: ${emailID}`);
+	return email;
 };
-var deleteEmailFromCache = async (emailID, esCache) => {
-  try {
-    const email = await getEmailFromCache(emailID, esCache);
-    const size = sizeOfEmail(email);
-    const removed = esCache.esCache.delete(emailID);
-    if (removed) esCache.cacheSize -= size;
-  } catch (error) {
-    throw new Error(`Failed to delete email with ID ${emailID}`, { cause: error });
-  }
+/**
+* Removes the email from cache
+*
+* @param emailID - The email identifier
+* @param esCache - The email cache
+*/
+const deleteEmailFromCache = async (emailID, esCache) => {
+	try {
+		const size = sizeOfEmail(await getEmailFromCache(emailID, esCache));
+		if (esCache.esCache.delete(emailID)) esCache.cacheSize -= size;
+	} catch (error) {
+		throw new Error(`Failed to delete email with ID ${emailID}`, { cause: error });
+	}
 };
+/**
+* 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.
+*/
 function addEmailsToCache(emails, esCache) {
-  try {
-    for (const email of emails) {
-      const result = addEmailToCache(email, esCache);
-      if (!result.success) return result;
-    }
-    return { success: true };
-  } catch (error) {
-    throw new Error("Failed to add emails to the cache", { cause: error });
-  }
+	try {
+		for (const email of emails) {
+			const result = addEmailToCache(email, esCache);
+			if (!result.success) return result;
+		}
+		return { success: true };
+	} catch (error) {
+		throw new Error("Failed to add emails to the cache", { cause: error });
+	}
 }
-var addEmailToCache = (email, esCache) => {
-  try {
-    if (esCache.esCache.has(email.id)) {
-      return { success: false, reason: "email already exists in cache" };
-    }
-    const emailSize = sizeOfEmail(email);
-    if (esCache.cacheSize + emailSize > MAX_CACHE_SIZE) {
-      esCache.isCacheLimited = true;
-      return { success: false, reason: "hit cache limit" };
-    }
-    esCache.esCache.set(email.id, email);
-    esCache.cacheSize += emailSize;
-    return { success: true };
-  } catch (error) {
-    throw new Error("Failed to add email to the cache", { cause: error });
-  }
+/**
+* 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.
+*/
+const addEmailToCache = (email, esCache) => {
+	try {
+		if (esCache.esCache.has(email.id)) return {
+			success: false,
+			reason: "email already exists in cache"
+		};
+		const emailSize = sizeOfEmail(email);
+		if (esCache.cacheSize + emailSize > require_constants.MAX_CACHE_SIZE) {
+			esCache.isCacheLimited = true;
+			return {
+				success: false,
+				reason: "hit cache limit"
+			};
+		}
+		esCache.esCache.set(email.id, email);
+		esCache.cacheSize += emailSize;
+		return { success: true };
+	} catch (error) {
+		throw new Error("Failed to add email to the cache", { cause: error });
+	}
 };
-var SUBJECT_OPTIONS = {
-  preset: "match",
-  tokenize: "forward",
-  resolution: 9,
-  minlength: 2,
-  optimize: true,
-  fastupdate: true,
-  cache: true
+
+//#endregion
+//#region src/email-search/search.ts
+const SUBJECT_OPTIONS = {
+	preset: "match",
+	tokenize: "forward",
+	resolution: 9,
+	minlength: 2,
+	optimize: true,
+	fastupdate: true,
+	cache: true
 };
-var BODY_OPTIONS = {
-  ...SUBJECT_OPTIONS,
-  minlength: 3,
-  resolution: 6
+const BODY_OPTIONS = {
+	...SUBJECT_OPTIONS,
+	minlength: 3,
+	resolution: 6
 };
-var FROM_OPTIONS = {
-  ...SUBJECT_OPTIONS,
-  tokenize: "strict",
-  minlength: 1
+const FROM_OPTIONS = {
+	...SUBJECT_OPTIONS,
+	tokenize: "strict",
+	minlength: 1
 };
-var TO_OPTIONS = {
-  ...SUBJECT_OPTIONS,
-  tokenize: "strict",
-  minlength: 1
+const TO_OPTIONS = {
+	...SUBJECT_OPTIONS,
+	tokenize: "strict",
+	minlength: 1
 };
-var createSearchIndex = () => ({
-  subjectIndex: new flexsearch.Index(SUBJECT_OPTIONS),
-  bodyIndex: new flexsearch.Index(BODY_OPTIONS),
-  fromIndex: new flexsearch.Index(FROM_OPTIONS),
-  toIndex: new flexsearch.Index(TO_OPTIONS),
-  isReady: false
+/**
+* Creates new email search index
+*
+* @returns The email search index
+*/
+const createSearchIndex = () => ({
+	subjectIndex: new flexsearch.Index(SUBJECT_OPTIONS),
+	bodyIndex: new flexsearch.Index(BODY_OPTIONS),
+	fromIndex: new flexsearch.Index(FROM_OPTIONS),
+	toIndex: new flexsearch.Index(TO_OPTIONS),
+	isReady: false
 });
-var addEmailToSearchIndex = (email, searchIndex) => {
-  try {
-    const emailId = email.id;
-    if (email.params.subject) {
-      searchIndex.subjectIndex.add(emailId, email.params.subject);
-    }
-    if (email.body?.text) {
-      searchIndex.bodyIndex.add(emailId, email.body.text);
-    }
-    if (email.params.sender) {
-      const senderText = `${email.params.sender.name || ""} ${email.params.sender.email || ""}`.trim();
-      searchIndex.fromIndex.add(emailId, senderText);
-    }
-    const recipientsList = email.params.recipients?.length ? email.params.recipients : [email.params.recipient];
-    const recipientsText = recipientsList.map((recipient) => `${recipient.name || ""} ${recipient.email || ""}`.trim()).join(" ");
-    searchIndex.toIndex.add(emailId, recipientsText);
-  } catch (error) {
-    throw new Error("Failed to add email to the search index", { cause: error });
-  }
+/**
+* Adds the given email to the email search index
+*
+* @param email - The email to add
+* @param searchIndex - The email search index
+*/
+const addEmailToSearchIndex = (email, searchIndex) => {
+	try {
+		const emailId = email.id;
+		if (email.params.subject) searchIndex.subjectIndex.add(emailId, email.params.subject);
+		if (email.body?.text) searchIndex.bodyIndex.add(emailId, email.body.text);
+		if (email.params.sender) {
+			const senderText = `${email.params.sender.name || ""} ${email.params.sender.email || ""}`.trim();
+			searchIndex.fromIndex.add(emailId, senderText);
+		}
+		const recipientsText = (email.params.recipients?.length ? email.params.recipients : [email.params.recipient]).map((recipient) => `${recipient.name || ""} ${recipient.email || ""}`.trim()).join(" ");
+		searchIndex.toIndex.add(emailId, recipientsText);
+	} catch (error) {
+		throw new Error("Failed to add email to the search index", { cause: error });
+	}
 };
-var removeEmailFromSearchIndex = (emailID, searchIndex) => {
-  try {
-    searchIndex.subjectIndex.remove(emailID);
-    searchIndex.bodyIndex.remove(emailID);
-    searchIndex.fromIndex.remove(emailID);
-    searchIndex.toIndex.remove(emailID);
-  } catch (error) {
-    throw new Error(`Failed to remove email with ID ${emailID} from the search index`, { cause: error });
-  }
+/**
+* Removes the email from the email search index
+*
+* @param emailID - The email identifier
+* @param searchIndex - The email search index
+*/
+const removeEmailFromSearchIndex = (emailID, searchIndex) => {
+	try {
+		searchIndex.subjectIndex.remove(emailID);
+		searchIndex.bodyIndex.remove(emailID);
+		searchIndex.fromIndex.remove(emailID);
+		searchIndex.toIndex.remove(emailID);
+	} catch (error) {
+		throw new Error(`Failed to remove email with ID ${emailID} from the search index`, { cause: error });
+	}
 };
-var buildSearchIndexFromCache = async (esCache) => {
-  try {
-    const searchIndex = createSearchIndex();
-    searchIndex.isReady = false;
-    for (const email of esCache.esCache.values()) {
-      addEmailToSearchIndex(email, searchIndex);
-    }
-    searchIndex.isReady = true;
-    return searchIndex;
-  } catch (error) {
-    throw new Error("Failed build an email search index from the cache", { cause: error });
-  }
+/**
+* Buils the email search index from the email cache
+*
+* @param esCache - The email cache
+* @returns  The email search index
+*/
+const buildSearchIndexFromCache = async (esCache) => {
+	try {
+		const searchIndex = createSearchIndex();
+		searchIndex.isReady = false;
+		for (const email of esCache.esCache.values()) addEmailToSearchIndex(email, searchIndex);
+		searchIndex.isReady = true;
+		return searchIndex;
+	} catch (error) {
+		throw new Error("Failed build an email search index from the cache", { cause: error });
+	}
 };
-var searchEmails = async (query, esCache, searchIndex, options = {}) => {
-  try {
-    if (!searchIndex.isReady || !query.trim()) {
-      return [];
-    }
-    const {
-      fields = ["subject", "body", "from", "to"],
-      limit = 50,
-      boost = { subject: 3, body: 1, from: 2, to: 2 }
-    } = options;
-    const results = /* @__PURE__ */ new Map();
-    const searchPromises = fields.map(async (field) => {
-      let fieldResults;
-      switch (field) {
-        case "subject":
-          fieldResults = await searchIndex.subjectIndex.searchAsync(query);
-          break;
-        case "body":
-          fieldResults = await searchIndex.bodyIndex.searchAsync(query);
-          break;
-        case "from":
-          fieldResults = await searchIndex.fromIndex.searchAsync(query);
-          break;
-        case "to":
-          fieldResults = await searchIndex.toIndex.searchAsync(query);
-          break;
-        default:
-          return;
-      }
-      const fieldBoost = boost[field] || 1;
-      fieldResults.forEach((emailId) => {
-        const currentScore = results.get(String(emailId)) || 0;
-        results.set(String(emailId), currentScore + fieldBoost);
-      });
-    });
-    await Promise.all(searchPromises);
-    const emailResults = [];
-    for (const [emailId, score] of results) {
-      const email = esCache.esCache.get(emailId);
-      if (email) {
-        emailResults.push({ email, score });
-      }
-    }
-    emailResults.sort((a, b) => (b.score || 0) - (a.score || 0));
-    return emailResults.slice(0, limit);
-  } catch (error) {
-    throw new Error("Email search failed", { cause: error });
-  }
+/**
+* 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)
+*/
+const searchEmails = async (query, esCache, searchIndex, options = {}) => {
+	try {
+		if (!searchIndex.isReady || !query.trim()) return [];
+		const { fields = [
+			"subject",
+			"body",
+			"from",
+			"to"
+		], limit = 50, boost = {
+			subject: 3,
+			body: 1,
+			from: 2,
+			to: 2
+		} } = options;
+		const results = /* @__PURE__ */ new Map();
+		const searchPromises = fields.map(async (field) => {
+			let fieldResults;
+			switch (field) {
+				case "subject":
+					fieldResults = await searchIndex.subjectIndex.searchAsync(query);
+					break;
+				case "body":
+					fieldResults = await searchIndex.bodyIndex.searchAsync(query);
+					break;
+				case "from":
+					fieldResults = await searchIndex.fromIndex.searchAsync(query);
+					break;
+				case "to":
+					fieldResults = await searchIndex.toIndex.searchAsync(query);
+					break;
+				default: return;
+			}
+			const fieldBoost = boost[field] || 1;
+			fieldResults.forEach((emailId) => {
+				const currentScore = results.get(String(emailId)) || 0;
+				results.set(String(emailId), currentScore + fieldBoost);
+			});
+		});
+		await Promise.all(searchPromises);
+		const emailResults = [];
+		for (const [emailId, score] of results) {
+			const email = esCache.esCache.get(emailId);
+			if (email) emailResults.push({
+				email,
+				score
+			});
+		}
+		emailResults.sort((a, b) => (b.score || 0) - (a.score || 0));
+		return emailResults.slice(0, limit);
+	} catch (error) {
+		throw new Error("Email search failed", { cause: error });
+	}
 };
 
+//#endregion
 exports.addEmailToCache = addEmailToCache;
 exports.addEmailToSearchIndex = addEmailToSearchIndex;
 exports.addEmailsToCache = addEmailsToCache;
@@ -601,5 +596,4 @@ exports.getEmailFromCache = getEmailFromCache;
 exports.openDatabase = openDatabase;
 exports.removeEmailFromSearchIndex = removeEmailFromSearchIndex;
 exports.searchEmails = searchEmails;
-//# sourceMappingURL=email-search.js.map
 //# sourceMappingURL=email-search.js.map