internxt-crypto 1.2.0 → 1.3.1

package/dist/emailEncryptionKey-Cw-vW_Oq.js

@@ -1,248 +0,0 @@
-const require_constants = require('./constants.js');
-const require_genID = require('./genID-cWOPmspk.js');
-const require_deriveKeysFromMnemonic = require('./deriveKeysFromMnemonic-Dbx7VSBQ.js');
-const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-iMHv-tIA.js');
-const require_aes = require('./aes-CuW_SPl-.js');
-const require_xwing = require('./xwing-iRWVRtNE.js');
-const require_types = require('./types.js');
-
-//#region src/keystore-crypto/core.ts
-/**
-* Encrypts the user's hybrid key using symmetric encryption to get a keystore
-*
-* @param secretKey - The symmetric key to encrypt the keystore content
-* @param key - The hybrid key pair
-* @param userEmail - The email of the user
-* @param type - The keystore type
-* @returns The encrypted keystore
-*/
-async function encryptKeystoreContent(secretKey, keys, userEmail, type) {
-	try {
-		const aux = require_genID.UTF8ToUint8(userEmail + type);
-		return {
-			userEmail,
-			type,
-			publicKey: require_genID.uint8ArrayToBase64(keys.publicKey),
-			privateKeyEncrypted: require_genID.uint8ArrayToBase64(await require_aes.encryptSymmetrically(secretKey, keys.secretKey, aux))
-		};
-	} catch (error) {
-		throw new Error("Failed to encrypt keystore content", { cause: error });
-	}
-}
-/**
-* Decrypts the keystore content using symmetric encryption
-*
-* @param kesytoreOpeningKey - The symmetric key to decrypt the keystore content
-* @param encryptedKeys - The encrypted keystore content
-* @returns The decrypted hybrid key pair contained in the keystore
-*/
-async function decryptKeystoreContent(kesytoreOpeningKey, encryptedKeystore) {
-	try {
-		const aux = require_genID.UTF8ToUint8(encryptedKeystore.userEmail + encryptedKeystore.type);
-		return {
-			publicKey: require_genID.base64ToUint8Array(encryptedKeystore.publicKey),
-			secretKey: await require_aes.decryptSymmetrically(kesytoreOpeningKey, require_genID.base64ToUint8Array(encryptedKeystore.privateKeyEncrypted), aux)
-		};
-	} catch (error) {
-		throw new Error("Failed to decrypt keystore content", { cause: error });
-	}
-}
-/**
-* Derives a secret key for protecting the recovery keystore
-*
-* @param recoveryCodes - The recovery codes (machine-generated with secure PRNG)
-* @returns The derived secret key for protecting the recovery keystore
-*/
-async function deriveRecoveryKey(recoveryCodes) {
-	return require_deriveKeysFromMnemonic.deriveKeyFromMnemonic(recoveryCodes, require_constants.CONTEXT_RECOVERY);
-}
-/**
-* Derives a secret key for protecting the encryption keystore
-*
-* @param password - The user's password
-* @param salt - The keystore salt
-* @returns The derived secret key for protecting the encryption keystore
-*/
-async function deriveEncryptionKeystoreKey(password, salt) {
-	return require_deriveKeysFromMnemonic.deriveSymmetricKeyFromContext(require_constants.CONTEXT_ENC_KEYSTORE, await require_deriveKeysFromPassword.getKeyFromPasswordAndSalt(password, salt));
-}
-/**
-* Derives a secret key for protecting the encryption keystore
-*
-* @param password - The user's password
-* @param salt - The keystore salt
-* @returns The derived secret key for protecting the encryption keystore
-*/
-async function deriveNewEncryptionKeystoreKey(password) {
-	const { key, salt } = await require_deriveKeysFromPassword.getKeyFromPassword(password);
-	return {
-		secretKey: require_deriveKeysFromMnemonic.deriveSymmetricKeyFromContext(require_constants.CONTEXT_ENC_KEYSTORE, key),
-		salt
-	};
-}
-
-//#endregion
-//#region src/keystore-crypto/errors.ts
-var FailedToCreateKeyStores = class FailedToCreateKeyStores extends Error {
-	constructor(errorMsg) {
-		super("Failed to create encryption and recovery keystores: " + errorMsg);
-		Object.setPrototypeOf(this, FailedToCreateKeyStores.prototype);
-	}
-};
-var FailedToOpenEncryptionKeyStore = class FailedToOpenEncryptionKeyStore extends Error {
-	constructor(errorMsg) {
-		super("Failed to open encryption keystore: " + errorMsg);
-		Object.setPrototypeOf(this, FailedToOpenEncryptionKeyStore.prototype);
-	}
-};
-var FailedToOpenRecoveryKeyStore = class FailedToOpenRecoveryKeyStore extends Error {
-	constructor(errorMsg) {
-		super("Failed to open recovery keystore: " + errorMsg);
-		Object.setPrototypeOf(this, FailedToOpenRecoveryKeyStore.prototype);
-	}
-};
-var FailedToChangePasswordForKeyStore = class FailedToChangePasswordForKeyStore extends Error {
-	constructor(errorMsg) {
-		super("Error while fetching message: " + errorMsg);
-		Object.setPrototypeOf(this, FailedToChangePasswordForKeyStore.prototype);
-	}
-};
-
-//#endregion
-//#region src/keystore-crypto/emailEncryptionKey.ts
-/**
-* Generates hybrid keys and creates encrypted main and recovery keystores
-* The main keystore encryption key is derived from the user's password
-* The recovery keystore encryption key is derived from the recovery codes
-*
-* @param userEmail - The user's email
-* @param password - The user's password
-* @returns The encryption keys
-*
-* @returns The encryption and recovery keystores, recovery codes and hybrid keys
-*/
-async function createEncryptionAndRecoveryKeystores(userEmail, password) {
-	try {
-		const keys = require_xwing.genHybridKeys();
-		const { secretKey, salt } = await deriveNewEncryptionKeystoreKey(password);
-		const encryptionKeystore = await encryptKeystoreContent(secretKey, keys, userEmail, require_types.KeystoreType.ENCRYPTION);
-		const recoveryCodes = require_genID.genMnemonic();
-		return {
-			encryptionKeystore,
-			recoveryKeystore: await encryptKeystoreContent(await deriveRecoveryKey(recoveryCodes), keys, userEmail, require_types.KeystoreType.RECOVERY),
-			recoveryCodes,
-			keys,
-			salt
-		};
-	} catch (error) {
-		throw new FailedToCreateKeyStores(error instanceof Error ? error.message : String(error));
-	}
-}
-/**
-* Opens the encryption keystore and returns the email encryption keys
-* The decryption key is derived from the user password
-*
-* @param encryptedKeystore - The encrypted keystore containing encryption keys
-* @param password - The user's password
-* @param salt - The keystore's salt
-* @returns The encryption keys
-*/
-async function openEncryptionKeystore(encryptedKeystore, password, salt) {
-	try {
-		if (encryptedKeystore.type !== require_types.KeystoreType.ENCRYPTION) throw new Error("Input is invalid");
-		return await decryptKeystoreContent(await deriveEncryptionKeystoreKey(password, salt), encryptedKeystore);
-	} catch (error) {
-		throw new FailedToOpenEncryptionKeyStore(error instanceof Error ? error.message : String(error));
-	}
-}
-/**
-* Opens the recovery keystore and returns the email encryption keys
-* The decryption key is derived from the recovery codes (machine-generated mnemonic)
-*
-* @param recoveryCodes - The user's recovery codes
-* @param encryptedKeystore - The encrypted keystore containing encryption keys
-* @returns The encryption keys
-*/
-async function openRecoveryKeystore(recoveryCodes, encryptedKeystore) {
-	try {
-		if (encryptedKeystore.type !== require_types.KeystoreType.RECOVERY) throw new Error("Input is invalid");
-		return await decryptKeystoreContent(await deriveRecoveryKey(recoveryCodes), encryptedKeystore);
-	} catch (error) {
-		throw new FailedToOpenRecoveryKeyStore(error instanceof Error ? error.message : String(error));
-	}
-}
-/**
-* Re-encrypts the encryption keystore with a new password
-* The decryption key is derived from the user password
-*
-* @param encryptedKeystore - The encrypted keystore containing encryption keys
-* @param oldPassword - The user's old password
-* @param newPassword - The user's new password
-* @param oldSalt - The keystore's old salt
-* @returns The keys, re-encrypted keystore, and new salt
-*/
-async function changePasswordForEncryptionKeystore(encryptedKeystore, oldPassword, newPassword, oldSalt) {
-	try {
-		if (encryptedKeystore.type !== require_types.KeystoreType.ENCRYPTION) throw new Error("Input is invalid");
-		const keys = await openEncryptionKeystore(encryptedKeystore, oldPassword, oldSalt);
-		const { secretKey, salt } = await deriveNewEncryptionKeystoreKey(newPassword);
-		return {
-			newKeystore: await encryptKeystoreContent(secretKey, keys, encryptedKeystore.userEmail, require_types.KeystoreType.ENCRYPTION),
-			newSalt: salt,
-			keys
-		};
-	} catch (error) {
-		throw new FailedToChangePasswordForKeyStore(error instanceof Error ? error.message : String(error));
-	}
-}
-
-//#endregion
-Object.defineProperty(exports, 'FailedToChangePasswordForKeyStore', {
-  enumerable: true,
-  get: function () {
-    return FailedToChangePasswordForKeyStore;
-  }
-});
-Object.defineProperty(exports, 'FailedToCreateKeyStores', {
-  enumerable: true,
-  get: function () {
-    return FailedToCreateKeyStores;
-  }
-});
-Object.defineProperty(exports, 'FailedToOpenEncryptionKeyStore', {
-  enumerable: true,
-  get: function () {
-    return FailedToOpenEncryptionKeyStore;
-  }
-});
-Object.defineProperty(exports, 'FailedToOpenRecoveryKeyStore', {
-  enumerable: true,
-  get: function () {
-    return FailedToOpenRecoveryKeyStore;
-  }
-});
-Object.defineProperty(exports, 'changePasswordForEncryptionKeystore', {
-  enumerable: true,
-  get: function () {
-    return changePasswordForEncryptionKeystore;
-  }
-});
-Object.defineProperty(exports, 'createEncryptionAndRecoveryKeystores', {
-  enumerable: true,
-  get: function () {
-    return createEncryptionAndRecoveryKeystores;
-  }
-});
-Object.defineProperty(exports, 'openEncryptionKeystore', {
-  enumerable: true,
-  get: function () {
-    return openEncryptionKeystore;
-  }
-});
-Object.defineProperty(exports, 'openRecoveryKeystore', {
-  enumerable: true,
-  get: function () {
-    return openRecoveryKeystore;
-  }
-});
-//# sourceMappingURL=emailEncryptionKey-Cw-vW_Oq.js.map

