internxt-crypto 0.0.14 → 1.0.1

package/dist/post-quantum-crypto.mjs

@@ -1,3 +1,47 @@
-import { n as encapsulateKyber, r as generateKyberKeys, t as decapsulateKyber } from "./kyber768-SXnIo-Nw.mjs";
+import { ml_kem768 } from "@noble/post-quantum/ml-kem.js";
 
-export { decapsulateKyber, encapsulateKyber, generateKyberKeys };
+//#region src/post-quantum-crypto/kyber768.ts
+/**
+* Generates public and secret Kyber keys
+*
+* @param seed - The optional seed
+* @returns The generated Kyber key pair.
+*/
+function generateKyberKeys(seed) {
+	try {
+		return ml_kem768.keygen(seed);
+	} catch (error) {
+		throw new Error("Failed to generate Kyber keys", { cause: error });
+	}
+}
+/**
+* Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
+*
+* @param publicKey - The public Kyber key
+* @returns The resulting encapsulation and the generated shared secret.
+*/
+function encapsulateKyber(publicKey) {
+	try {
+		return ml_kem768.encapsulate(publicKey);
+	} catch (error) {
+		throw new Error("Failed to encapsulate", { cause: error });
+	}
+}
+/**
+* Decapsulates the encapsulated shared secret using Kyber algorithms
+*
+* @param cipherText - The encapsulated key
+* @param secretKey - The private Kyber key
+* @returns The resulting decapsulated shared secret.
+*/
+function decapsulateKyber(cipherText, secretKey) {
+	try {
+		return ml_kem768.decapsulate(cipherText, secretKey);
+	} catch (error) {
+		throw new Error("Failed to decapsulate", { cause: error });
+	}
+}
+
+//#endregion
+export { decapsulateKyber, encapsulateKyber, generateKyberKeys };
+//# sourceMappingURL=post-quantum-crypto.mjs.map

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

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

package/dist/search-B9YM3XAA.mjs

