internxt-crypto 1.3.0 → 1.4.0

package/dist/emailKeys-BjIeINfC.mjs

@@ -1,304 +0,0 @@
-import { CONTEXT_DATABASE, CONTEXT_DRAFT } from "./constants.mjs";
-import { c as base64ToUint8Array, f as uint8ToUTF8, s as UTF8ToUint8, u as uint8ArrayToBase64 } from "./genID-D08K7JPr.mjs";
-import { t as deriveKeyFromMnemonic } from "./deriveKeysFromMnemonic-DB0UHE-y.mjs";
-import { n as getKeyFromPassword, r as getKeyFromPasswordAndSalt } from "./deriveKeysFromPassword-DFzo2OII.mjs";
-import { n as encryptSymmetrically, r as genSymmetricKey, t as decryptSymmetrically } from "./aes-B8TA-JKq.mjs";
-import { n as encapsulateHybrid, r as genHybridKeys, t as decapsulateHybrid } from "./xwing-CQmQX6hn.mjs";
-import { aeskw } from "@noble/ciphers/aes.js";
-
-//#region src/key-wrapper/aesWrapper.ts
-/**
-* Unwraps the given wrapped key
-*
-* @param encryptedKey - The wrapped key
-* @param wrappingKey - The secret key used for unwrapping
-* @returns The resulting key
-*/
-async function unwrapKey(encryptedKey, wrappingKey) {
-	return aeskw(wrappingKey).decrypt(encryptedKey);
-}
-/**
-* Wraps the given key
-*
-* @param key - The key to be wrapped
-* @param wrappingKey - The secret key used for wrapping
-* @returns The resulting ciphertext
-*/
-async function wrapKey(key, wrappingKey) {
-	return aeskw(wrappingKey).encrypt(key);
-}
-
-//#endregion
-//#region src/email-crypto/core.ts
-/**
-* Symmetrically encrypts email body.
-*
-* @param body - The email body to encrypt.
-* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The resulting encrypted email body and symmetric key used for encryption
-*/
-async function encryptEmailBody(body, aux) {
-	try {
-		if (!body.text || !body.subject) throw new Error("Invalid input");
-		const encryptionKey = genSymmetricKey();
-		return {
-			encEmailBody: await encryptEmailBodyWithKey(body, encryptionKey, aux),
-			encryptionKey
-		};
-	} catch (error) {
-		throw new Error("Failed to symmetrically encrypt email body", { cause: error });
-	}
-}
-/**
-* Symmetrically encrypts email body with the given key.
-*
-* @param body - The email body to encrypt.
-* @param encryptionKey - The symmetric key to encrypt the email.
-* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The resulting encrypted email body and symmetric key used for encryption
-*/
-async function encryptEmailBodyWithKey(body, encryptionKey, aux) {
-	try {
-		const text = UTF8ToUint8(body.text);
-		const subjectEnc = await encryptSymmetrically(encryptionKey, UTF8ToUint8(body.subject), aux);
-		const enc = {
-			encText: uint8ArrayToBase64(await encryptSymmetrically(encryptionKey, text, aux)),
-			encSubject: uint8ArrayToBase64(subjectEnc)
-		};
-		if (body.attachments) {
-			const promises = body.attachments.map((attachment) => {
-				return encryptSymmetrically(encryptionKey, UTF8ToUint8(attachment), aux);
-			});
-			enc.encAttachments = (await Promise.all(promises))?.map(uint8ArrayToBase64);
-		}
-		return enc;
-	} catch (error) {
-		throw new Error("Failed to encrypt email body", { cause: error });
-	}
-}
-/**
-* Decrypts symmetrically encrypted email body.
-*
-* @param encEmailBody - The email body to decrypt.
-* @param encryptionKey - The symmetric key to decrypt the email.
-* @param aux - An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The resulting decrypted email body
-*/
-async function decryptEmailBody(encEmailBody, encryptionKey, aux) {
-	try {
-		const subject = uint8ToUTF8(await decryptSymmetrically(encryptionKey, base64ToUint8Array(encEmailBody.encSubject), aux));
-		const body = {
-			text: uint8ToUTF8(await decryptSymmetrically(encryptionKey, base64ToUint8Array(encEmailBody.encText), aux)),
-			subject
-		};
-		if (encEmailBody.encAttachments) {
-			const promises = (encEmailBody.encAttachments?.map(base64ToUint8Array))?.map((encAtt) => decryptSymmetrically(encryptionKey, encAtt, aux));
-			body.attachments = (await Promise.all(promises))?.map((att) => uint8ToUTF8(att));
-		}
-		return body;
-	} catch (error) {
-		throw new Error("Failed to symmetrically decrypt email body", { cause: error });
-	}
-}
-/**
-* Encrypts the email symmetric key using hybrid encryption.
-*
-* @param emailEncryptionKey - The symmetric key used for email encryption.
-* @param recipient - The recipient with a public hybrid key.
-* @returns The encrypted email symmetric key
-*/
-async function encryptKeysHybrid(emailEncryptionKey, recipient) {
-	try {
-		const { cipherText, sharedSecret } = encapsulateHybrid(recipient.publicHybridKey);
-		return {
-			encryptedKey: uint8ArrayToBase64(await wrapKey(emailEncryptionKey, sharedSecret)),
-			hybridCiphertext: uint8ArrayToBase64(cipherText),
-			encryptedForEmail: recipient.email
-		};
-	} catch (error) {
-		throw new Error("Failed to encrypt email key using hybrid encryption", { cause: error });
-	}
-}
-/**
-* Decrypts the email symmetric key encrypted via hybrid encryption.
-*
-* @param encryptedKey - The encrypted email key.
-* @param recipientPrivateKey - The private key of the recipient.
-* @returns The email encryption key
-*/
-async function decryptKeysHybrid(encryptedKey, recipientPrivateKey) {
-	try {
-		const kyberCiphertext = base64ToUint8Array(encryptedKey.hybridCiphertext);
-		return await unwrapKey(base64ToUint8Array(encryptedKey.encryptedKey), decapsulateHybrid(kyberCiphertext, recipientPrivateKey));
-	} catch (error) {
-		throw new Error("Failed to decrypt email key encrypted via hybrid encryption", { cause: error });
-	}
-}
-/**
-* Password-protects the email symmetric key.
-*
-* @param emailEncryptionKey - The symmetric key used for email encryption.
-* @param password - The secret password for key protection.
-* @returns The password-protected email symmetric key
-*/
-async function passwordProtectKey(emailEncryptionKey, password) {
-	try {
-		const { key, salt } = await getKeyFromPassword(password);
-		const encryptedKey = await wrapKey(emailEncryptionKey, key);
-		const saltStr = uint8ArrayToBase64(salt);
-		return {
-			encryptedKey: uint8ArrayToBase64(encryptedKey),
-			salt: saltStr
-		};
-	} catch (error) {
-		throw new Error("Failed to password-protect email key", { cause: error });
-	}
-}
-/**
-* Removes passoword-protection and exposes the email symmetric key.
-*
-* @param emailEncryptionKey -  The password-protected email key.
-* @param password - The secret password for key protection.
-* @returns The email encryption key
-*/
-async function removePasswordProtection(emailEncryptionKey, password) {
-	try {
-		const salt = base64ToUint8Array(emailEncryptionKey.salt);
-		return await unwrapKey(base64ToUint8Array(emailEncryptionKey.encryptedKey), await getKeyFromPasswordAndSalt(password, salt));
-	} catch (error) {
-		throw new Error("Failed to remove password-protection from email key", { cause: error });
-	}
-}
-
-//#endregion
-//#region src/email-crypto/hybridEncyptedEmail.ts
-/**
-* Encrypts the email body using hybrid encryption.
-*
-* @param body - The email body to encrypt.
-* @param recipientPublicKeys - The public keys of the recipient.
-* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The encrypted email body
-*/
-async function encryptEmailHybrid(body, recipient, aux) {
-	try {
-		const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);
-		return {
-			encEmailBody,
-			encryptedKey: await encryptKeysHybrid(encryptionKey, recipient)
-		};
-	} catch (error) {
-		throw new Error("Failed to encrypt email body with hybrid encryption", { cause: error });
-	}
-}
-/**
-* Encrypts the email body using hybrid encryption for multiple recipients.
-*
-* @param body - The email body to encrypt for multiple recipients.
-* @param recipients - The recipients with corresponding public keys.
-* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The set of encrypted email bodies
-*/
-async function encryptEmailHybridForMultipleRecipients(body, recipients, aux) {
-	try {
-		const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);
-		const encryptedEmails = [];
-		for (const recipient of recipients) {
-			const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);
-			encryptedEmails.push({
-				encEmailBody,
-				encryptedKey
-			});
-		}
-		return encryptedEmails;
-	} catch (error) {
-		throw new Error("Failed to encrypt email to multiple recipients with hybrid encryption", { cause: error });
-	}
-}
-/**
-* Decrypts the email using hybrid encryption.
-*
-* @param encEmailBody - The encrypted email.
-* @param recipientPrivateHybridKeys - The private key of the recipient.
-* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The decrypted email body
-*/
-async function decryptEmailHybrid(encEmailBody, recipientPrivateHybridKeys, aux) {
-	try {
-		const encryptionKey = await decryptKeysHybrid(encEmailBody.encryptedKey, recipientPrivateHybridKeys);
-		return await decryptEmailBody(encEmailBody.encEmailBody, encryptionKey, aux);
-	} catch (error) {
-		throw new Error("Failed to decrypt email with hybrid encryption", { cause: error });
-	}
-}
-
-//#endregion
-//#region src/email-crypto/pwdProtectedEmail.ts
-/**
-* Creates a password-protected email.
-*
-* @param email - The email to password-protect
-* @param password - The secret password shared among recipients
-* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The password-protected email
-*/
-async function createPwdProtectedEmail(emailBody, password, aux) {
-	try {
-		const { encryptionKey, encEmailBody } = await encryptEmailBody(emailBody, aux);
-		return {
-			encEmailBody,
-			encryptedKey: await passwordProtectKey(encryptionKey, password)
-		};
-	} catch (error) {
-		throw new Error("Failed to password-protect email", { cause: error });
-	}
-}
-/**
-* Opens a password-protected email.
-*
-* @param encryptedEmail - The encrypted email
-* @param password - The secret password shared among recipients.
-* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The decrypted email body
-*/
-async function decryptPwdProtectedEmail(encryptedEmail, password, aux) {
-	try {
-		const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);
-		return await decryptEmailBody(encryptedEmail.encEmailBody, encryptionKey, aux);
-	} catch (error) {
-		throw new Error("Failed to decrypt password-protect email", { cause: error });
-	}
-}
-
-//#endregion
-//#region src/email-crypto/emailKeys.ts
-/**
-* Generates public and private keys for email encryption.
-*
-* @returns The user's private and public keys
-*/
-async function generateEmailKeys() {
-	return genHybridKeys();
-}
-/**
-* Derives database encryption key for the given user
-*
-* @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)
-* @returns The symmetric key for protecting database
-*/
-const deriveDatabaseKey = async (mnemonic) => {
-	return deriveKeyFromMnemonic(mnemonic, CONTEXT_DATABASE);
-};
-/**
-* Derives email draft encryption key for the given user
-*
-* @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)
-* @returns The symmetric key for protecting email drafts
-*/
-const deriveEmailDraftKey = async (mnemonic) => {
-	return deriveKeyFromMnemonic(mnemonic, CONTEXT_DRAFT);
-};
-
-//#endregion
-export { wrapKey as _, decryptPwdProtectedEmail as a, encryptEmailHybridForMultipleRecipients as c, encryptEmailBody as d, encryptEmailBodyWithKey as f, unwrapKey as g, removePasswordProtection as h, createPwdProtectedEmail as i, decryptEmailBody as l, passwordProtectKey as m, deriveEmailDraftKey as n, decryptEmailHybrid as o, encryptKeysHybrid as p, generateEmailKeys as r, encryptEmailHybrid as s, deriveDatabaseKey as t, decryptKeysHybrid as u };
-//# sourceMappingURL=emailKeys-BjIeINfC.mjs.map