package/dist/emailEncryptionKey-Cw-vW_Oq.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"emailEncryptionKey-Cw-vW_Oq.js","names":["UTF8ToUint8","uint8ArrayToBase64","encryptSymmetrically","base64ToUint8Array","decryptSymmetrically","deriveKeyFromMnemonic","CONTEXT_RECOVERY","deriveSymmetricKeyFromContext","CONTEXT_ENC_KEYSTORE","getKeyFromPasswordAndSalt","getKeyFromPassword","genHybridKeys","KeystoreType","genMnemonic"],"sources":["../src/keystore-crypto/core.ts","../src/keystore-crypto/errors.ts","../src/keystore-crypto/emailEncryptionKey.ts"],"sourcesContent":["import { encryptSymmetrically, decryptSymmetrically } from '../symmetric-crypto';\nimport { base64ToUint8Array, uint8ArrayToBase64, UTF8ToUint8 } from '../utils';\nimport { deriveKeyFromMnemonic, deriveSymmetricKeyFromContext } from '../derive-key';\nimport { CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY } from '../constants';\nimport { EncryptedKeystore, HybridKeyPair, KeystoreType } from '../types';\nimport { getKeyFromPasswordAndSalt, getKeyFromPassword } from '../derive-password';\n\n/**\n * Encrypts the user's hybrid key using symmetric encryption to get a keystore\n *\n * @param secretKey - The symmetric key to encrypt the keystore content\n * @param key - The hybrid key pair\n * @param userEmail - The email of the user\n * @param type - The keystore type\n * @returns The encrypted keystore\n */\nexport async function encryptKeystoreContent(\n  secretKey: Uint8Array,\n  keys: HybridKeyPair,\n  userEmail: string,\n  type: KeystoreType,\n): Promise<EncryptedKeystore> {\n  try {\n    const aux = UTF8ToUint8(userEmail + type);\n    const publicKey = uint8ArrayToBase64(keys.publicKey);\n    const secretKeyEncrypted = await encryptSymmetrically(secretKey, keys.secretKey, aux);\n\n    const keystore: EncryptedKeystore = {\n      userEmail,\n      type,\n      publicKey,\n      privateKeyEncrypted: uint8ArrayToBase64(secretKeyEncrypted),\n    };\n    return keystore;\n  } catch (error) {\n    throw new Error('Failed to encrypt keystore content', { cause: error });\n  }\n}\n\n/**\n * Decrypts the keystore content using symmetric encryption\n *\n * @param kesytoreOpeningKey - The symmetric key to decrypt the keystore content\n * @param encryptedKeys - The encrypted keystore content\n * @returns The decrypted hybrid key pair contained in the keystore\n */\nexport async function decryptKeystoreContent(\n  kesytoreOpeningKey: Uint8Array,\n  encryptedKeystore: EncryptedKeystore,\n): Promise<HybridKeyPair> {\n  try {\n    const aux = UTF8ToUint8(encryptedKeystore.userEmail + encryptedKeystore.type);\n    const publicKey = base64ToUint8Array(encryptedKeystore.publicKey);\n    const ciphertext = base64ToUint8Array(encryptedKeystore.privateKeyEncrypted);\n    const secretKey = await decryptSymmetrically(kesytoreOpeningKey, ciphertext, aux);\n    return {\n      publicKey,\n      secretKey,\n    };\n  } catch (error) {\n    throw new Error('Failed to decrypt keystore content', { cause: error });\n  }\n}\n\n/**\n * Derives a secret key for protecting the recovery keystore\n *\n * @param recoveryCodes - The recovery codes (machine-generated with secure PRNG)\n * @returns The derived secret key for protecting the recovery keystore\n */\nexport async function deriveRecoveryKey(recoveryCodes: string): Promise<Uint8Array> {\n  return deriveKeyFromMnemonic(recoveryCodes, CONTEXT_RECOVERY);\n}\n\n/**\n * Derives a secret key for protecting the encryption keystore from user's mnemonic\n *\n * @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)\n * @returns The derived secret key for protecting the encryption keystore\n */\nexport async function deriveEncryptionKeystoreKeyFromMnemonic(mnemonic: string): Promise<Uint8Array> {\n  return deriveKeyFromMnemonic(mnemonic, CONTEXT_ENC_KEYSTORE);\n}\n\n/**\n * Derives a secret key for protecting the encryption keystore\n *\n * @param password - The user's password\n * @param salt - The keystore salt\n * @returns The derived secret key for protecting the encryption keystore\n */\nexport async function deriveEncryptionKeystoreKey(password: string, salt: Uint8Array): Promise<Uint8Array> {\n  const baseKey = await getKeyFromPasswordAndSalt(password, salt);\n  return deriveSymmetricKeyFromContext(CONTEXT_ENC_KEYSTORE, baseKey);\n}\n\n/**\n * Derives a secret key for protecting the encryption keystore\n *\n * @param password - The user's password\n * @param salt - The keystore salt\n * @returns The derived secret key for protecting the encryption keystore\n */\nexport async function deriveNewEncryptionKeystoreKey(\n  password: string,\n): Promise<{ secretKey: Uint8Array; salt: Uint8Array }> {\n  const { key, salt } = await getKeyFromPassword(password);\n  const secretKey = deriveSymmetricKeyFromContext(CONTEXT_ENC_KEYSTORE, key);\n  return { secretKey, salt };\n}\n","export class FailedToCreateKeyStores extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to create encryption and recovery keystores: ' + errorMsg);\n\n    Object.setPrototypeOf(this, FailedToCreateKeyStores.prototype);\n  }\n}\n\nexport class FailedToOpenEncryptionKeyStore extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to open encryption keystore: ' + errorMsg);\n\n    Object.setPrototypeOf(this, FailedToOpenEncryptionKeyStore.prototype);\n  }\n}\n\nexport class FailedToOpenRecoveryKeyStore extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to open recovery keystore: ' + errorMsg);\n\n    Object.setPrototypeOf(this, FailedToOpenRecoveryKeyStore.prototype);\n  }\n}\n\nexport class FailedToChangePasswordForKeyStore extends Error {\n  constructor(errorMsg?: string) {\n    super('Error while fetching message: ' + errorMsg);\n\n    Object.setPrototypeOf(this, FailedToChangePasswordForKeyStore.prototype);\n  }\n}\n","import { EncryptedKeystore, KeystoreType, HybridKeyPair } from '../types';\nimport { genMnemonic } from '../utils';\nimport {\n  encryptKeystoreContent,\n  decryptKeystoreContent,\n  deriveEncryptionKeystoreKey,\n  deriveNewEncryptionKeystoreKey,\n  deriveRecoveryKey,\n} from './core';\nimport { genHybridKeys } from '../hybrid-crypto';\nimport {\n  FailedToOpenEncryptionKeyStore,\n  FailedToCreateKeyStores,\n  FailedToOpenRecoveryKeyStore,\n  FailedToChangePasswordForKeyStore,\n} from './errors';\n\n/**\n * Generates hybrid keys and creates encrypted main and recovery keystores\n * The main keystore encryption key is derived from the user's password\n * The recovery keystore encryption key is derived from the recovery codes\n *\n * @param userEmail - The user's email\n * @param password - The user's password\n * @returns The encryption keys\n *\n * @returns The encryption and recovery keystores, recovery codes and hybrid keys\n */\nexport async function createEncryptionAndRecoveryKeystores(\n  userEmail: string,\n  password: string,\n): Promise<{\n  encryptionKeystore: EncryptedKeystore;\n  recoveryKeystore: EncryptedKeystore;\n  recoveryCodes: string;\n  keys: HybridKeyPair;\n  salt: Uint8Array;\n}> {\n  try {\n    const keys = genHybridKeys();\n\n    const { secretKey, salt } = await deriveNewEncryptionKeystoreKey(password);\n    const encryptionKeystore = await encryptKeystoreContent(secretKey, keys, userEmail, KeystoreType.ENCRYPTION);\n\n    const recoveryCodes = genMnemonic();\n    const recoveryKey = await deriveRecoveryKey(recoveryCodes);\n    const recoveryKeystore = await encryptKeystoreContent(recoveryKey, keys, userEmail, KeystoreType.RECOVERY);\n\n    return { encryptionKeystore, recoveryKeystore, recoveryCodes, keys, salt };\n  } catch (error) {\n    throw new FailedToCreateKeyStores(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Opens the encryption keystore and returns the email encryption keys\n * The decryption key is derived from the user password\n *\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @param password - The user's password\n * @param salt - The keystore's salt\n * @returns The encryption keys\n */\nexport async function openEncryptionKeystore(\n  encryptedKeystore: EncryptedKeystore,\n  password: string,\n  salt: Uint8Array,\n): Promise<HybridKeyPair> {\n  try {\n    if (encryptedKeystore.type !== KeystoreType.ENCRYPTION) {\n      throw new Error('Input is invalid');\n    }\n    const secretKey = await deriveEncryptionKeystoreKey(password, salt);\n    const keys = await decryptKeystoreContent(secretKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    throw new FailedToOpenEncryptionKeyStore(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Opens the recovery keystore and returns the email encryption keys\n * The decryption key is derived from the recovery codes (machine-generated mnemonic)\n *\n * @param recoveryCodes - The user's recovery codes\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @returns The encryption keys\n */\nexport async function openRecoveryKeystore(\n  recoveryCodes: string,\n  encryptedKeystore: EncryptedKeystore,\n): Promise<HybridKeyPair> {\n  try {\n    if (encryptedKeystore.type !== KeystoreType.RECOVERY) {\n      throw new Error('Input is invalid');\n    }\n    const recoveryKey = await deriveRecoveryKey(recoveryCodes);\n    const keys = await decryptKeystoreContent(recoveryKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    throw new FailedToOpenRecoveryKeyStore(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Re-encrypts the encryption keystore with a new password\n * The decryption key is derived from the user password\n *\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @param oldPassword - The user's old password\n * @param newPassword - The user's new password\n * @param oldSalt - The keystore's old salt\n * @returns The keys, re-encrypted keystore, and new salt\n */\nexport async function changePasswordForEncryptionKeystore(\n  encryptedKeystore: EncryptedKeystore,\n  oldPassword: string,\n  newPassword: string,\n  oldSalt: Uint8Array,\n): Promise<{ keys: HybridKeyPair; newSalt: Uint8Array; newKeystore: EncryptedKeystore }> {\n  try {\n    if (encryptedKeystore.type !== KeystoreType.ENCRYPTION) {\n      throw new Error('Input is invalid');\n    }\n    const keys = await openEncryptionKeystore(encryptedKeystore, oldPassword, oldSalt);\n\n    const { secretKey, salt } = await deriveNewEncryptionKeystoreKey(newPassword);\n    const newKeystore = await encryptKeystoreContent(\n      secretKey,\n      keys,\n      encryptedKeystore.userEmail,\n      KeystoreType.ENCRYPTION,\n    );\n\n    return { newKeystore, newSalt: salt, keys };\n  } catch (error) {\n    throw new FailedToChangePasswordForKeyStore(error instanceof Error ? error.message : String(error));\n  }\n}\n"],"mappings":"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"}

