internxt-crypto 1.5.0 → 1.6.1

package/dist/react-native/hash.d.ts

@@ -0,0 +1,50 @@
+//#region src/hash/blake3.d.ts
+/**
+ * Hashes the given array of data
+ *
+ * @param data - The array of data
+ * @returns The resulting hash
+ */
+declare function hashDataArray(data: Uint8Array[]): Uint8Array;
+/**
+ * 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
+ */
+declare function hashDataArrayWithKey(hashKey: Uint8Array, data: Uint8Array[]): Uint8Array;
+/**
+ * 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
+ */
+declare function getBytesFromDataArray(data: Uint8Array[], bytes: number): Uint8Array;
+/**
+ * Hashes the given data
+ *
+ * @param data - The data
+ * @returns The resulting hash
+ */
+declare function hashData(data: Uint8Array): Uint8Array;
+/**
+ * Hashes the given data with the given key
+ *
+ * @param hashKey - The key for keyed hashing
+ * @param data - The data
+ * @returns The resulting keyed hash
+ */
+declare function hashDataWithKey(hashKey: Uint8Array, data: Uint8Array): Uint8Array;
+/**
+ * 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
+ */
+declare function getBytesFromData(data: Uint8Array, bytes: number): Uint8Array;
+//#endregion
+export { getBytesFromData, getBytesFromDataArray, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey };
+//# sourceMappingURL=hash.d.ts.map

package/dist/react-native/hash.d.ts.map

@@ -0,0 +1 @@
+{"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/react-native/hash.js

@@ -0,0 +1,89 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./chunk-DskHE4z1.js");
+let _noble_hashes_blake3_js = require("@noble/hashes/blake3.js");
+//#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/react-native/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,wBAAAA,OAAO,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,wBAAAA,OAAO,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,wBAAAA,OAAO,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,SAAA,GAAA,wBAAA,QAAc,KAAK;;;;;;;;;AAUrB,SAAgB,gBAAgB,SAAqB,MAA8B;AACjF,SAAA,GAAA,wBAAA,QAAc,MAAM,EAAE,KAAK,SAAS,CAAC;;;;;;;;;AAUvC,SAAgB,iBAAiB,MAAkB,OAA2B;AAC5E,SAAA,GAAA,wBAAA,QAAc,MAAM,EAAE,OAAO,OAAO,CAAC"}

package/dist/react-native/hash.mjs

@@ -0,0 +1,82 @@
+import { blake3 } from "@noble/hashes/blake3.js";
+//#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 = 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 = 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 = 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 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 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 blake3(data, { dkLen: bytes });
+}
+//#endregion
+export { getBytesFromData, getBytesFromDataArray, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey };
+
+//# sourceMappingURL=hash.mjs.map

package/dist/react-native/hash.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.mjs","names":[],"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,SAAS,OAAO,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,SAAS,OAAO,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,SAAS,OAAO,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,QAAO,OAAO,KAAK;;;;;;;;;AAUrB,SAAgB,gBAAgB,SAAqB,MAA8B;AACjF,QAAO,OAAO,MAAM,EAAE,KAAK,SAAS,CAAC;;;;;;;;;AAUvC,SAAgB,iBAAiB,MAAkB,OAA2B;AAC5E,QAAO,OAAO,MAAM,EAAE,OAAO,OAAO,CAAC"}

package/dist/react-native/index.d.mts