package/dist/emailKeys-BjIeINfC.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"emailKeys-BjIeINfC.mjs","names":[],"sources":["../src/key-wrapper/aesWrapper.ts","../src/email-crypto/core.ts","../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/emailKeys.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","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';\nimport { deriveKeyFromMnemonic } from '../derive-key';\nimport { CONTEXT_DATABASE, CONTEXT_DRAFT } from '../constants';\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\n/**\n * Derives database encryption key for the given user\n *\n * @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)\n * @returns The symmetric key for protecting database\n */\nexport const deriveDatabaseKey = async (mnemonic: string): Promise<Uint8Array> => {\n  return deriveKeyFromMnemonic(mnemonic, CONTEXT_DATABASE);\n};\n\n/**\n * Derives email draft encryption key for the given user\n *\n * @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)\n * @returns The symmetric key for protecting email drafts\n */\nexport const deriveEmailDraftKey = async (mnemonic: string): Promise<Uint8Array> => {\n  return deriveKeyFromMnemonic(mnemonic, CONTEXT_DRAFT);\n};\n"],"mappings":"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"}

package/dist/genID-D08K7JPr.mjs

@@ -1,117 +0,0 @@
-import { AES_KEY_BYTE_LENGTH } from "./constants.mjs";
-import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
-import * as bip39 from "@scure/bip39";
-import { wordlist } from "@scure/bip39/wordlists/english.js";
-import { parse, stringify, v4 } from "uuid";
-
-//#region src/utils/converters.ts
-/**
-* Converts a Uint8Array into a hexadecimal string.
-*
-* @param array - The Uint8Array to convert.
-* @returns The hexadecimal string representation of the array.
-*/
-function uint8ArrayToHex(array) {
-	return bytesToHex(array);
-}
-/**
-* Converts a UTF-8 string into a Uint8Array.
-*
-* @param str - The UTF-8 string to convert.
-* @returns A Uint8Array created from the UTF-8 string.
-*/
-function UTF8ToUint8(str) {
-	return new TextEncoder().encode(str);
-}
-/**
-* Converts an Uint8Array into a UTF-8 string.
-*
-* @param array - The Uint8Array to convert.
-* @returns The UTF-8 string representation of the array.
-*/
-function uint8ToUTF8(array) {
-	return new TextDecoder().decode(array);
-}
-/**
-* Converts a hexadecimal string into a Uint8Array.
-*
-* @param hex - The hexadecimal string to convert.
-* @returns A Uint8Array created from the hex string.
-*/
-function hexToUint8Array(hex) {
-	return hexToBytes(hex);
-}
-/**
-* Converts a Uint8Array into a base64 string.
-*
-* @param array - The Uint8Array to convert.
-* @returns The base64 string representation of the array.
-*/
-function uint8ArrayToBase64(buffer) {
-	const array = Uint16Array.from(buffer);
-	const binaryString = new TextDecoder("UTF-16").decode(array);
-	return btoa(binaryString);
-}
-/**
-* Converts a base64 string into a Uint8Array.
-*
-* @param str - The base64 string to convert.
-* @returns A Uint8Array created from the base64 string.
-*/
-function base64ToUint8Array(str) {
-	const binaryString = atob(str);
-	const len = binaryString.length;
-	const array = new Uint8Array(len);
-	for (let i = 0; i < len; i++) array[i] = binaryString.codePointAt(i);
-	return new Uint8Array(array.buffer);
-}
-
-//#endregion
-//#region src/utils/genMnemonic.ts
-/**
-* Generates a mnemonic
-*
-* @returns The generated mnemonic.
-*/
-function genMnemonic() {
-	return bip39.generateMnemonic(wordlist, AES_KEY_BYTE_LENGTH * 8);
-}
-/**
-* Converts a mnemonic to Uint8Array
-*
-* @param mnemonic - The mnemonic to convert
-* @returns The mnemonic as Uint8Array
-*/
-function mnemonicToBytes(mnemonic) {
-	return bip39.mnemonicToEntropy(mnemonic, wordlist);
-}
-/**
-* Converts a Uint8Array to a mnemonic
-*
-* @param bytes - The bytes to convert
-* @returns The mnemonic string
-*/
-function bytesToMnemonic(bytes) {
-	return bip39.entropyToMnemonic(bytes, wordlist);
-}
-
-//#endregion
-//#region src/utils/genID.ts
-/**
-* Creates a random identifier.
-*
-* @returns The resulting auxilary string
-*/
-function generateUuid() {
-	return v4();
-}
-function uuidToBytes(uuid) {
-	return parse(uuid);
-}
-function bytesToUuid(bytes) {
-	return stringify(bytes);
-}
-
-//#endregion
-export { genMnemonic as a, base64ToUint8Array as c, uint8ArrayToHex as d, uint8ToUTF8 as f, bytesToMnemonic as i, hexToUint8Array as l, generateUuid as n, mnemonicToBytes as o, uuidToBytes as r, UTF8ToUint8 as s, bytesToUuid as t, uint8ArrayToBase64 as u };
-//# sourceMappingURL=genID-D08K7JPr.mjs.map

