internxt-crypto 0.0.14 → 1.0.0

package/dist/emailEncryptionKey-BtSPYd9M.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"emailEncryptionKey-BtSPYd9M.mjs","names":[],"sources":["../src/keystore-crypto/core.ts","../src/keystore-crypto/emailEncryptionKey.ts"],"sourcesContent":["import { encryptSymmetrically, decryptSymmetrically } from '../symmetric-crypto';\nimport { base64ToUint8Array, uint8ArrayToBase64, UTF8ToUint8, mnemonicToBytes } from '../utils';\nimport { deriveSymmetricKeyFromContext } from '../derive-key';\nimport { CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY } from '../constants';\nimport { EncryptedKeystore, HybridKeyPair, KeystoreType } from '../types';\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\n * @returns The derived secret key for protecting the recovery keystore\n */\nexport async function deriveRecoveryKey(recoveryCodes: string): Promise<Uint8Array> {\n  const recoverCodesArray = mnemonicToBytes(recoveryCodes);\n  return deriveSymmetricKeyFromContext(CONTEXT_RECOVERY, recoverCodesArray);\n}\n\n/**\n * Derives a secret key for protecting the encryption keystore\n *\n * @param baseKey - The base secret key from which a new key secret will be derived\n * @returns The derived secret key for protecting the encryption keystore\n */\nexport async function deriveEncryptionKeystoreKey(baseKey: Uint8Array): Promise<Uint8Array> {\n  return deriveSymmetricKeyFromContext(CONTEXT_ENC_KEYSTORE, baseKey);\n}\n","import { EncryptedKeystore, KeystoreType, HybridKeyPair } from '../types';\nimport { genMnemonic } from '../utils';\nimport { encryptKeystoreContent, decryptKeystoreContent, deriveEncryptionKeystoreKey, deriveRecoveryKey } from './core';\nimport { genHybridKeys } from '../hybrid-crypto';\n\n/**\n * Generates hybrid keys and creates encrypted main and recovery keystores\n * The main keystore encryption key is derived from the base key (stored in session storage)\n * The recovery keystore encryption key is derived from the recovery codes\n *\n * @returns The encryption and recovery keystores, recovery codes and hybrid keys\n */\nexport async function createEncryptionAndRecoveryKeystores(\n  userEmail: string,\n  baseKey: Uint8Array,\n): Promise<{\n  encryptionKeystore: EncryptedKeystore;\n  recoveryKeystore: EncryptedKeystore;\n  recoveryCodes: string;\n  keys: HybridKeyPair;\n}> {\n  try {\n    const keys = genHybridKeys();\n\n    const secretKey = await deriveEncryptionKeystoreKey(baseKey);\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 };\n  } catch (error) {\n    throw new Error('Failed to create encryption and recovery keystores', { cause: error });\n  }\n}\n\n/**\n * Opens the encryption keystore and returns the email encryption keys\n * The decryption key is derived from the base key (stored in session storage)\n *\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @param baseKey - The base key from which the decryption key will be derived\n * @returns The encryption keys\n */\nexport async function openEncryptionKeystore(\n  encryptedKeystore: EncryptedKeystore,\n  baseKey: 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(baseKey);\n    const keys = await decryptKeystoreContent(secretKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to open encryption keystore', { cause: error });\n  }\n}\n\n/**\n * Opens the recovery keystore and returns the email encryption keys\n * The decryption key is derived from the base key (stored in session storage)\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 Error('Failed to open recovery keystore', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAeA,eAAsB,uBACpB,WACA,MACA,WACA,MAC4B;AAC5B,KAAI;EACF,MAAM,MAAM,YAAY,YAAY,KAAK;AAUzC,SANoC;GAClC;GACA;GACA,WANgB,mBAAmB,KAAK,UAAU;GAOlD,qBAAqB,mBANI,MAAM,qBAAqB,WAAW,KAAK,WAAW,IAAI,CAMxB;GAC5D;UAEM,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW3E,eAAsB,uBACpB,oBACA,mBACwB;AACxB,KAAI;EACF,MAAM,MAAM,YAAY,kBAAkB,YAAY,kBAAkB,KAAK;AAI7E,SAAO;GACL,WAJgB,mBAAmB,kBAAkB,UAAU;GAK/D,WAHgB,MAAM,qBAAqB,oBAD1B,mBAAmB,kBAAkB,oBAAoB,EACC,IAAI;GAIhF;UACM,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU3E,eAAsB,kBAAkB,eAA4C;AAElF,QAAO,8BAA8B,kBADX,gBAAgB,cAAc,CACiB;;;;;;;;AAS3E,eAAsB,4BAA4B,SAA0C;AAC1F,QAAO,8BAA8B,sBAAsB,QAAQ;;;;;;;;;;;;ACrErE,eAAsB,qCACpB,WACA,SAMC;AACD,KAAI;EACF,MAAM,OAAO,eAAe;EAG5B,MAAM,qBAAqB,MAAM,uBADf,MAAM,4BAA4B,QAAQ,EACO,MAAM,WAAW,aAAa,WAAW;EAE5G,MAAM,gBAAgB,aAAa;AAInC,SAAO;GAAE;GAAoB,kBAFJ,MAAM,uBADX,MAAM,kBAAkB,cAAc,EACS,MAAM,WAAW,aAAa,SAAS;GAE3D;GAAe;GAAM;UAC7D,OAAO;AACd,QAAM,IAAI,MAAM,sDAAsD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY3F,eAAsB,uBACpB,mBACA,SACwB;AACxB,KAAI;AACF,MAAI,kBAAkB,QAAQ,aAAa,WACzC,OAAM,IAAI,MAAM,mBAAmB;AAIrC,SADa,MAAM,uBADD,MAAM,4BAA4B,QAAQ,EACP,kBAAkB;UAEhE,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY3E,eAAsB,qBACpB,eACA,mBACwB;AACxB,KAAI;AACF,MAAI,kBAAkB,QAAQ,aAAa,SACzC,OAAM,IAAI,MAAM,mBAAmB;AAIrC,SADa,MAAM,uBADC,MAAM,kBAAkB,cAAc,EACH,kBAAkB;UAElE,OAAO;AACd,QAAM,IAAI,MAAM,oCAAoC,EAAE,OAAO,OAAO,CAAC"}