@@ -0,0 +1,32 @@
+import { deriveSecretKey, generateEccKeys } from "./asymmetric-crypto.mjs";
+import { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DATABASE, CONTEXT_DRAFT, CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY, CONTEXT_TWO_KEYS, DB_LABEL, DB_VERSION, IV_LEN_BYTES, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH } from "./constants.mjs";
+import { deriveKeyFromMnemonic, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys } from "./derive-key.mjs";
+import { generateSalt, getKeyFromPassword, getKeyFromPasswordAndSalt } from "./derive-password.mjs";
+import { a as EncryptedKeystore, c as KeystoreType, d as PwdProtectedKey, f as RecipientWithPublicKey, i as EmailEncrypted, l as PwdProtectedEmail, n as EmailAndSubject, o as HybridEncKey, r as EmailAndSubjectEncrypted, s as HybridKeyPair, t as Email, u as PwdProtectedEmailAndSubject } from "./types-D1R4_m5r.mjs";
+import { EmailHybridDecryptionError, EmailHybridEncryptionError, EmailPasswordOpenError, EmailPasswordProtectError, EmailSymmetricDecryptionError, EmailSymmetricEncryptionError, FailedToDecryptEmail, FailedToEncryptEmail, InvalidInputEmail, createPwdProtectedEmail, createPwdProtectedEmailAndSubject, decryptEmail, decryptEmailAndSubject, decryptEmailAndSubjectHybrid, decryptEmailHybrid, decryptEmailPreviewHybrid, decryptPwdProtectedEmail, decryptPwdProtectedEmailAndSubject, deriveDatabaseKey, deriveEmailDraftKey, encryptEmail, encryptEmailAndSubject, encryptEmailAndSubjectHybridForMultipleRecipients, encryptEmailAndSubjectWithKey, encryptEmailHybridForMultipleRecipients, encryptEmailWithKey, generateEmailKeys } from "./email-crypto.mjs";
+import { getBytesFromData, getBytesFromDataArray, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey } from "./hash.mjs";
+import { FailedToChangeMnemonicForKeyStore, FailedToCreateKeyStores, FailedToOpenEncryptionKeyStore, FailedToOpenRecoveryKeyStore, InvalidInputKeyStore, changeMnemonicForEncryptionKeystore, createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore } from "./keystore-crypto.mjs";
+import { decapsulateKyber, encapsulateKyber, generateKyberKeys } from "./post-quantum-crypto.mjs";
+import { decryptSymmetrically, encryptSymmetrically, genSymmetricKey } from "./symmetric-crypto.mjs";
+import { UTF8ToUint8, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes } from "./utils.mjs";
+
+//#region src/key-wrapper/aesWrapper.d.ts
+/**
+ * Unwraps the given wrapped key
+ *
+ * @param encryptedKey - The wrapped key
+ * @param wrappingKey - The secret key used for unwrapping
+ * @returns The resulting key
+ */
+declare function unwrapKey(encryptedKey: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array>;
+/**
+ * Wraps the given key
+ *
+ * @param key - The key to be wrapped
+ * @param wrappingKey - The secret key used for wrapping
+ * @returns The resulting ciphertext
+ */
+declare function wrapKey(key: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array>;
+//#endregion
+export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DATABASE, CONTEXT_DRAFT, CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY, CONTEXT_TWO_KEYS, DB_LABEL, DB_VERSION, Email, EmailAndSubject, EmailAndSubjectEncrypted, EmailEncrypted, EmailHybridDecryptionError, EmailHybridEncryptionError, EmailPasswordOpenError, EmailPasswordProtectError, EmailSymmetricDecryptionError, EmailSymmetricEncryptionError, EncryptedKeystore, FailedToChangeMnemonicForKeyStore, FailedToCreateKeyStores, FailedToDecryptEmail, FailedToEncryptEmail, FailedToOpenEncryptionKeyStore, FailedToOpenRecoveryKeyStore, HybridEncKey, HybridKeyPair, IV_LEN_BYTES, InvalidInputEmail, InvalidInputKeyStore, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, PwdProtectedEmail, PwdProtectedEmailAndSubject, PwdProtectedKey, RecipientWithPublicKey, UTF8ToUint8, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, base64ToUint8Array, bytesToMnemonic, bytesToUuid, changeMnemonicForEncryptionKeystore, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, createPwdProtectedEmailAndSubject, decapsulateKyber, decryptEmail, decryptEmailAndSubject, decryptEmailAndSubjectHybrid, decryptEmailHybrid, decryptEmailPreviewHybrid, decryptPwdProtectedEmail, decryptPwdProtectedEmailAndSubject, decryptSymmetrically, deriveDatabaseKey, deriveEmailDraftKey, deriveKeyFromMnemonic, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptEmail, encryptEmailAndSubject, encryptEmailAndSubjectHybridForMultipleRecipients, encryptEmailAndSubjectWithKey, encryptEmailHybridForMultipleRecipients, encryptEmailWithKey, encryptSymmetrically, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateSalt, generateUuid, getBytesFromData, getBytesFromDataArray, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openEncryptionKeystore, openRecoveryKeystore, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };
+//# sourceMappingURL=index.d.mts.map

package/dist/react-native/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/key-wrapper/aesWrapper.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBASsB,SAAA,CAAU,YAAA,EAAc,UAAA,EAAY,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,UAAA;;;;;;AAA5F;;iBAWsB,OAAA,CAAQ,GAAA,EAAK,UAAA,EAAY,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,UAAA"}

package/dist/react-native/index.d.ts

@@ -0,0 +1,32 @@
+import { deriveSecretKey, generateEccKeys } from "./asymmetric-crypto.js";
+import { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DATABASE, CONTEXT_DRAFT, CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY, CONTEXT_TWO_KEYS, DB_LABEL, DB_VERSION, IV_LEN_BYTES, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH } from "./constants.js";
+import { deriveKeyFromMnemonic, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys } from "./derive-key.js";
+import { generateSalt, getKeyFromPassword, getKeyFromPasswordAndSalt } from "./derive-password.js";
+import { a as EncryptedKeystore, c as KeystoreType, d as PwdProtectedKey, f as RecipientWithPublicKey, i as EmailEncrypted, l as PwdProtectedEmail, n as EmailAndSubject, o as HybridEncKey, r as EmailAndSubjectEncrypted, s as HybridKeyPair, t as Email, u as PwdProtectedEmailAndSubject } from "./types-Y0wL7HUH.js";
+import { EmailHybridDecryptionError, EmailHybridEncryptionError, EmailPasswordOpenError, EmailPasswordProtectError, EmailSymmetricDecryptionError, EmailSymmetricEncryptionError, FailedToDecryptEmail, FailedToEncryptEmail, InvalidInputEmail, createPwdProtectedEmail, createPwdProtectedEmailAndSubject, decryptEmail, decryptEmailAndSubject, decryptEmailAndSubjectHybrid, decryptEmailHybrid, decryptEmailPreviewHybrid, decryptPwdProtectedEmail, decryptPwdProtectedEmailAndSubject, deriveDatabaseKey, deriveEmailDraftKey, encryptEmail, encryptEmailAndSubject, encryptEmailAndSubjectHybridForMultipleRecipients, encryptEmailAndSubjectWithKey, encryptEmailHybridForMultipleRecipients, encryptEmailWithKey, generateEmailKeys } from "./email-crypto.js";
+import { getBytesFromData, getBytesFromDataArray, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey } from "./hash.js";
+import { FailedToChangeMnemonicForKeyStore, FailedToCreateKeyStores, FailedToOpenEncryptionKeyStore, FailedToOpenRecoveryKeyStore, InvalidInputKeyStore, changeMnemonicForEncryptionKeystore, createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore } from "./keystore-crypto.js";
+import { decapsulateKyber, encapsulateKyber, generateKyberKeys } from "./post-quantum-crypto.js";
+import { decryptSymmetrically, encryptSymmetrically, genSymmetricKey } from "./symmetric-crypto.js";
+import { UTF8ToUint8, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes } from "./utils.js";
+
+//#region src/key-wrapper/aesWrapper.d.ts
+/**
+ * Unwraps the given wrapped key
+ *
+ * @param encryptedKey - The wrapped key
+ * @param wrappingKey - The secret key used for unwrapping
+ * @returns The resulting key
+ */
+declare function unwrapKey(encryptedKey: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array>;
+/**
+ * Wraps the given key
+ *
+ * @param key - The key to be wrapped
+ * @param wrappingKey - The secret key used for wrapping
+ * @returns The resulting ciphertext
+ */
+declare function wrapKey(key: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array>;
+//#endregion
+export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DATABASE, CONTEXT_DRAFT, CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY, CONTEXT_TWO_KEYS, DB_LABEL, DB_VERSION, Email, EmailAndSubject, EmailAndSubjectEncrypted, EmailEncrypted, EmailHybridDecryptionError, EmailHybridEncryptionError, EmailPasswordOpenError, EmailPasswordProtectError, EmailSymmetricDecryptionError, EmailSymmetricEncryptionError, EncryptedKeystore, FailedToChangeMnemonicForKeyStore, FailedToCreateKeyStores, FailedToDecryptEmail, FailedToEncryptEmail, FailedToOpenEncryptionKeyStore, FailedToOpenRecoveryKeyStore, HybridEncKey, HybridKeyPair, IV_LEN_BYTES, InvalidInputEmail, InvalidInputKeyStore, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, PwdProtectedEmail, PwdProtectedEmailAndSubject, PwdProtectedKey, RecipientWithPublicKey, UTF8ToUint8, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, base64ToUint8Array, bytesToMnemonic, bytesToUuid, changeMnemonicForEncryptionKeystore, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, createPwdProtectedEmailAndSubject, decapsulateKyber, decryptEmail, decryptEmailAndSubject, decryptEmailAndSubjectHybrid, decryptEmailHybrid, decryptEmailPreviewHybrid, decryptPwdProtectedEmail, decryptPwdProtectedEmailAndSubject, decryptSymmetrically, deriveDatabaseKey, deriveEmailDraftKey, deriveKeyFromMnemonic, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptEmail, encryptEmailAndSubject, encryptEmailAndSubjectHybridForMultipleRecipients, encryptEmailAndSubjectWithKey, encryptEmailHybridForMultipleRecipients, encryptEmailWithKey, encryptSymmetrically, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateSalt, generateUuid, getBytesFromData, getBytesFromDataArray, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openEncryptionKeystore, openRecoveryKeystore, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };
+//# sourceMappingURL=index.d.ts.map

package/dist/react-native/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/key-wrapper/aesWrapper.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBASsB,SAAA,CAAU,YAAA,EAAc,UAAA,EAAY,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,UAAA;;;;;;AAA5F;;iBAWsB,OAAA,CAAQ,GAAA,EAAK,UAAA,EAAY,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,UAAA"}

package/dist/react-native/index.js

@@ -0,0 +1,106 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_asymmetric_crypto = require("./asymmetric-crypto.js");
+const require_constants = require("./constants.js");
+const require_utils = require("./utils.js");
+const require_derive_key = require("./derive-key.js");
+const require_derive_password = require("./derive-password-DIPrE8Mz.js");
+const require_symmetric_crypto = require("./symmetric-crypto.js");
+const require_email_crypto = require("./email-crypto-C3ka3aAj.js");
+const require_hash = require("./hash.js");
+const require_types = require("./types.js");
+const require_keystore_crypto = require("./keystore-crypto-BXPEVvzq.js");
+const require_post_quantum_crypto = require("./post-quantum-crypto.js");
+exports.AES_KEY_BYTE_LENGTH = require_constants.AES_KEY_BYTE_LENGTH;
+exports.ARGON2ID_ITERATIONS = require_constants.ARGON2ID_ITERATIONS;
+exports.ARGON2ID_MEMORY_SIZE = require_constants.ARGON2ID_MEMORY_SIZE;
+exports.ARGON2ID_OUTPUT_BYTE_LENGTH = require_constants.ARGON2ID_OUTPUT_BYTE_LENGTH;
+exports.ARGON2ID_PARALLELISM = require_constants.ARGON2ID_PARALLELISM;
+exports.ARGON2ID_SALT_BYTE_LENGTH = require_constants.ARGON2ID_SALT_BYTE_LENGTH;
+exports.CONTEXT_DATABASE = require_constants.CONTEXT_DATABASE;
+exports.CONTEXT_DRAFT = require_constants.CONTEXT_DRAFT;
+exports.CONTEXT_ENC_KEYSTORE = require_constants.CONTEXT_ENC_KEYSTORE;
+exports.CONTEXT_RECOVERY = require_constants.CONTEXT_RECOVERY;
+exports.CONTEXT_TWO_KEYS = require_constants.CONTEXT_TWO_KEYS;
+exports.DB_LABEL = require_constants.DB_LABEL;
+exports.DB_VERSION = require_constants.DB_VERSION;
+exports.EmailHybridDecryptionError = require_email_crypto.EmailHybridDecryptionError;
+exports.EmailHybridEncryptionError = require_email_crypto.EmailHybridEncryptionError;
+exports.EmailPasswordOpenError = require_email_crypto.EmailPasswordOpenError;
+exports.EmailPasswordProtectError = require_email_crypto.EmailPasswordProtectError;
+exports.EmailSymmetricDecryptionError = require_email_crypto.EmailSymmetricDecryptionError;
+exports.EmailSymmetricEncryptionError = require_email_crypto.EmailSymmetricEncryptionError;
+exports.FailedToChangeMnemonicForKeyStore = require_keystore_crypto.FailedToChangeMnemonicForKeyStore;
+exports.FailedToCreateKeyStores = require_keystore_crypto.FailedToCreateKeyStores;
+exports.FailedToDecryptEmail = require_email_crypto.FailedToDecryptEmail;
+exports.FailedToEncryptEmail = require_email_crypto.FailedToEncryptEmail;
+exports.FailedToOpenEncryptionKeyStore = require_keystore_crypto.FailedToOpenEncryptionKeyStore;
+exports.FailedToOpenRecoveryKeyStore = require_keystore_crypto.FailedToOpenRecoveryKeyStore;
+exports.IV_LEN_BYTES = require_constants.IV_LEN_BYTES;
+exports.InvalidInputEmail = require_email_crypto.InvalidInputEmail;
+exports.InvalidInputKeyStore = require_keystore_crypto.InvalidInputKeyStore;
+exports.KYBER768_PUBLIC_KEY_LENGTH = require_constants.KYBER768_PUBLIC_KEY_LENGTH;
+exports.KYBER768_SECRET_KEY_LENGTH = require_constants.KYBER768_SECRET_KEY_LENGTH;
+exports.KYBER_SEED_LENGTH = require_constants.KYBER_SEED_LENGTH;
+exports.KeystoreType = require_types.KeystoreType;
+exports.MAX_CACHE_SIZE = require_constants.MAX_CACHE_SIZE;
+exports.MAX_EMAIL_PER_BATCH = require_constants.MAX_EMAIL_PER_BATCH;
+exports.UTF8ToUint8 = require_utils.UTF8ToUint8;
+exports.XWING_CIPHERTEXT_BYTE_LENGTH = require_constants.XWING_CIPHERTEXT_BYTE_LENGTH;
+exports.XWING_PUBLIC_KEY_LENGTH = require_constants.XWING_PUBLIC_KEY_LENGTH;
+exports.XWING_SECRET_KEY_LENGTH = require_constants.XWING_SECRET_KEY_LENGTH;
+exports.XWING_SEED_BYTE_LENGTH = require_constants.XWING_SEED_BYTE_LENGTH;
+exports.base64ToUint8Array = require_utils.base64ToUint8Array;
+exports.bytesToMnemonic = require_utils.bytesToMnemonic;
+exports.bytesToUuid = require_utils.bytesToUuid;
+exports.changeMnemonicForEncryptionKeystore = require_keystore_crypto.changeMnemonicForEncryptionKeystore;
+exports.createEncryptionAndRecoveryKeystores = require_keystore_crypto.createEncryptionAndRecoveryKeystores;
+exports.createPwdProtectedEmail = require_email_crypto.createPwdProtectedEmail;
+exports.createPwdProtectedEmailAndSubject = require_email_crypto.createPwdProtectedEmailAndSubject;
+exports.decapsulateKyber = require_post_quantum_crypto.decapsulateKyber;
+exports.decryptEmail = require_email_crypto.decryptEmail;
+exports.decryptEmailAndSubject = require_email_crypto.decryptEmailAndSubject;
+exports.decryptEmailAndSubjectHybrid = require_email_crypto.decryptEmailAndSubjectHybrid;
+exports.decryptEmailHybrid = require_email_crypto.decryptEmailHybrid;
+exports.decryptEmailPreviewHybrid = require_email_crypto.decryptEmailPreviewHybrid;
+exports.decryptPwdProtectedEmail = require_email_crypto.decryptPwdProtectedEmail;
+exports.decryptPwdProtectedEmailAndSubject = require_email_crypto.decryptPwdProtectedEmailAndSubject;
+exports.decryptSymmetrically = require_symmetric_crypto.decryptSymmetrically;
+exports.deriveDatabaseKey = require_email_crypto.deriveDatabaseKey;
+exports.deriveEmailDraftKey = require_email_crypto.deriveEmailDraftKey;
+exports.deriveKeyFromMnemonic = require_derive_key.deriveKeyFromMnemonic;
+exports.deriveSecretKey = require_asymmetric_crypto.deriveSecretKey;
+exports.deriveSymmetricKeyFromContext = require_derive_key.deriveSymmetricKeyFromContext;
+exports.deriveSymmetricKeyFromTwoKeys = require_derive_key.deriveSymmetricKeyFromTwoKeys;
+exports.encapsulateKyber = require_post_quantum_crypto.encapsulateKyber;
+exports.encryptEmail = require_email_crypto.encryptEmail;
+exports.encryptEmailAndSubject = require_email_crypto.encryptEmailAndSubject;
+exports.encryptEmailAndSubjectHybridForMultipleRecipients = require_email_crypto.encryptEmailAndSubjectHybridForMultipleRecipients;
+exports.encryptEmailAndSubjectWithKey = require_email_crypto.encryptEmailAndSubjectWithKey;
+exports.encryptEmailHybridForMultipleRecipients = require_email_crypto.encryptEmailHybridForMultipleRecipients;
+exports.encryptEmailWithKey = require_email_crypto.encryptEmailWithKey;
+exports.encryptSymmetrically = require_symmetric_crypto.encryptSymmetrically;
+exports.genMnemonic = require_utils.genMnemonic;
+exports.genSymmetricKey = require_symmetric_crypto.genSymmetricKey;
+exports.generateEccKeys = require_asymmetric_crypto.generateEccKeys;
+exports.generateEmailKeys = require_email_crypto.generateEmailKeys;
+exports.generateKyberKeys = require_post_quantum_crypto.generateKyberKeys;
+exports.generateSalt = require_derive_password.generateSalt;
+exports.generateUuid = require_utils.generateUuid;
+exports.getBytesFromData = require_hash.getBytesFromData;
+exports.getBytesFromDataArray = require_hash.getBytesFromDataArray;
+exports.getKeyFromPassword = require_derive_password.getKeyFromPassword;
+exports.getKeyFromPasswordAndSalt = require_derive_password.getKeyFromPasswordAndSalt;
+exports.hashData = require_hash.hashData;
+exports.hashDataArray = require_hash.hashDataArray;
+exports.hashDataArrayWithKey = require_hash.hashDataArrayWithKey;
+exports.hashDataWithKey = require_hash.hashDataWithKey;
+exports.hexToUint8Array = require_utils.hexToUint8Array;
+exports.mnemonicToBytes = require_utils.mnemonicToBytes;
+exports.openEncryptionKeystore = require_keystore_crypto.openEncryptionKeystore;
+exports.openRecoveryKeystore = require_keystore_crypto.openRecoveryKeystore;
+exports.uint8ArrayToBase64 = require_utils.uint8ArrayToBase64;
+exports.uint8ArrayToHex = require_utils.uint8ArrayToHex;
+exports.uint8ToUTF8 = require_utils.uint8ToUTF8;
+exports.unwrapKey = require_email_crypto.unwrapKey;
+exports.uuidToBytes = require_utils.uuidToBytes;
+exports.wrapKey = require_email_crypto.wrapKey;

package/dist/react-native/index.mjs

@@ -0,0 +1,12 @@
+import { deriveSecretKey, generateEccKeys } from "./asymmetric-crypto.mjs";
+import { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DATABASE, CONTEXT_DRAFT, CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY, CONTEXT_TWO_KEYS, DB_LABEL, DB_VERSION, IV_LEN_BYTES, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH } from "./constants.mjs";
+import { UTF8ToUint8, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes } from "./utils.mjs";
+import { deriveKeyFromMnemonic, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys } from "./derive-key.mjs";
+import { n as getKeyFromPassword, r as getKeyFromPasswordAndSalt, t as generateSalt } from "./derive-password-Bb3R3nyh.mjs";
+import { decryptSymmetrically, encryptSymmetrically, genSymmetricKey } from "./symmetric-crypto.mjs";
+import { A as EmailSymmetricEncryptionError, D as EmailPasswordProtectError, E as EmailPasswordOpenError, F as wrapKey, M as FailedToEncryptEmail, N as InvalidInputEmail, P as unwrapKey, T as EmailHybridEncryptionError, a as decryptPwdProtectedEmailAndSubject, b as encryptEmailWithKey, c as decryptEmailAndSubject, d as createPwdProtectedEmail, f as decryptPwdProtectedEmail, g as decryptEmail, h as encryptEmailHybridForMultipleRecipients, i as createPwdProtectedEmailAndSubject, j as FailedToDecryptEmail, k as EmailSymmetricDecryptionError, l as encryptEmailAndSubject, m as decryptEmailPreviewHybrid, n as deriveEmailDraftKey, o as decryptEmailAndSubjectHybrid, p as decryptEmailHybrid, r as generateEmailKeys, s as encryptEmailAndSubjectHybridForMultipleRecipients, t as deriveDatabaseKey, u as encryptEmailAndSubjectWithKey, w as EmailHybridDecryptionError, y as encryptEmail } from "./email-crypto-CDM4iPK8.mjs";
+import { getBytesFromData, getBytesFromDataArray, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey } from "./hash.mjs";
+import { KeystoreType } from "./types.mjs";
+import { a as FailedToChangeMnemonicForKeyStore, c as FailedToOpenRecoveryKeyStore, i as openRecoveryKeystore, l as InvalidInputKeyStore, n as createEncryptionAndRecoveryKeystores, o as FailedToCreateKeyStores, r as openEncryptionKeystore, s as FailedToOpenEncryptionKeyStore, t as changeMnemonicForEncryptionKeystore } from "./keystore-crypto-C6F-NQdX.mjs";
+import { decapsulateKyber, encapsulateKyber, generateKyberKeys } from "./post-quantum-crypto.mjs";
+export { AES_KEY_BYTE_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DATABASE, CONTEXT_DRAFT, CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY, CONTEXT_TWO_KEYS, DB_LABEL, DB_VERSION, EmailHybridDecryptionError, EmailHybridEncryptionError, EmailPasswordOpenError, EmailPasswordProtectError, EmailSymmetricDecryptionError, EmailSymmetricEncryptionError, FailedToChangeMnemonicForKeyStore, FailedToCreateKeyStores, FailedToDecryptEmail, FailedToEncryptEmail, FailedToOpenEncryptionKeyStore, FailedToOpenRecoveryKeyStore, IV_LEN_BYTES, InvalidInputEmail, InvalidInputKeyStore, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, UTF8ToUint8, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, base64ToUint8Array, bytesToMnemonic, bytesToUuid, changeMnemonicForEncryptionKeystore, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, createPwdProtectedEmailAndSubject, decapsulateKyber, decryptEmail, decryptEmailAndSubject, decryptEmailAndSubjectHybrid, decryptEmailHybrid, decryptEmailPreviewHybrid, decryptPwdProtectedEmail, decryptPwdProtectedEmailAndSubject, decryptSymmetrically, deriveDatabaseKey, deriveEmailDraftKey, deriveKeyFromMnemonic, deriveSecretKey, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, encapsulateKyber, encryptEmail, encryptEmailAndSubject, encryptEmailAndSubjectHybridForMultipleRecipients, encryptEmailAndSubjectWithKey, encryptEmailHybridForMultipleRecipients, encryptEmailWithKey, encryptSymmetrically, genMnemonic, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateSalt, generateUuid, getBytesFromData, getBytesFromDataArray, getKeyFromPassword, getKeyFromPasswordAndSalt, hashData, hashDataArray, hashDataArrayWithKey, hashDataWithKey, hexToUint8Array, mnemonicToBytes, openEncryptionKeystore, openRecoveryKeystore, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, wrapKey };