@@ -0,0 +1,587 @@
+import { CONTEXT_INDEX, DB_LABEL, DB_VERSION, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH } from "./constants.mjs";
+import { s as UTF8ToUint8 } from "./genID-D08K7JPr.mjs";
+import { t as deriveSymmetricKeyFromContext } from "./deriveKeysFromKey-DPU_h7wr.mjs";
+import { i as encryptEmailBodyWithKey, t as decryptEmailBody } from "./core-pEGygy6S.mjs";
+import { deleteDB, openDB } from "idb";
+import { Index } from "flexsearch";
+
+//#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`;
+};
+/**
+* Opens IndexedDB database for the given user
+*
+* @param userID - The user ID
+* @returns The database
+*/
+const openDatabase = async (userID) => {
+	try {
+		return openDB(getDatabaseName(userID), DB_VERSION, { upgrade(db) {
+			if (!db.objectStoreNames.contains(DB_LABEL)) db.createObjectStore(DB_LABEL, { keyPath: "id" }).createIndex("byTime", "params.createdAt");
+		} });
+	} catch (error) {
+		throw new Error(`Cannot open a database for the user ${userID}`, { cause: error });
+	}
+};
+/**
+* Closes the IndexedDB database
+*
+* @param esDB - The database
+*/
+const closeDatabase = (esDB) => {
+	return esDB.close();
+};
+/**
+* Deletes IndexedDB database for the given user
+*
+* @param userID - The user ID
+* @returns The database
+*/
+const deleteDatabase = async (userID) => {
+	return deleteDB(getDatabaseName(userID));
+};
+/**
+* Derives database encryption key for the given user
+*
+* @param userID - The user ID
+* @returns The symmetric key for protecting database
+*/
+const deriveIndexKey = async (baseKey) => {
+	return deriveSymmetricKeyFromContext(CONTEXT_INDEX, baseKey);
+};
+/**
+* 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
+*/
+const encryptAndStoreEmail = async (newEmailToStore, indexKey, esDB) => {
+	try {
+		const encryptedEmail = {
+			encEmailBody: await encryptEmailBodyWithKey(newEmailToStore.body, indexKey),
+			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 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
+*/
+const encryptAndStoreManyEmail = async (newEmailsToStore, indexKey, esDB) => {
+	try {
+		const encryptedEmails = await Promise.all(newEmailsToStore.map(async (email) => {
+			return {
+				encEmailBody: await encryptEmailBodyWithKey(email.body, indexKey),
+				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 });
+	}
+};
+/**
+* Decrypts the given email
+*
+* @param indexKey - The symmetric key key for protecting database
+* @param encryptedEmail - The encrypted email
+* @returns The decrypted email
+*/
+const decryptEmail = async (indexKey, encryptedEmail) => {
+	try {
+		return {
+			body: await decryptEmailBody(encryptedEmail.encEmailBody, indexKey),
+			params: encryptedEmail.params,
+			id: encryptedEmail.id
+		};
+	} catch (error) {
+		throw new Error("Cannot decrypt the given email", { cause: error });
+	}
+};
+/**
+* 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
+*/
+const 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 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
+*/
+const getAndDecryptAllEmails = async (indexKey, esDB) => {
+	try {
+		const encryptedEmails = await esDB.getAll(DB_LABEL);
+		return (await Promise.all(encryptedEmails.map(async (encEmail) => {
+			return {
+				body: await decryptEmailBody(encEmail.encEmailBody, indexKey),
+				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 });
+	}
+};
+/**
+* Deletes the email from the database
+*
+* @param emailID - The email identifier
+* @param esDB - The database
+*/
+const deleteEmail = async (emailID, esDB) => {
+	await esDB.delete(DB_LABEL, emailID);
+};
+/**
+* Returns the number of stored email
+*
+* @param esDB - The database
+* @returns The number of stored emails
+*/
+const getEmailCount = async (esDB) => {
+	return await esDB.count(DB_LABEL);
+};
+/**
+* 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(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 });
+	}
+};
+/**
+* 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 });
+	}
+};
+/**
+* Fetches all emails from the database, decrypts them and sortes the results in the specified order
+*
+* @param esDB - The database
+* @param indexKey - The symmetric key 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(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 });
+	}
+};
+/**
+* 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
+*/
+const 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 (oldest first)
+*
+* @param esDB - The database
+* @param indexKey - The symmetric key for protecting database
+* @returns The number of stored emails
+*/
+const getAllEmailsSortedOldestFirst = async (esDB, indexKey) => {
+	return fetchEmails(esDB, indexKey, "next");
+};
+/**
+* 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
+*/
+const getEmailBatch = async (esDB, indexKey, batchSize, startCursor) => {
+	try {
+		const index = esDB.transaction(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 });
+	}
+};
+
+//#endregion
+//#region src/email-search/utils.ts
+/**
+* Converts an Email type into a Uint8Array array.
+*
+* @param email - The email.
+* @returns The Uint8Array array representation of the Email type.
+*/
+function emailToBinary(email) {
+	try {
+		return UTF8ToUint8(JSON.stringify(email));
+	} catch (error) {
+		throw new Error("Failed to convert EmailBody to Uint8Array", { cause: error });
+	}
+}
+
+//#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;
+}
+/**
+* Creates an empty cache variable
+*
+* @returns The empty cache
+*/
+function createEmptyCache() {
+	return {
+		esCache: /* @__PURE__ */ new Map(),
+		cacheSize: 0,
+		isCacheLimited: false,
+		isCacheReady: true
+	};
+}
+/**
+* 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
+*/
+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 <= 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, 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 });
+	}
+};
+/**
+* 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;
+};
+/**
+* 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 });
+	}
+}
+/**
+* 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 > 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 });
+	}
+};
+
+//#endregion
+//#region src/email-search/search.ts
+const SUBJECT_OPTIONS = {
+	preset: "match",
+	tokenize: "forward",
+	resolution: 9,
+	minlength: 2,
+	optimize: true,
+	fastupdate: true,
+	cache: true
+};
+const BODY_OPTIONS = {
+	...SUBJECT_OPTIONS,
+	minlength: 3,
+	resolution: 6
+};
+const FROM_OPTIONS = {
+	...SUBJECT_OPTIONS,
+	tokenize: "strict",
+	minlength: 1
+};
+const TO_OPTIONS = {
+	...SUBJECT_OPTIONS,
+	tokenize: "strict",
+	minlength: 1
+};
+/**
+* Creates new email search index
+*
+* @returns The email search index
+*/
+const createSearchIndex = () => ({
+	subjectIndex: new Index(SUBJECT_OPTIONS),
+	bodyIndex: new Index(BODY_OPTIONS),
+	fromIndex: new Index(FROM_OPTIONS),
+	toIndex: new Index(TO_OPTIONS),
+	isReady: false
+});
+/**
+* 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;
+		searchIndex.subjectIndex.add(emailId, email.body.subject);
+		searchIndex.bodyIndex.add(emailId, email.body.text);
+		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 });
+	}
+};
+/**
+* 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 });
+	}
+};
+/**
+* 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 });
+	}
+};
+/**
+* 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
+export { getEmailCount as C, getEmailBatch as S, enforceMaxEmailNumber as _, addEmailToCache as a, getAndDecryptAllEmails as b, deleteEmailFromCache as c, deleteDatabase as d, deleteEmail as f, encryptAndStoreManyEmail as g, encryptAndStoreEmail as h, searchEmails as i, getEmailFromCache as l, deriveIndexKey as m, buildSearchIndexFromCache as n, addEmailsToCache as o, deleteOldestEmails as p, removeEmailFromSearchIndex as r, createCacheFromDB as s, addEmailToSearchIndex as t, closeDatabase as u, getAllEmailsSortedNewestFirst as v, openDatabase as w, getAndDecryptEmail as x, getAllEmailsSortedOldestFirst as y };
+//# sourceMappingURL=search-B9YM3XAA.mjs.map