package/dist/genID-D08K7JPr.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"genID-D08K7JPr.mjs","names":["uuidv4"],"sources":["../src/utils/converters.ts","../src/utils/genMnemonic.ts","../src/utils/genID.ts"],"sourcesContent":["import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';\n\n/**\n * Converts a Uint8Array into a hexadecimal string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The hexadecimal string representation of the array.\n */\nexport function uint8ArrayToHex(array: Uint8Array): string {\n  return bytesToHex(array);\n}\n\n/**\n * Converts a UTF-8 string into a Uint8Array.\n *\n * @param str - The UTF-8 string to convert.\n * @returns A Uint8Array created from the UTF-8 string.\n */\nexport function UTF8ToUint8(str: string): Uint8Array {\n  return new TextEncoder().encode(str);\n}\n\n/**\n * Converts an Uint8Array into a UTF-8 string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The UTF-8 string representation of the array.\n */\nexport function uint8ToUTF8(array: Uint8Array): string {\n  return new TextDecoder().decode(array);\n}\n\n/**\n * Converts a hexadecimal string into a Uint8Array.\n *\n * @param hex - The hexadecimal string to convert.\n * @returns A Uint8Array created from the hex string.\n */\nexport function hexToUint8Array(hex: string): Uint8Array {\n  return hexToBytes(hex);\n}\n\n/**\n * Converts a Uint8Array into a base64 string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The base64 string representation of the array.\n */\nexport function uint8ArrayToBase64(buffer: Uint8Array): string {\n  const array = Uint16Array.from(buffer);\n  const binaryString = new TextDecoder('UTF-16').decode(array);\n  return btoa(binaryString);\n}\n\n/**\n * Converts a base64 string into a Uint8Array.\n *\n * @param str - The base64 string to convert.\n * @returns A Uint8Array created from the base64 string.\n */\nexport function base64ToUint8Array(str: string): Uint8Array {\n  const binaryString = atob(str);\n  const len = binaryString.length;\n  const array = new Uint8Array(len);\n  for (let i = 0; i < len; i++) {\n    array[i] = binaryString.codePointAt(i)!;\n  }\n  return new Uint8Array(array.buffer);\n}\n","import * as bip39 from '@scure/bip39';\nimport { wordlist } from '@scure/bip39/wordlists/english.js';\nimport { AES_KEY_BYTE_LENGTH } from '../constants';\n/**\n * Generates a mnemonic\n *\n * @returns The generated mnemonic.\n */\nexport function genMnemonic(): string {\n  return bip39.generateMnemonic(wordlist, AES_KEY_BYTE_LENGTH * 8);\n}\n\n/**\n * Converts a mnemonic to Uint8Array\n *\n * @param mnemonic - The mnemonic to convert\n * @returns The mnemonic as Uint8Array\n */\nexport function mnemonicToBytes(mnemonic: string): Uint8Array {\n  return bip39.mnemonicToEntropy(mnemonic, wordlist);\n}\n\n/**\n * Converts a Uint8Array to a mnemonic\n *\n * @param bytes - The bytes to convert\n * @returns The mnemonic string\n */\nexport function bytesToMnemonic(bytes: Uint8Array): string {\n  return bip39.entropyToMnemonic(bytes, wordlist);\n}\n","import { v4 as uuidv4, parse, stringify } from 'uuid';\n/**\n * Creates a random identifier.\n *\n * @returns The resulting auxilary string\n */\nexport function generateUuid(): string {\n  return uuidv4();\n}\n\nexport function uuidToBytes(uuid: string): Uint8Array {\n  return parse(uuid);\n}\n\nexport function bytesToUuid(bytes: Uint8Array): string {\n  return stringify(bytes);\n}\n"],"mappings":";;;;;;;;;;;;;AAQA,SAAgB,gBAAgB,OAA2B;AACzD,QAAO,WAAW,MAAM;;;;;;;;AAS1B,SAAgB,YAAY,KAAyB;AACnD,QAAO,IAAI,aAAa,CAAC,OAAO,IAAI;;;;;;;;AAStC,SAAgB,YAAY,OAA2B;AACrD,QAAO,IAAI,aAAa,CAAC,OAAO,MAAM;;;;;;;;AASxC,SAAgB,gBAAgB,KAAyB;AACvD,QAAO,WAAW,IAAI;;;;;;;;AASxB,SAAgB,mBAAmB,QAA4B;CAC7D,MAAM,QAAQ,YAAY,KAAK,OAAO;CACtC,MAAM,eAAe,IAAI,YAAY,SAAS,CAAC,OAAO,MAAM;AAC5D,QAAO,KAAK,aAAa;;;;;;;;AAS3B,SAAgB,mBAAmB,KAAyB;CAC1D,MAAM,eAAe,KAAK,IAAI;CAC9B,MAAM,MAAM,aAAa;CACzB,MAAM,QAAQ,IAAI,WAAW,IAAI;AACjC,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,IACvB,OAAM,KAAK,aAAa,YAAY,EAAE;AAExC,QAAO,IAAI,WAAW,MAAM,OAAO;;;;;;;;;;AC3DrC,SAAgB,cAAsB;AACpC,QAAO,MAAM,iBAAiB,UAAU,sBAAsB,EAAE;;;;;;;;AASlE,SAAgB,gBAAgB,UAA8B;AAC5D,QAAO,MAAM,kBAAkB,UAAU,SAAS;;;;;;;;AASpD,SAAgB,gBAAgB,OAA2B;AACzD,QAAO,MAAM,kBAAkB,OAAO,SAAS;;;;;;;;;;ACvBjD,SAAgB,eAAuB;AACrC,QAAOA,IAAQ;;AAGjB,SAAgB,YAAY,MAA0B;AACpD,QAAO,MAAM,KAAK;;AAGpB,SAAgB,YAAY,OAA2B;AACrD,QAAO,UAAU,MAAM"}