package/dist/{emailEncryptionKey-CQNe5W_T.js → emailEncryptionKey-C4X1Bwy4.js}

@@ -1,38 +1,28 @@
 const require_constants = require('./constants.js');
-const require_keys = require('./keys-CinT7kEY.js');
-const require_genID = require('./genID-YJSl3YhL.js');
-const require_mac = require('./mac-BMb1F0dN.js');
-const require_aes = require('./aes-DQo1MyCz.js');
-const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-BYaiSGKL.js');
-const require_emailKeys = require('./emailKeys-C0KhtfNP.js');
+const require_genID = require('./genID-cWOPmspk.js');
+const require_deriveKeysFromKey = require('./deriveKeysFromKey-C4McqO6_.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 keystore content using symmetric encryption
+* Encrypts the user's hybrid key using symmetric encryption to get a keystore
 *
 * @param secretKey - The symmetric key to encrypt the keystore content
-* @param content - The content of the keystore
-* @param userID - The ID of the user
-* @param tag - The keystore type-specific tag string
-* @returns The encrypted 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);
-		const publicKeys = await require_genID.publicKeyToBase64(keys.publicKeys);
-		const kyberPrivateKeyEnc = await require_aes.encryptSymmetrically(secretKey, keys.privateKeys.kyberPrivateKey, aux);
-		const eccPrivateKeyEnc = await require_aes.encryptSymmetrically(secretKey, await require_keys.exportPrivateKey(keys.privateKeys.eccPrivateKey), aux);
 		return {
 			userEmail,
 			type,
-			encryptedKeys: {
-				publicKeys,
-				privateKeys: {
-					kyberPrivateKeyBase64: require_genID.uint8ArrayToBase64(kyberPrivateKeyEnc),
-					eccPrivateKeyBase64: require_genID.uint8ArrayToBase64(eccPrivateKeyEnc)
-				}
-			}
+			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 });
@@ -41,28 +31,16 @@ async function encryptKeystoreContent(secretKey, keys, userEmail, type) {
 /**
 * Decrypts the keystore content using symmetric encryption
 *
-* @param secretKey - The symmetric key to decrypt the keystore content
+* @param kesytoreOpeningKey - The symmetric key to decrypt the keystore content
 * @param encryptedKeys - The encrypted keystore content
-* @param userEmail - The ID of the user
-* @param tag - The keystore type-specific tag string
-* @returns The decrypted keystore content
+* @returns The decrypted hybrid key pair contained in the keystore
 */
-async function decryptKeystoreContent(secretKey, encryptedKeystore) {
+async function decryptKeystoreContent(kesytoreOpeningKey, encryptedKeystore) {
 	try {
 		const aux = require_genID.UTF8ToUint8(encryptedKeystore.userEmail + encryptedKeystore.type);
-		const kyberPublicKey = require_genID.base64ToUint8Array(encryptedKeystore.encryptedKeys.publicKeys.kyberPublicKeyBase64);
-		const eccPublicKey = await require_keys.importPublicKey(require_genID.base64ToUint8Array(encryptedKeystore.encryptedKeys.publicKeys.eccPublicKeyBase64));
-		const kyberPrivateKey = await require_aes.decryptSymmetrically(secretKey, require_genID.base64ToUint8Array(encryptedKeystore.encryptedKeys.privateKeys.kyberPrivateKeyBase64), aux);
-		const eccPrivateKey = await require_keys.importPrivateKey(await require_aes.decryptSymmetrically(secretKey, require_genID.base64ToUint8Array(encryptedKeystore.encryptedKeys.privateKeys.eccPrivateKeyBase64), aux));
 		return {
-			publicKeys: {
-				kyberPublicKey,
-				eccPublicKey
-			},
-			privateKeys: {
-				kyberPrivateKey,
-				eccPrivateKey
-			}
+			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 });
@@ -75,8 +53,7 @@ async function decryptKeystoreContent(secretKey, encryptedKeystore) {
 * @returns The derived secret key for protecting the recovery keystore
 */
 async function deriveRecoveryKey(recoveryCodes) {
-	const recoverCodesArray = require_genID.mnemonicToBytes(recoveryCodes);
-	return require_deriveKeysFromPassword.deriveSymmetricKeyFromContext(require_constants.CONTEXT_RECOVERY, require_mac.getBytesFromData(require_constants.AES_KEY_BIT_LENGTH / 8, recoverCodesArray));
+	return require_deriveKeysFromKey.deriveSymmetricKeyFromContext(require_constants.CONTEXT_RECOVERY, require_genID.mnemonicToBytes(recoveryCodes));
 }
 /**
 * Derives a secret key for protecting the encryption keystore
@@ -85,21 +62,21 @@ async function deriveRecoveryKey(recoveryCodes) {
 * @returns The derived secret key for protecting the encryption keystore
 */
 async function deriveEncryptionKeystoreKey(baseKey) {
-	return require_deriveKeysFromPassword.deriveSymmetricKeyFromContext(require_constants.CONTEXT_ENC_KEYSTORE, baseKey);
+	return require_deriveKeysFromKey.deriveSymmetricKeyFromContext(require_constants.CONTEXT_ENC_KEYSTORE, baseKey);
 }
 
 //#endregion
 //#region src/keystore-crypto/emailEncryptionKey.ts
 /**
-* Generates email keys and creates encrypted main and recovery keystores
+* Generates hybrid keys and creates encrypted main and recovery keystores
 * The main keystore encryption key is derived from the base key (stored in session storage)
 * The recovery keystore encryption key is derived from the recovery codes
 *
-* @returns The encryption and recovery keystores, recovery codes and email keys
+* @returns The encryption and recovery keystores, recovery codes and hybrid keys
 */
 async function createEncryptionAndRecoveryKeystores(userEmail, baseKey) {
 	try {
-		const keys = await require_emailKeys.generateEmailKeys();
+		const keys = require_xwing.genHybridKeys();
 		const encryptionKeystore = await encryptKeystoreContent(await deriveEncryptionKeystoreKey(baseKey), keys, userEmail, require_types.KeystoreType.ENCRYPTION);
 		const recoveryCodes = require_genID.genMnemonic();
 		return {
@@ -164,4 +141,4 @@ Object.defineProperty(exports, 'openRecoveryKeystore', {
     return openRecoveryKeystore;
   }
 });
-//# sourceMappingURL=emailEncryptionKey-CQNe5W_T.js.map
+//# sourceMappingURL=emailEncryptionKey-C4X1Bwy4.js.map

package/dist/emailEncryptionKey-C4X1Bwy4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emailEncryptionKey-C4X1Bwy4.js","names":["UTF8ToUint8","uint8ArrayToBase64","encryptSymmetrically","base64ToUint8Array","decryptSymmetrically","deriveSymmetricKeyFromContext","CONTEXT_RECOVERY","mnemonicToBytes","CONTEXT_ENC_KEYSTORE","genHybridKeys","KeystoreType","genMnemonic"],"sources":["../src/keystore-crypto/core.ts","../src/keystore-crypto/emailEncryptionKey.ts"],"sourcesContent":["import { encryptSymmetrically, decryptSymmetrically } from '../symmetric-crypto';\nimport { base64ToUint8Array, uint8ArrayToBase64, UTF8ToUint8, mnemonicToBytes } from '../utils';\nimport { deriveSymmetricKeyFromContext } from '../derive-key';\nimport { CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY } from '../constants';\nimport { EncryptedKeystore, HybridKeyPair, KeystoreType } from '../types';\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\n * @returns The derived secret key for protecting the recovery keystore\n */\nexport async function deriveRecoveryKey(recoveryCodes: string): Promise<Uint8Array> {\n  const recoverCodesArray = mnemonicToBytes(recoveryCodes);\n  return deriveSymmetricKeyFromContext(CONTEXT_RECOVERY, recoverCodesArray);\n}\n\n/**\n * Derives a secret key for protecting the encryption keystore\n *\n * @param baseKey - The base secret key from which a new key secret will be derived\n * @returns The derived secret key for protecting the encryption keystore\n */\nexport async function deriveEncryptionKeystoreKey(baseKey: Uint8Array): Promise<Uint8Array> {\n  return deriveSymmetricKeyFromContext(CONTEXT_ENC_KEYSTORE, baseKey);\n}\n","import { EncryptedKeystore, KeystoreType, HybridKeyPair } from '../types';\nimport { genMnemonic } from '../utils';\nimport { encryptKeystoreContent, decryptKeystoreContent, deriveEncryptionKeystoreKey, deriveRecoveryKey } from './core';\nimport { genHybridKeys } from '../hybrid-crypto';\n\n/**\n * Generates hybrid keys and creates encrypted main and recovery keystores\n * The main keystore encryption key is derived from the base key (stored in session storage)\n * The recovery keystore encryption key is derived from the recovery codes\n *\n * @returns The encryption and recovery keystores, recovery codes and hybrid keys\n */\nexport async function createEncryptionAndRecoveryKeystores(\n  userEmail: string,\n  baseKey: Uint8Array,\n): Promise<{\n  encryptionKeystore: EncryptedKeystore;\n  recoveryKeystore: EncryptedKeystore;\n  recoveryCodes: string;\n  keys: HybridKeyPair;\n}> {\n  try {\n    const keys = genHybridKeys();\n\n    const secretKey = await deriveEncryptionKeystoreKey(baseKey);\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 };\n  } catch (error) {\n    throw new Error('Failed to create encryption and recovery keystores', { cause: error });\n  }\n}\n\n/**\n * Opens the encryption keystore and returns the email encryption keys\n * The decryption key is derived from the base key (stored in session storage)\n *\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @param baseKey - The base key from which the decryption key will be derived\n * @returns The encryption keys\n */\nexport async function openEncryptionKeystore(\n  encryptedKeystore: EncryptedKeystore,\n  baseKey: 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(baseKey);\n    const keys = await decryptKeystoreContent(secretKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to open encryption keystore', { cause: error });\n  }\n}\n\n/**\n * Opens the recovery keystore and returns the email encryption keys\n * The decryption key is derived from the base key (stored in session storage)\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 Error('Failed to open recovery keystore', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAeA,eAAsB,uBACpB,WACA,MACA,WACA,MAC4B;AAC5B,KAAI;EACF,MAAM,MAAMA,0BAAY,YAAY,KAAK;AAUzC,SANoC;GAClC;GACA;GACA,WANgBC,iCAAmB,KAAK,UAAU;GAOlD,qBAAqBA,iCANI,MAAMC,iCAAqB,WAAW,KAAK,WAAW,IAAI,CAMxB;GAC5D;UAEM,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW3E,eAAsB,uBACpB,oBACA,mBACwB;AACxB,KAAI;EACF,MAAM,MAAMF,0BAAY,kBAAkB,YAAY,kBAAkB,KAAK;AAI7E,SAAO;GACL,WAJgBG,iCAAmB,kBAAkB,UAAU;GAK/D,WAHgB,MAAMC,iCAAqB,oBAD1BD,iCAAmB,kBAAkB,oBAAoB,EACC,IAAI;GAIhF;UACM,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU3E,eAAsB,kBAAkB,eAA4C;AAElF,QAAOE,wDAA8BC,oCADXC,8BAAgB,cAAc,CACiB;;;;;;;;AAS3E,eAAsB,4BAA4B,SAA0C;AAC1F,QAAOF,wDAA8BG,wCAAsB,QAAQ;;;;;;;;;;;;ACrErE,eAAsB,qCACpB,WACA,SAMC;AACD,KAAI;EACF,MAAM,OAAOC,6BAAe;EAG5B,MAAM,qBAAqB,MAAM,uBADf,MAAM,4BAA4B,QAAQ,EACO,MAAM,WAAWC,2BAAa,WAAW;EAE5G,MAAM,gBAAgBC,2BAAa;AAInC,SAAO;GAAE;GAAoB,kBAFJ,MAAM,uBADX,MAAM,kBAAkB,cAAc,EACS,MAAM,WAAWD,2BAAa,SAAS;GAE3D;GAAe;GAAM;UAC7D,OAAO;AACd,QAAM,IAAI,MAAM,sDAAsD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY3F,eAAsB,uBACpB,mBACA,SACwB;AACxB,KAAI;AACF,MAAI,kBAAkB,QAAQA,2BAAa,WACzC,OAAM,IAAI,MAAM,mBAAmB;AAIrC,SADa,MAAM,uBADD,MAAM,4BAA4B,QAAQ,EACP,kBAAkB;UAEhE,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY3E,eAAsB,qBACpB,eACA,mBACwB;AACxB,KAAI;AACF,MAAI,kBAAkB,QAAQA,2BAAa,SACzC,OAAM,IAAI,MAAM,mBAAmB;AAIrC,SADa,MAAM,uBADC,MAAM,kBAAkB,cAAc,EACH,kBAAkB;UAElE,OAAO;AACd,QAAM,IAAI,MAAM,oCAAoC,EAAE,OAAO,OAAO,CAAC"}

package/dist/{genID-3Er5IowC.mjs → genID-D08K7JPr.mjs}

@@ -1,5 +1,4 @@
-import { AES_KEY_BIT_LENGTH } from "./constants.mjs";
-import { a as importPublicKey, n as exportPublicKey } from "./keys-BfcaiAOv.mjs";
+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";
@@ -67,41 +66,6 @@ function base64ToUint8Array(str) {
 	return new Uint8Array(array.buffer);
 }
 
-//#endregion
-//#region src/utils/keyConverters.ts
-/**
-* Converts a base64 string into PublicKeys type.
-*
-* @param base64 - The base64 representation of the public key.
-* @returns The resulting PublicKeys.
-*/
-async function base64ToPublicKey(base64) {
-	try {
-		return {
-			eccPublicKey: await importPublicKey(base64ToUint8Array(base64.eccPublicKeyBase64)),
-			kyberPublicKey: base64ToUint8Array(base64.kyberPublicKeyBase64)
-		};
-	} catch (error) {
-		throw new Error("Failed to convert base64 to PublicKeys", { cause: error });
-	}
-}
-/**
-* Converts a PublicKeys type into PublicKeysBase64.
-*
-* @param key - The PublicKeys key.
-* @returns The resulting PublicKeysBase64.
-*/
-async function publicKeyToBase64(key) {
-	try {
-		return {
-			eccPublicKeyBase64: uint8ArrayToBase64(await exportPublicKey(key.eccPublicKey)),
-			kyberPublicKeyBase64: uint8ArrayToBase64(key.kyberPublicKey)
-		};
-	} catch (error) {
-		throw new Error("Failed to convert key of the type PublicKeys to PublicKeysBase64", { cause: error });
-	}
-}
-
 //#endregion
 //#region src/utils/genMnemonic.ts
 /**
@@ -110,7 +74,7 @@ async function publicKeyToBase64(key) {
 * @returns The generated mnemonic.
 */
 function genMnemonic() {
-	return bip39.generateMnemonic(wordlist, AES_KEY_BIT_LENGTH);
+	return bip39.generateMnemonic(wordlist, AES_KEY_BYTE_LENGTH * 8);
 }
 /**
 * Converts a mnemonic to Uint8Array
@@ -149,5 +113,5 @@ function bytesToUuid(bytes) {
 }
 
 //#endregion
-export { genMnemonic as a, publicKeyToBase64 as c, hexToUint8Array as d, uint8ArrayToBase64 as f, bytesToMnemonic as i, UTF8ToUint8 as l, uint8ToUTF8 as m, generateUuid as n, mnemonicToBytes as o, uint8ArrayToHex as p, uuidToBytes as r, base64ToPublicKey as s, bytesToUuid as t, base64ToUint8Array as u };
-//# sourceMappingURL=genID-3Er5IowC.mjs.map
+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

@@ -0,0 +1 @@
+{"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-YJSl3YhL.js → genID-cWOPmspk.js}

@@ -1,6 +1,5 @@
 const require_chunk = require('./chunk-EbLFQX5m.js');
 const require_constants = require('./constants.js');
-const require_keys = require('./keys-CinT7kEY.js');
 let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
 let _scure_bip39 = require("@scure/bip39");
 _scure_bip39 = require_chunk.__toESM(_scure_bip39);
@@ -69,41 +68,6 @@ function base64ToUint8Array(str) {
 	return new Uint8Array(array.buffer);
 }
 
-//#endregion
-//#region src/utils/keyConverters.ts
-/**
-* Converts a base64 string into PublicKeys type.
-*
-* @param base64 - The base64 representation of the public key.
-* @returns The resulting PublicKeys.
-*/
-async function base64ToPublicKey(base64) {
-	try {
-		return {
-			eccPublicKey: await require_keys.importPublicKey(base64ToUint8Array(base64.eccPublicKeyBase64)),
-			kyberPublicKey: base64ToUint8Array(base64.kyberPublicKeyBase64)
-		};
-	} catch (error) {
-		throw new Error("Failed to convert base64 to PublicKeys", { cause: error });
-	}
-}
-/**
-* Converts a PublicKeys type into PublicKeysBase64.
-*
-* @param key - The PublicKeys key.
-* @returns The resulting PublicKeysBase64.
-*/
-async function publicKeyToBase64(key) {
-	try {
-		return {
-			eccPublicKeyBase64: uint8ArrayToBase64(await require_keys.exportPublicKey(key.eccPublicKey)),
-			kyberPublicKeyBase64: uint8ArrayToBase64(key.kyberPublicKey)
-		};
-	} catch (error) {
-		throw new Error("Failed to convert key of the type PublicKeys to PublicKeysBase64", { cause: error });
-	}
-}
-
 //#endregion
 //#region src/utils/genMnemonic.ts
 /**
@@ -112,7 +76,7 @@ async function publicKeyToBase64(key) {
 * @returns The generated mnemonic.
 */
 function genMnemonic() {
-	return _scure_bip39.generateMnemonic(_scure_bip39_wordlists_english_js.wordlist, require_constants.AES_KEY_BIT_LENGTH);
+	return _scure_bip39.generateMnemonic(_scure_bip39_wordlists_english_js.wordlist, require_constants.AES_KEY_BYTE_LENGTH * 8);
 }
 /**
 * Converts a mnemonic to Uint8Array
@@ -157,12 +121,6 @@ Object.defineProperty(exports, 'UTF8ToUint8', {
     return UTF8ToUint8;
   }
 });
-Object.defineProperty(exports, 'base64ToPublicKey', {
-  enumerable: true,
-  get: function () {
-    return base64ToPublicKey;
-  }
-});
 Object.defineProperty(exports, 'base64ToUint8Array', {
   enumerable: true,
   get: function () {
@@ -205,12 +163,6 @@ Object.defineProperty(exports, 'mnemonicToBytes', {
     return mnemonicToBytes;
   }
 });
-Object.defineProperty(exports, 'publicKeyToBase64', {
-  enumerable: true,
-  get: function () {
-    return publicKeyToBase64;
-  }
-});
 Object.defineProperty(exports, 'uint8ArrayToBase64', {
   enumerable: true,
   get: function () {
@@ -235,4 +187,4 @@ Object.defineProperty(exports, 'uuidToBytes', {
     return uuidToBytes;
   }
 });
-//# sourceMappingURL=genID-YJSl3YhL.js.map
+//# sourceMappingURL=genID-cWOPmspk.js.map

package/dist/genID-cWOPmspk.js.map

@@ -0,0 +1 @@
+{"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/hash.d.mts

@@ -2,61 +2,49 @@
 /**
  * Hashes the given array of data
  *
- * @param data - The data to hash
- * @returns The resulting hash array
+ * @param data - The array of data
+ * @returns The resulting hash
  */
 declare function hashDataArray(data: Uint8Array[]): Uint8Array;
 /**
- * Hashes the given array of data
+ * Hashes the given array of data with the given key
  *
- * @param data - The data to hash
- * @returns The resulting hash hex string
+ * @param hashKey - The key for keyed hashing
+ * @param data - The array of data
+ * @returns The resulting keyed hash
  */
-declare function hashDataArrayHex(data: Uint8Array[]): string;
-declare function hashDataArrayWithKeyHex(hashKey: Uint8Array, data: Uint8Array[]): string;
 declare function hashDataArrayWithKey(hashKey: Uint8Array, data: Uint8Array[]): Uint8Array;
 /**
- * Hashes the given array of data using blake3 algorithm
+ * Hashes the given array of data to the desired byte-length
  *
+ * @param data - The array of data
  * @param bytes - The desired output byte-length
- * @param data - The data to hash
- * @returns The resulting hash value
+ * @returns The resulting hash of the desired byte-length
  */
-declare function getBytesFromDataArray(bytes: number, data: Uint8Array[]): Uint8Array;
+declare function getBytesFromDataArray(data: Uint8Array[], bytes: number): Uint8Array;
 /**
- * Hashes the given array of data using blake3 algorithm
+ * Hashes the given data
  *
- * @param bytes - The desired output byte-length
- * @param data - The data to hash
- * @returns The resulting hash value
+ * @param data - The data
+ * @returns The resulting hash
  */
-declare function getBytesFromDataArrayHex(bytes: number, data: Uint8Array[]): string;
+declare function hashData(data: Uint8Array): Uint8Array;
 /**
- * Hashes the given string using blake3 algorithm
+ * Hashes the given data with the given key
  *
- * @param bytes - The desired output byte-length
- * @param data - The data to hash
- * @returns The resulting hash value
+ * @param hashKey - The key for keyed hashing
+ * @param data - The data
+ * @returns The resulting keyed hash
  */
-declare function getBytesFromData(bytes: number, data: Uint8Array): Uint8Array;
+declare function hashDataWithKey(hashKey: Uint8Array, data: Uint8Array): Uint8Array;
 /**
- * Hashes the given data using blake3 algorithm
+ * Hashes the given data to the desired byte-length
  *
+ * @param data - The data
  * @param bytes - The desired output byte-length
- * @param data - The data to hash
- * @returns The resulting hash value
- */
-declare function getBytesFromDataHex(bytes: number, data: Uint8Array): string;
-//#endregion
-//#region src/hash/mac.d.ts
-/**
- * Computes mac for the given key material and data
- *
- * @param keyMaterial - The key material
- * @param data - The data to hash
- * @returns The resulting hash hex string
+ * @returns The resulting hash of the desired byte-length
  */
-declare function computeMac(keyMaterial: Uint8Array, data: Uint8Array[]): string;
+declare function getBytesFromData(data: Uint8Array, bytes: number): Uint8Array;
 //#endregion
-export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex };
+export { getBytesFromData, getBytesFromDataArray, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey };
 //# sourceMappingURL=hash.d.mts.map

package/dist/hash.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"hash.d.mts","names":[],"sources":["../src/hash/blake3.ts","../src/hash/mac.ts"],"mappings":";;AASA;;;;;iBAAgB,aAAA,CAAc,IAAA,EAAM,UAAA,KAAe,UAAA;;;;AAkBnD;;;iBAAgB,gBAAA,CAAiB,IAAA,EAAM,UAAA;AAAA,iBAIvB,uBAAA,CAAwB,OAAA,EAAS,UAAA,EAAY,IAAA,EAAM,UAAA;AAAA,iBASnD,oBAAA,CAAqB,OAAA,EAAS,UAAA,EAAY,IAAA,EAAM,UAAA,KAAe,UAAA;;;;;;;;iBAmB/D,qBAAA,CAAsB,KAAA,UAAe,IAAA,EAAM,UAAA,KAAe,UAAA;;AAnB1E;;;;;;iBAsCgB,wBAAA,CAAyB,KAAA,UAAe,IAAA,EAAM,UAAA;;;;;;;;iBAgB9C,gBAAA,CAAiB,KAAA,UAAe,IAAA,EAAM,UAAA,GAAa,UAAA;AAnCnE;;;;;;;AAAA,iBA8CgB,mBAAA,CAAoB,KAAA,UAAe,IAAA,EAAM,UAAA;;;;AAhGzD;;;;;;iBCEgB,UAAA,CAAW,WAAA,EAAa,UAAA,EAAY,IAAA,EAAM,UAAA"}
+{"version":3,"file":"hash.d.mts","names":[],"sources":["../src/hash/blake3.ts"],"mappings":";;AAQA;;;;;iBAAgB,aAAA,CAAc,IAAA,EAAM,UAAA,KAAe,UAAA;;;;AAmBnD;;;;iBAAgB,oBAAA,CAAqB,OAAA,EAAS,UAAA,EAAY,IAAA,EAAM,UAAA,KAAe,UAAA;;;;;;;;iBAmB/D,qBAAA,CAAsB,IAAA,EAAM,UAAA,IAAc,KAAA,WAAgB,UAAA;;;AAA1E;;;;iBAkBgB,QAAA,CAAS,IAAA,EAAM,UAAA,GAAa,UAAA;;;;;;AAA5C;;iBAWgB,eAAA,CAAgB,OAAA,EAAS,UAAA,EAAY,IAAA,EAAM,UAAA,GAAa,UAAA;;;;;;;AAAxE;iBAWgB,gBAAA,CAAiB,IAAA,EAAM,UAAA,EAAY,KAAA,WAAgB,UAAA"}

package/dist/hash.d.ts

@@ -2,61 +2,49 @@
 /**
  * Hashes the given array of data
  *
- * @param data - The data to hash
- * @returns The resulting hash array
+ * @param data - The array of data
+ * @returns The resulting hash
  */
 declare function hashDataArray(data: Uint8Array[]): Uint8Array;
 /**
- * Hashes the given array of data
+ * Hashes the given array of data with the given key
  *
- * @param data - The data to hash
- * @returns The resulting hash hex string
+ * @param hashKey - The key for keyed hashing
+ * @param data - The array of data
+ * @returns The resulting keyed hash
  */
-declare function hashDataArrayHex(data: Uint8Array[]): string;
-declare function hashDataArrayWithKeyHex(hashKey: Uint8Array, data: Uint8Array[]): string;
 declare function hashDataArrayWithKey(hashKey: Uint8Array, data: Uint8Array[]): Uint8Array;
 /**
- * Hashes the given array of data using blake3 algorithm
+ * Hashes the given array of data to the desired byte-length
  *
+ * @param data - The array of data
  * @param bytes - The desired output byte-length
- * @param data - The data to hash
- * @returns The resulting hash value
+ * @returns The resulting hash of the desired byte-length
  */
-declare function getBytesFromDataArray(bytes: number, data: Uint8Array[]): Uint8Array;
+declare function getBytesFromDataArray(data: Uint8Array[], bytes: number): Uint8Array;
 /**
- * Hashes the given array of data using blake3 algorithm
+ * Hashes the given data
  *
- * @param bytes - The desired output byte-length
- * @param data - The data to hash
- * @returns The resulting hash value
+ * @param data - The data
+ * @returns The resulting hash
  */
-declare function getBytesFromDataArrayHex(bytes: number, data: Uint8Array[]): string;
+declare function hashData(data: Uint8Array): Uint8Array;
 /**
- * Hashes the given string using blake3 algorithm
+ * Hashes the given data with the given key
  *
- * @param bytes - The desired output byte-length
- * @param data - The data to hash
- * @returns The resulting hash value
+ * @param hashKey - The key for keyed hashing
+ * @param data - The data
+ * @returns The resulting keyed hash
  */
-declare function getBytesFromData(bytes: number, data: Uint8Array): Uint8Array;
+declare function hashDataWithKey(hashKey: Uint8Array, data: Uint8Array): Uint8Array;
 /**
- * Hashes the given data using blake3 algorithm
+ * Hashes the given data to the desired byte-length
  *
+ * @param data - The data
  * @param bytes - The desired output byte-length
- * @param data - The data to hash
- * @returns The resulting hash value
- */
-declare function getBytesFromDataHex(bytes: number, data: Uint8Array): string;
-//#endregion
-//#region src/hash/mac.d.ts
-/**
- * Computes mac for the given key material and data
- *
- * @param keyMaterial - The key material
- * @param data - The data to hash
- * @returns The resulting hash hex string
+ * @returns The resulting hash of the desired byte-length
  */
-declare function computeMac(keyMaterial: Uint8Array, data: Uint8Array[]): string;
+declare function getBytesFromData(data: Uint8Array, bytes: number): Uint8Array;
 //#endregion
-export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex };
+export { getBytesFromData, getBytesFromDataArray, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey };
 //# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","names":[],"sources":["../src/hash/blake3.ts","../src/hash/mac.ts"],"mappings":";;AASA;;;;;iBAAgB,aAAA,CAAc,IAAA,EAAM,UAAA,KAAe,UAAA;;;;AAkBnD;;;iBAAgB,gBAAA,CAAiB,IAAA,EAAM,UAAA;AAAA,iBAIvB,uBAAA,CAAwB,OAAA,EAAS,UAAA,EAAY,IAAA,EAAM,UAAA;AAAA,iBASnD,oBAAA,CAAqB,OAAA,EAAS,UAAA,EAAY,IAAA,EAAM,UAAA,KAAe,UAAA;;;;;;;;iBAmB/D,qBAAA,CAAsB,KAAA,UAAe,IAAA,EAAM,UAAA,KAAe,UAAA;;AAnB1E;;;;;;iBAsCgB,wBAAA,CAAyB,KAAA,UAAe,IAAA,EAAM,UAAA;;;;;;;;iBAgB9C,gBAAA,CAAiB,KAAA,UAAe,IAAA,EAAM,UAAA,GAAa,UAAA;AAnCnE;;;;;;;AAAA,iBA8CgB,mBAAA,CAAoB,KAAA,UAAe,IAAA,EAAM,UAAA;;;;AAhGzD;;;;;;iBCEgB,UAAA,CAAW,WAAA,EAAa,UAAA,EAAY,IAAA,EAAM,UAAA"}
+{"version":3,"file":"hash.d.ts","names":[],"sources":["../src/hash/blake3.ts"],"mappings":";;AAQA;;;;;iBAAgB,aAAA,CAAc,IAAA,EAAM,UAAA,KAAe,UAAA;;;;AAmBnD;;;;iBAAgB,oBAAA,CAAqB,OAAA,EAAS,UAAA,EAAY,IAAA,EAAM,UAAA,KAAe,UAAA;;;;;;;;iBAmB/D,qBAAA,CAAsB,IAAA,EAAM,UAAA,IAAc,KAAA,WAAgB,UAAA;;;AAA1E;;;;iBAkBgB,QAAA,CAAS,IAAA,EAAM,UAAA,GAAa,UAAA;;;;;;AAA5C;;iBAWgB,eAAA,CAAgB,OAAA,EAAS,UAAA,EAAY,IAAA,EAAM,UAAA,GAAa,UAAA;;;;;;;AAAxE;iBAWgB,gBAAA,CAAiB,IAAA,EAAM,UAAA,EAAY,KAAA,WAAgB,UAAA"}

package/dist/hash.js

@@ -1,12 +1,90 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_mac = require('./mac-BMb1F0dN.js');
+const require_chunk = require('./chunk-EbLFQX5m.js');
+let _noble_hashes_blake3_js = require("@noble/hashes/blake3.js");
 
-exports.computeMac = require_mac.computeMac;
-exports.getBytesFromData = require_mac.getBytesFromData;
-exports.getBytesFromDataArray = require_mac.getBytesFromDataArray;
-exports.getBytesFromDataArrayHex = require_mac.getBytesFromDataArrayHex;
-exports.getBytesFromDataHex = require_mac.getBytesFromDataHex;
-exports.hashDataArray = require_mac.hashDataArray;
-exports.hashDataArrayHex = require_mac.hashDataArrayHex;
-exports.hashDataArrayWithKey = require_mac.hashDataArrayWithKey;
-exports.hashDataArrayWithKeyHex = require_mac.hashDataArrayWithKeyHex;
+//#region src/hash/blake3.ts
+/**
+* Hashes the given array of data
+*
+* @param data - The array of data
+* @returns The resulting hash
+*/
+function hashDataArray(data) {
+	try {
+		const hasher = _noble_hashes_blake3_js.blake3.create();
+		for (const d of data) hasher.update(d);
+		return hasher.digest();
+	} catch (error) {
+		throw new Error("Failed to compute hash", { cause: error });
+	}
+}
+/**
+* Hashes the given array of data with the given key
+*
+* @param hashKey - The key for keyed hashing
+* @param data - The array of data
+* @returns The resulting keyed hash
+*/
+function hashDataArrayWithKey(hashKey, data) {
+	try {
+		const hasher = _noble_hashes_blake3_js.blake3.create({ key: hashKey });
+		for (const d of data) hasher.update(d);
+		return hasher.digest();
+	} catch (error) {
+		throw new Error("Failed to compute hash", { cause: error });
+	}
+}
+/**
+* Hashes the given array of data to the desired byte-length
+*
+* @param data - The array of data
+* @param bytes - The desired output byte-length
+* @returns The resulting hash of the desired byte-length
+*/
+function getBytesFromDataArray(data, bytes) {
+	try {
+		const hasher = _noble_hashes_blake3_js.blake3.create({ dkLen: bytes });
+		for (const chunk of data) hasher.update(chunk);
+		return hasher.digest();
+	} catch (error) {
+		throw new Error("Failed to get bytes from data", { cause: error });
+	}
+}
+/**
+* Hashes the given data
+*
+* @param data - The data
+* @returns The resulting hash
+*/
+function hashData(data) {
+	return (0, _noble_hashes_blake3_js.blake3)(data);
+}
+/**
+* Hashes the given data with the given key
+*
+* @param hashKey - The key for keyed hashing
+* @param data - The data
+* @returns The resulting keyed hash
+*/
+function hashDataWithKey(hashKey, data) {
+	return (0, _noble_hashes_blake3_js.blake3)(data, { key: hashKey });
+}
+/**
+* Hashes the given data to the desired byte-length
+*
+* @param data - The data
+* @param bytes - The desired output byte-length
+* @returns The resulting hash of the desired byte-length
+*/
+function getBytesFromData(data, bytes) {
+	return (0, _noble_hashes_blake3_js.blake3)(data, { dkLen: bytes });
+}
+
+//#endregion
+exports.getBytesFromData = getBytesFromData;
+exports.getBytesFromDataArray = getBytesFromDataArray;
+exports.hashData = hashData;
+exports.hashDataArray = hashDataArray;
+exports.hashDataArrayWithKey = hashDataArrayWithKey;
+exports.hashDataWithKey = hashDataWithKey;
+//# sourceMappingURL=hash.js.map

package/dist/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","names":["blake3"],"sources":["../src/hash/blake3.ts"],"sourcesContent":["import { blake3 } from '@noble/hashes/blake3.js';\n\n/**\n * Hashes the given array of data\n *\n * @param data - The array of data\n * @returns The resulting hash\n */\nexport function hashDataArray(data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create();\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data with the given key\n *\n * @param hashKey - The key for keyed hashing\n * @param data - The array of data\n * @returns The resulting keyed hash\n */\nexport function hashDataArrayWithKey(hashKey: Uint8Array, data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create({ key: hashKey });\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data to the desired byte-length\n *\n * @param data - The array of data\n * @param bytes - The desired output byte-length\n * @returns The resulting hash of the desired byte-length\n */\nexport function getBytesFromDataArray(data: Uint8Array[], bytes: number): Uint8Array {\n  try {\n    const hasher = blake3.create({ dkLen: bytes });\n    for (const chunk of data) {\n      hasher.update(chunk);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to get bytes from data', { cause: error });\n  }\n}\n\n/**\n * Hashes the given data\n *\n * @param data - The data\n * @returns The resulting hash\n */\nexport function hashData(data: Uint8Array): Uint8Array {\n  return blake3(data);\n}\n\n/**\n * Hashes the given data with the given key\n *\n * @param hashKey - The key for keyed hashing\n * @param data - The data\n * @returns The resulting keyed hash\n */\nexport function hashDataWithKey(hashKey: Uint8Array, data: Uint8Array): Uint8Array {\n  return blake3(data, { key: hashKey });\n}\n\n/**\n * Hashes the given data to the desired byte-length\n *\n * @param data - The data\n * @param bytes - The desired output byte-length\n * @returns The resulting hash of the desired byte-length\n */\nexport function getBytesFromData(data: Uint8Array, bytes: number): Uint8Array {\n  return blake3(data, { dkLen: bytes });\n}\n"],"mappings":";;;;;;;;;;;AAQA,SAAgB,cAAc,MAAgC;AAC5D,KAAI;EACF,MAAM,SAASA,+BAAO,QAAQ;AAC9B,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW/D,SAAgB,qBAAqB,SAAqB,MAAgC;AACxF,KAAI;EACF,MAAM,SAASA,+BAAO,OAAO,EAAE,KAAK,SAAS,CAAC;AAC9C,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW/D,SAAgB,sBAAsB,MAAoB,OAA2B;AACnF,KAAI;EACF,MAAM,SAASA,+BAAO,OAAO,EAAE,OAAO,OAAO,CAAC;AAC9C,OAAK,MAAM,SAAS,KAClB,QAAO,OAAO,MAAM;AAEtB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgB,SAAS,MAA8B;AACrD,4CAAc,KAAK;;;;;;;;;AAUrB,SAAgB,gBAAgB,SAAqB,MAA8B;AACjF,4CAAc,MAAM,EAAE,KAAK,SAAS,CAAC;;;;;;;;;AAUvC,SAAgB,iBAAiB,MAAkB,OAA2B;AAC5E,4CAAc,MAAM,EAAE,OAAO,OAAO,CAAC"}