package/dist/emailEncryptionKey-D9sk_WKj.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"emailEncryptionKey-D9sk_WKj.mjs","names":[],"sources":["../src/keystore-crypto/core.ts","../src/keystore-crypto/errors.ts","../src/keystore-crypto/emailEncryptionKey.ts"],"sourcesContent":["import { encryptSymmetrically, decryptSymmetrically } from '../symmetric-crypto';\nimport { base64ToUint8Array, uint8ArrayToBase64, UTF8ToUint8 } from '../utils';\nimport { deriveKeyFromMnemonic, deriveSymmetricKeyFromContext } from '../derive-key';\nimport { CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY } from '../constants';\nimport { EncryptedKeystore, HybridKeyPair, KeystoreType } from '../types';\nimport { getKeyFromPasswordAndSalt, getKeyFromPassword } from '../derive-password';\n\n/**\n * Encrypts the user's hybrid key using symmetric encryption to get a keystore\n *\n * @param secretKey - The symmetric key to encrypt the keystore content\n * @param key - The hybrid key pair\n * @param userEmail - The email of the user\n * @param type - The keystore type\n * @returns The encrypted keystore\n */\nexport async function encryptKeystoreContent(\n  secretKey: Uint8Array,\n  keys: HybridKeyPair,\n  userEmail: string,\n  type: KeystoreType,\n): Promise<EncryptedKeystore> {\n  try {\n    const aux = UTF8ToUint8(userEmail + type);\n    const publicKey = uint8ArrayToBase64(keys.publicKey);\n    const secretKeyEncrypted = await encryptSymmetrically(secretKey, keys.secretKey, aux);\n\n    const keystore: EncryptedKeystore = {\n      userEmail,\n      type,\n      publicKey,\n      privateKeyEncrypted: uint8ArrayToBase64(secretKeyEncrypted),\n    };\n    return keystore;\n  } catch (error) {\n    throw new Error('Failed to encrypt keystore content', { cause: error });\n  }\n}\n\n/**\n * Decrypts the keystore content using symmetric encryption\n *\n * @param kesytoreOpeningKey - The symmetric key to decrypt the keystore content\n * @param encryptedKeys - The encrypted keystore content\n * @returns The decrypted hybrid key pair contained in the keystore\n */\nexport async function decryptKeystoreContent(\n  kesytoreOpeningKey: Uint8Array,\n  encryptedKeystore: EncryptedKeystore,\n): Promise<HybridKeyPair> {\n  try {\n    const aux = UTF8ToUint8(encryptedKeystore.userEmail + encryptedKeystore.type);\n    const publicKey = base64ToUint8Array(encryptedKeystore.publicKey);\n    const ciphertext = base64ToUint8Array(encryptedKeystore.privateKeyEncrypted);\n    const secretKey = await decryptSymmetrically(kesytoreOpeningKey, ciphertext, aux);\n    return {\n      publicKey,\n      secretKey,\n    };\n  } catch (error) {\n    throw new Error('Failed to decrypt keystore content', { cause: error });\n  }\n}\n\n/**\n * Derives a secret key for protecting the recovery keystore\n *\n * @param recoveryCodes - The recovery codes (machine-generated with secure PRNG)\n * @returns The derived secret key for protecting the recovery keystore\n */\nexport async function deriveRecoveryKey(recoveryCodes: string): Promise<Uint8Array> {\n  return deriveKeyFromMnemonic(recoveryCodes, CONTEXT_RECOVERY);\n}\n\n/**\n * Derives a secret key for protecting the encryption keystore from user's mnemonic\n *\n * @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)\n * @returns The derived secret key for protecting the encryption keystore\n */\nexport async function deriveEncryptionKeystoreKeyFromMnemonic(mnemonic: string): Promise<Uint8Array> {\n  return deriveKeyFromMnemonic(mnemonic, CONTEXT_ENC_KEYSTORE);\n}\n\n/**\n * Derives a secret key for protecting the encryption keystore\n *\n * @param password - The user's password\n * @param salt - The keystore salt\n * @returns The derived secret key for protecting the encryption keystore\n */\nexport async function deriveEncryptionKeystoreKey(password: string, salt: Uint8Array): Promise<Uint8Array> {\n  const baseKey = await getKeyFromPasswordAndSalt(password, salt);\n  return deriveSymmetricKeyFromContext(CONTEXT_ENC_KEYSTORE, baseKey);\n}\n\n/**\n * Derives a secret key for protecting the encryption keystore\n *\n * @param password - The user's password\n * @param salt - The keystore salt\n * @returns The derived secret key for protecting the encryption keystore\n */\nexport async function deriveNewEncryptionKeystoreKey(\n  password: string,\n): Promise<{ secretKey: Uint8Array; salt: Uint8Array }> {\n  const { key, salt } = await getKeyFromPassword(password);\n  const secretKey = deriveSymmetricKeyFromContext(CONTEXT_ENC_KEYSTORE, key);\n  return { secretKey, salt };\n}\n","export class FailedToCreateKeyStores extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to create encryption and recovery keystores: ' + errorMsg);\n\n    Object.setPrototypeOf(this, FailedToCreateKeyStores.prototype);\n  }\n}\n\nexport class FailedToOpenEncryptionKeyStore extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to open encryption keystore: ' + errorMsg);\n\n    Object.setPrototypeOf(this, FailedToOpenEncryptionKeyStore.prototype);\n  }\n}\n\nexport class FailedToOpenRecoveryKeyStore extends Error {\n  constructor(errorMsg?: string) {\n    super('Failed to open recovery keystore: ' + errorMsg);\n\n    Object.setPrototypeOf(this, FailedToOpenRecoveryKeyStore.prototype);\n  }\n}\n\nexport class FailedToChangePasswordForKeyStore extends Error {\n  constructor(errorMsg?: string) {\n    super('Error while fetching message: ' + errorMsg);\n\n    Object.setPrototypeOf(this, FailedToChangePasswordForKeyStore.prototype);\n  }\n}\n","import { EncryptedKeystore, KeystoreType, HybridKeyPair } from '../types';\nimport { genMnemonic } from '../utils';\nimport {\n  encryptKeystoreContent,\n  decryptKeystoreContent,\n  deriveEncryptionKeystoreKey,\n  deriveNewEncryptionKeystoreKey,\n  deriveRecoveryKey,\n} from './core';\nimport { genHybridKeys } from '../hybrid-crypto';\nimport {\n  FailedToOpenEncryptionKeyStore,\n  FailedToCreateKeyStores,\n  FailedToOpenRecoveryKeyStore,\n  FailedToChangePasswordForKeyStore,\n} from './errors';\n\n/**\n * Generates hybrid keys and creates encrypted main and recovery keystores\n * The main keystore encryption key is derived from the user's password\n * The recovery keystore encryption key is derived from the recovery codes\n *\n * @param userEmail - The user's email\n * @param password - The user's password\n * @returns The encryption keys\n *\n * @returns The encryption and recovery keystores, recovery codes and hybrid keys\n */\nexport async function createEncryptionAndRecoveryKeystores(\n  userEmail: string,\n  password: string,\n): Promise<{\n  encryptionKeystore: EncryptedKeystore;\n  recoveryKeystore: EncryptedKeystore;\n  recoveryCodes: string;\n  keys: HybridKeyPair;\n  salt: Uint8Array;\n}> {\n  try {\n    const keys = genHybridKeys();\n\n    const { secretKey, salt } = await deriveNewEncryptionKeystoreKey(password);\n    const encryptionKeystore = await encryptKeystoreContent(secretKey, keys, userEmail, KeystoreType.ENCRYPTION);\n\n    const recoveryCodes = genMnemonic();\n    const recoveryKey = await deriveRecoveryKey(recoveryCodes);\n    const recoveryKeystore = await encryptKeystoreContent(recoveryKey, keys, userEmail, KeystoreType.RECOVERY);\n\n    return { encryptionKeystore, recoveryKeystore, recoveryCodes, keys, salt };\n  } catch (error) {\n    throw new FailedToCreateKeyStores(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Opens the encryption keystore and returns the email encryption keys\n * The decryption key is derived from the user password\n *\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @param password - The user's password\n * @param salt - The keystore's salt\n * @returns The encryption keys\n */\nexport async function openEncryptionKeystore(\n  encryptedKeystore: EncryptedKeystore,\n  password: string,\n  salt: Uint8Array,\n): Promise<HybridKeyPair> {\n  try {\n    if (encryptedKeystore.type !== KeystoreType.ENCRYPTION) {\n      throw new Error('Input is invalid');\n    }\n    const secretKey = await deriveEncryptionKeystoreKey(password, salt);\n    const keys = await decryptKeystoreContent(secretKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    throw new FailedToOpenEncryptionKeyStore(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Opens the recovery keystore and returns the email encryption keys\n * The decryption key is derived from the recovery codes (machine-generated mnemonic)\n *\n * @param recoveryCodes - The user's recovery codes\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @returns The encryption keys\n */\nexport async function openRecoveryKeystore(\n  recoveryCodes: string,\n  encryptedKeystore: EncryptedKeystore,\n): Promise<HybridKeyPair> {\n  try {\n    if (encryptedKeystore.type !== KeystoreType.RECOVERY) {\n      throw new Error('Input is invalid');\n    }\n    const recoveryKey = await deriveRecoveryKey(recoveryCodes);\n    const keys = await decryptKeystoreContent(recoveryKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    throw new FailedToOpenRecoveryKeyStore(error instanceof Error ? error.message : String(error));\n  }\n}\n\n/**\n * Re-encrypts the encryption keystore with a new password\n * The decryption key is derived from the user password\n *\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @param oldPassword - The user's old password\n * @param newPassword - The user's new password\n * @param oldSalt - The keystore's old salt\n * @returns The keys, re-encrypted keystore, and new salt\n */\nexport async function changePasswordForEncryptionKeystore(\n  encryptedKeystore: EncryptedKeystore,\n  oldPassword: string,\n  newPassword: string,\n  oldSalt: Uint8Array,\n): Promise<{ keys: HybridKeyPair; newSalt: Uint8Array; newKeystore: EncryptedKeystore }> {\n  try {\n    if (encryptedKeystore.type !== KeystoreType.ENCRYPTION) {\n      throw new Error('Input is invalid');\n    }\n    const keys = await openEncryptionKeystore(encryptedKeystore, oldPassword, oldSalt);\n\n    const { secretKey, salt } = await deriveNewEncryptionKeystoreKey(newPassword);\n    const newKeystore = await encryptKeystoreContent(\n      secretKey,\n      keys,\n      encryptedKeystore.userEmail,\n      KeystoreType.ENCRYPTION,\n    );\n\n    return { newKeystore, newSalt: salt, keys };\n  } catch (error) {\n    throw new FailedToChangePasswordForKeyStore(error instanceof Error ? error.message : String(error));\n  }\n}\n"],"mappings":"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"}

package/dist/emailKeys-BFI-paQq.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"emailKeys-BFI-paQq.js","names":["genSymmetricKey","UTF8ToUint8","encryptSymmetrically","uint8ArrayToBase64","uint8ToUTF8","decryptSymmetrically","base64ToUint8Array","encapsulateHybrid","decapsulateHybrid","getKeyFromPassword","getKeyFromPasswordAndSalt","genHybridKeys","deriveKeyFromMnemonic","CONTEXT_DATABASE","CONTEXT_DRAFT"],"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/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"}