package/dist/genID-cWOPmspk.js

@@ -1,190 +0,0 @@
-const require_chunk = require('./chunk-EbLFQX5m.js');
-const require_constants = require('./constants.js');
-let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
-let _scure_bip39 = require("@scure/bip39");
-_scure_bip39 = require_chunk.__toESM(_scure_bip39);
-let _scure_bip39_wordlists_english_js = require("@scure/bip39/wordlists/english.js");
-let uuid = require("uuid");
-
-//#region src/utils/converters.ts
-/**
-* Converts a Uint8Array into a hexadecimal string.
-*
-* @param array - The Uint8Array to convert.
-* @returns The hexadecimal string representation of the array.
-*/
-function uint8ArrayToHex(array) {
-	return (0, _noble_hashes_utils_js.bytesToHex)(array);
-}
-/**
-* Converts a UTF-8 string into a Uint8Array.
-*
-* @param str - The UTF-8 string to convert.
-* @returns A Uint8Array created from the UTF-8 string.
-*/
-function UTF8ToUint8(str) {
-	return new TextEncoder().encode(str);
-}
-/**
-* Converts an Uint8Array into a UTF-8 string.
-*
-* @param array - The Uint8Array to convert.
-* @returns The UTF-8 string representation of the array.
-*/
-function uint8ToUTF8(array) {
-	return new TextDecoder().decode(array);
-}
-/**
-* Converts a hexadecimal string into a Uint8Array.
-*
-* @param hex - The hexadecimal string to convert.
-* @returns A Uint8Array created from the hex string.
-*/
-function hexToUint8Array(hex) {
-	return (0, _noble_hashes_utils_js.hexToBytes)(hex);
-}
-/**
-* Converts a Uint8Array into a base64 string.
-*
-* @param array - The Uint8Array to convert.
-* @returns The base64 string representation of the array.
-*/
-function uint8ArrayToBase64(buffer) {
-	const array = Uint16Array.from(buffer);
-	const binaryString = new TextDecoder("UTF-16").decode(array);
-	return btoa(binaryString);
-}
-/**
-* Converts a base64 string into a Uint8Array.
-*
-* @param str - The base64 string to convert.
-* @returns A Uint8Array created from the base64 string.
-*/
-function base64ToUint8Array(str) {
-	const binaryString = atob(str);
-	const len = binaryString.length;
-	const array = new Uint8Array(len);
-	for (let i = 0; i < len; i++) array[i] = binaryString.codePointAt(i);
-	return new Uint8Array(array.buffer);
-}
-
-//#endregion
-//#region src/utils/genMnemonic.ts
-/**
-* Generates a mnemonic
-*
-* @returns The generated mnemonic.
-*/
-function genMnemonic() {
-	return _scure_bip39.generateMnemonic(_scure_bip39_wordlists_english_js.wordlist, require_constants.AES_KEY_BYTE_LENGTH * 8);
-}
-/**
-* Converts a mnemonic to Uint8Array
-*
-* @param mnemonic - The mnemonic to convert
-* @returns The mnemonic as Uint8Array
-*/
-function mnemonicToBytes(mnemonic) {
-	return _scure_bip39.mnemonicToEntropy(mnemonic, _scure_bip39_wordlists_english_js.wordlist);
-}
-/**
-* Converts a Uint8Array to a mnemonic
-*
-* @param bytes - The bytes to convert
-* @returns The mnemonic string
-*/
-function bytesToMnemonic(bytes) {
-	return _scure_bip39.entropyToMnemonic(bytes, _scure_bip39_wordlists_english_js.wordlist);
-}
-
-//#endregion
-//#region src/utils/genID.ts
-/**
-* Creates a random identifier.
-*
-* @returns The resulting auxilary string
-*/
-function generateUuid() {
-	return (0, uuid.v4)();
-}
-function uuidToBytes(uuid$1) {
-	return (0, uuid.parse)(uuid$1);
-}
-function bytesToUuid(bytes) {
-	return (0, uuid.stringify)(bytes);
-}
-
-//#endregion
-Object.defineProperty(exports, 'UTF8ToUint8', {
-  enumerable: true,
-  get: function () {
-    return UTF8ToUint8;
-  }
-});
-Object.defineProperty(exports, 'base64ToUint8Array', {
-  enumerable: true,
-  get: function () {
-    return base64ToUint8Array;
-  }
-});
-Object.defineProperty(exports, 'bytesToMnemonic', {
-  enumerable: true,
-  get: function () {
-    return bytesToMnemonic;
-  }
-});
-Object.defineProperty(exports, 'bytesToUuid', {
-  enumerable: true,
-  get: function () {
-    return bytesToUuid;
-  }
-});
-Object.defineProperty(exports, 'genMnemonic', {
-  enumerable: true,
-  get: function () {
-    return genMnemonic;
-  }
-});
-Object.defineProperty(exports, 'generateUuid', {
-  enumerable: true,
-  get: function () {
-    return generateUuid;
-  }
-});
-Object.defineProperty(exports, 'hexToUint8Array', {
-  enumerable: true,
-  get: function () {
-    return hexToUint8Array;
-  }
-});
-Object.defineProperty(exports, 'mnemonicToBytes', {
-  enumerable: true,
-  get: function () {
-    return mnemonicToBytes;
-  }
-});
-Object.defineProperty(exports, 'uint8ArrayToBase64', {
-  enumerable: true,
-  get: function () {
-    return uint8ArrayToBase64;
-  }
-});
-Object.defineProperty(exports, 'uint8ArrayToHex', {
-  enumerable: true,
-  get: function () {
-    return uint8ArrayToHex;
-  }
-});
-Object.defineProperty(exports, 'uint8ToUTF8', {
-  enumerable: true,
-  get: function () {
-    return uint8ToUTF8;
-  }
-});
-Object.defineProperty(exports, 'uuidToBytes', {
-  enumerable: true,
-  get: function () {
-    return uuidToBytes;
-  }
-});
-//# sourceMappingURL=genID-cWOPmspk.js.map

package/dist/genID-cWOPmspk.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"genID-cWOPmspk.js","names":["bip39","wordlist","AES_KEY_BYTE_LENGTH","uuid"],"sources":["../src/utils/converters.ts","../src/utils/genMnemonic.ts","../src/utils/genID.ts"],"sourcesContent":["import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';\n\n/**\n * Converts a Uint8Array into a hexadecimal string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The hexadecimal string representation of the array.\n */\nexport function uint8ArrayToHex(array: Uint8Array): string {\n  return bytesToHex(array);\n}\n\n/**\n * Converts a UTF-8 string into a Uint8Array.\n *\n * @param str - The UTF-8 string to convert.\n * @returns A Uint8Array created from the UTF-8 string.\n */\nexport function UTF8ToUint8(str: string): Uint8Array {\n  return new TextEncoder().encode(str);\n}\n\n/**\n * Converts an Uint8Array into a UTF-8 string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The UTF-8 string representation of the array.\n */\nexport function uint8ToUTF8(array: Uint8Array): string {\n  return new TextDecoder().decode(array);\n}\n\n/**\n * Converts a hexadecimal string into a Uint8Array.\n *\n * @param hex - The hexadecimal string to convert.\n * @returns A Uint8Array created from the hex string.\n */\nexport function hexToUint8Array(hex: string): Uint8Array {\n  return hexToBytes(hex);\n}\n\n/**\n * Converts a Uint8Array into a base64 string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The base64 string representation of the array.\n */\nexport function uint8ArrayToBase64(buffer: Uint8Array): string {\n  const array = Uint16Array.from(buffer);\n  const binaryString = new TextDecoder('UTF-16').decode(array);\n  return btoa(binaryString);\n}\n\n/**\n * Converts a base64 string into a Uint8Array.\n *\n * @param str - The base64 string to convert.\n * @returns A Uint8Array created from the base64 string.\n */\nexport function base64ToUint8Array(str: string): Uint8Array {\n  const binaryString = atob(str);\n  const len = binaryString.length;\n  const array = new Uint8Array(len);\n  for (let i = 0; i < len; i++) {\n    array[i] = binaryString.codePointAt(i)!;\n  }\n  return new Uint8Array(array.buffer);\n}\n","import * as bip39 from '@scure/bip39';\nimport { wordlist } from '@scure/bip39/wordlists/english.js';\nimport { AES_KEY_BYTE_LENGTH } from '../constants';\n/**\n * Generates a mnemonic\n *\n * @returns The generated mnemonic.\n */\nexport function genMnemonic(): string {\n  return bip39.generateMnemonic(wordlist, AES_KEY_BYTE_LENGTH * 8);\n}\n\n/**\n * Converts a mnemonic to Uint8Array\n *\n * @param mnemonic - The mnemonic to convert\n * @returns The mnemonic as Uint8Array\n */\nexport function mnemonicToBytes(mnemonic: string): Uint8Array {\n  return bip39.mnemonicToEntropy(mnemonic, wordlist);\n}\n\n/**\n * Converts a Uint8Array to a mnemonic\n *\n * @param bytes - The bytes to convert\n * @returns The mnemonic string\n */\nexport function bytesToMnemonic(bytes: Uint8Array): string {\n  return bip39.entropyToMnemonic(bytes, wordlist);\n}\n","import { v4 as uuidv4, parse, stringify } from 'uuid';\n/**\n * Creates a random identifier.\n *\n * @returns The resulting auxilary string\n */\nexport function generateUuid(): string {\n  return uuidv4();\n}\n\nexport function uuidToBytes(uuid: string): Uint8Array {\n  return parse(uuid);\n}\n\nexport function bytesToUuid(bytes: Uint8Array): string {\n  return stringify(bytes);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAQA,SAAgB,gBAAgB,OAA2B;AACzD,+CAAkB,MAAM;;;;;;;;AAS1B,SAAgB,YAAY,KAAyB;AACnD,QAAO,IAAI,aAAa,CAAC,OAAO,IAAI;;;;;;;;AAStC,SAAgB,YAAY,OAA2B;AACrD,QAAO,IAAI,aAAa,CAAC,OAAO,MAAM;;;;;;;;AASxC,SAAgB,gBAAgB,KAAyB;AACvD,+CAAkB,IAAI;;;;;;;;AASxB,SAAgB,mBAAmB,QAA4B;CAC7D,MAAM,QAAQ,YAAY,KAAK,OAAO;CACtC,MAAM,eAAe,IAAI,YAAY,SAAS,CAAC,OAAO,MAAM;AAC5D,QAAO,KAAK,aAAa;;;;;;;;AAS3B,SAAgB,mBAAmB,KAAyB;CAC1D,MAAM,eAAe,KAAK,IAAI;CAC9B,MAAM,MAAM,aAAa;CACzB,MAAM,QAAQ,IAAI,WAAW,IAAI;AACjC,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,IACvB,OAAM,KAAK,aAAa,YAAY,EAAE;AAExC,QAAO,IAAI,WAAW,MAAM,OAAO;;;;;;;;;;AC3DrC,SAAgB,cAAsB;AACpC,QAAOA,aAAM,iBAAiBC,4CAAUC,wCAAsB,EAAE;;;;;;;;AASlE,SAAgB,gBAAgB,UAA8B;AAC5D,QAAOF,aAAM,kBAAkB,UAAUC,2CAAS;;;;;;;;AASpD,SAAgB,gBAAgB,OAA2B;AACzD,QAAOD,aAAM,kBAAkB,OAAOC,2CAAS;;;;;;;;;;ACvBjD,SAAgB,eAAuB;AACrC,sBAAe;;AAGjB,SAAgB,YAAY,QAA0B;AACpD,wBAAaE,OAAK;;AAGpB,SAAgB,YAAY,OAA2B;AACrD,4BAAiB,MAAM"}

package/dist/types.d.mts.map

@@ -1 +0,0 @@
-{"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.map

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