internxt-crypto 0.0.11 → 0.0.13

package/dist/genID-YJSl3YhL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"genID-YJSl3YhL.js","names":["importPublicKey","exportPublicKey","bip39","wordlist","AES_KEY_BIT_LENGTH","uuid"],"sources":["../src/utils/converters.ts","../src/utils/keyConverters.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 { uint8ArrayToBase64, base64ToUint8Array } from '.';\nimport { PublicKeys, PublicKeysBase64 } from '../types';\nimport { exportPublicKey, importPublicKey } from '../asymmetric-crypto';\n\n/**\n * Converts a base64 string into PublicKeys type.\n *\n * @param base64 - The base64 representation of the public key.\n * @returns The resulting PublicKeys.\n */\nexport async function base64ToPublicKey(base64: PublicKeysBase64): Promise<PublicKeys> {\n  try {\n    const eccPublicKeyBytes = base64ToUint8Array(base64.eccPublicKeyBase64);\n    const eccPublicKey = await importPublicKey(eccPublicKeyBytes);\n    const kyberPublicKey = base64ToUint8Array(base64.kyberPublicKeyBase64);\n    return {\n      eccPublicKey: eccPublicKey,\n      kyberPublicKey: kyberPublicKey,\n    };\n  } catch (error) {\n    throw new Error('Failed to convert base64 to PublicKeys', { cause: error });\n  }\n}\n\n/**\n * Converts a PublicKeys type into PublicKeysBase64.\n *\n * @param key - The PublicKeys key.\n * @returns The resulting PublicKeysBase64.\n */\nexport async function publicKeyToBase64(key: PublicKeys): Promise<PublicKeysBase64> {\n  try {\n    const eccPublicKeyArray = await exportPublicKey(key.eccPublicKey);\n    const keys = {\n      eccPublicKeyBase64: uint8ArrayToBase64(eccPublicKeyArray),\n      kyberPublicKeyBase64: uint8ArrayToBase64(key.kyberPublicKey),\n    };\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to convert key of the type PublicKeys to PublicKeysBase64', { cause: error });\n  }\n}\n","import * as bip39 from '@scure/bip39';\nimport { wordlist } from '@scure/bip39/wordlists/english.js';\nimport { AES_KEY_BIT_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_BIT_LENGTH);\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;;;;;;;;;;;ACzDrC,eAAsB,kBAAkB,QAA+C;AACrF,KAAI;AAIF,SAAO;GACL,cAHmB,MAAMA,6BADD,mBAAmB,OAAO,mBAAmB,CACV;GAI3D,gBAHqB,mBAAmB,OAAO,qBAAqB;GAIrE;UACM,OAAO;AACd,QAAM,IAAI,MAAM,0CAA0C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU/E,eAAsB,kBAAkB,KAA4C;AAClF,KAAI;AAMF,SAJa;GACX,oBAAoB,mBAFI,MAAMC,6BAAgB,IAAI,aAAa,CAEN;GACzD,sBAAsB,mBAAmB,IAAI,eAAe;GAC7D;UAEM,OAAO;AACd,QAAM,IAAI,MAAM,oEAAoE,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AC/BzG,SAAgB,cAAsB;AACpC,QAAOC,aAAM,iBAAiBC,4CAAUC,qCAAmB;;;;;;;;AAS7D,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

@@ -57,9 +57,6 @@ declare function getBytesFromDataHex(bytes: number, data: Uint8Array): string;
  * @returns The resulting hash hex string
  */
 declare function computeMac(keyMaterial: Uint8Array, data: Uint8Array[]): string;
-declare namespace index_d_exports {
-  export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex };
-}
 //#endregion
-export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex, index_d_exports as t };
+export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex };
 //# sourceMappingURL=hash.d.mts.map

package/dist/hash.d.mts.map

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

package/dist/hash.d.ts

@@ -57,9 +57,6 @@ declare function getBytesFromDataHex(bytes: number, data: Uint8Array): string;
  * @returns The resulting hash hex string
  */
 declare function computeMac(keyMaterial: Uint8Array, data: Uint8Array[]): string;
-declare namespace index_d_exports {
-  export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex };
-}
 //#endregion
-export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex, index_d_exports as t };
+export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex };
 //# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

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

package/dist/hash.js

@@ -1,11 +1,12 @@
-const require_hash = require('./hash-BoqwNkcd.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_mac = require('./mac-BMb1F0dN.js');
 
-exports.computeMac = require_hash.computeMac;
-exports.getBytesFromData = require_hash.getBytesFromData;
-exports.getBytesFromDataArray = require_hash.getBytesFromDataArray;
-exports.getBytesFromDataArrayHex = require_hash.getBytesFromDataArrayHex;
-exports.getBytesFromDataHex = require_hash.getBytesFromDataHex;
-exports.hashDataArray = require_hash.hashDataArray;
-exports.hashDataArrayHex = require_hash.hashDataArrayHex;
-exports.hashDataArrayWithKey = require_hash.hashDataArrayWithKey;
-exports.hashDataArrayWithKeyHex = require_hash.hashDataArrayWithKeyHex;
+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;

package/dist/hash.mjs

@@ -1,3 +1,3 @@
-import { a as getBytesFromDataArrayHex, c as hashDataArrayHex, i as getBytesFromDataArray, l as hashDataArrayWithKey, n as computeMac, o as getBytesFromDataHex, r as getBytesFromData, s as hashDataArray, u as hashDataArrayWithKeyHex } from "./hash-CXeGAwai.mjs";
+import { a as getBytesFromDataHex, c as hashDataArrayWithKey, i as getBytesFromDataArrayHex, l as hashDataArrayWithKeyHex, n as getBytesFromData, o as hashDataArray, r as getBytesFromDataArray, s as hashDataArrayHex, t as computeMac } from "./mac-ZpRlx8Fs.mjs";
 
 export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex };

package/dist/index.d.mts

@@ -1,33 +1,16 @@
-import { t as index_d_exports } from "./asymmetric-crypto.mjs";
+import { deriveSecretKey, exportPrivateKey, exportPublicKey, generateEccKeys, importPrivateKey, importPublicKey } from "./asymmetric-crypto.mjs";
 import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, HASH_BIT_LEN, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH } from "./constants.mjs";
-import { t as index_d_exports$1 } from "./derive-key.mjs";
-import { _ as PwdProtectedEmail, a as EmailKeysEncrypted, b as User, c as EncryptedKeystore, d as KeystoreType, f as MailCache, g as PublicKeysBase64, h as PublicKeys, i as EmailKeys, l as HybridEncKey, m as PrivateKeysEncrypted, n as EmailBody, o as EmailPublicParameters, p as PrivateKeys, r as EmailBodyEncrypted, s as EmailSearchResult, t as Email, u as HybridEncryptedEmail, v as PwdProtectedKey, x as UserWithPublicKeys, y as StoredEmail } from "./types-DwQJtrTx.mjs";
-import { t as index_d_exports$2 } from "./email-crypto.mjs";
-import { t as index_d_exports$3 } from "./email-search.mjs";
-import { t as index_d_exports$4 } from "./hash.mjs";
-import { t as index_d_exports$6 } from "./keystore-crypto.mjs";
-import { t as index_d_exports$7 } from "./keystore-service.mjs";
-import { t as index_d_exports$8 } from "./index-MaOov-ag.mjs";
-import { t as index_d_exports$9 } from "./index-D5pBU_A5.mjs";
-import { t as index_d_exports$10 } from "./symmetric-crypto.mjs";
-import { t as index_d_exports$11 } from "./utils.mjs";
+import { deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, verifyKeyFromPasswordHex } from "./derive-key.mjs";
+import { Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, KeystoreType, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys } from "./types.mjs";
+import { createPwdProtectedEmail, decryptEmailHybrid, decryptPwdProtectedEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys } from "./email-crypto.mjs";
+import { addEmailToCache, addEmailToSearchIndex, addEmailsToCache, buildSearchIndexFromCache, closeDatabase, createCacheFromDB, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, encryptAndStoreEmail, encryptAndStoreManyEmail, enforceMaxEmailNumber, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getEmailBatch, getEmailCount, getEmailFromCache, openDatabase, removeEmailFromSearchIndex, searchEmails } from "./email-search.mjs";
+import { computeMac, getBytesFromData, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex } from "./hash.mjs";
+import { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore } from "./keystore-crypto.mjs";
+import { n as encapsulateKyber, r as generateKyberKeys, t as decapsulateKyber } from "./kyber768-DzIcGg1i.mjs";
+import { decryptSymmetrically, deriveSymmetricCryptoKey, encryptSymmetrically, exportSymmetricCryptoKey, genSymmetricCryptoKey, genSymmetricKey, importSymmetricCryptoKey } from "./symmetric-crypto.mjs";
+import { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes } from "./utils.mjs";
 
 //#region src/key-wrapper/aesWrapper.d.ts
-/**
- * Converts wrapping key in Uint8Array into CryptoKey
- *
- * @param key - The wrapping key in Uint8Array representation
- * @returns The resulting CryptoKey
- */
-declare function importWrappingKey(key: Uint8Array): Promise<CryptoKey>;
-/**
- * Derives wrapping key from two secrets
- *
- * @param eccSecret - The secret exchanged via elliptic curves
- * @param kyberSecret - The secret exchanged via Kyber KEM
- * @returns The resulting wrapping CryptoKey
- */
-declare function deriveWrappingKey(eccSecret: Uint8Array, kyberSecret: Uint8Array): Promise<CryptoKey>;
 /**
  * Unwraps the given wrapped key
  *
@@ -44,9 +27,6 @@ declare function unwrapKey(encryptedKey: Uint8Array, wrappingKey: CryptoKey): Pr
  * @returns The resulting ciphertext
  */
 declare function wrapKey(encryptionKey: CryptoKey, wrappingKey: CryptoKey): Promise<Uint8Array>;
-declare namespace index_d_exports$5 {
-  export { deriveWrappingKey, importWrappingKey, unwrapKey, wrapKey };
-}
 //#endregion
-export { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HASH_BIT_LEN, HybridEncKey, HybridEncryptedEmail, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys, index_d_exports as asymmetric, index_d_exports$1 as deriveKey, index_d_exports$2 as emailCrypto, index_d_exports$3 as emailSearch, index_d_exports$4 as hash, index_d_exports$5 as keyWrapper, index_d_exports$6 as keystoreCrypto, index_d_exports$7 as keystoreService, index_d_exports$8 as pq, index_d_exports$9 as storage, index_d_exports$10 as symmetric, index_d_exports$11 as utils };
+export { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HASH_BIT_LEN, HybridEncKey, HybridEncryptedEmail, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, UTF8ToUint8, User, UserWithPublicKeys, addEmailToCache, addEmailToSearchIndex, addEmailsToCache, base64ToPublicKey, base64ToUint8Array, buildSearchIndexFromCache, bytesToMnemonic, bytesToUuid, closeDatabase, computeMac, createCacheFromDB, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, deriveSecretKey, deriveSymmetricCryptoKey, deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, encapsulateKyber, encryptAndStoreEmail, encryptAndStoreManyEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, enforceMaxEmailNumber, exportPrivateKey, exportPublicKey, exportSymmetricCryptoKey, genMnemonic, genSymmetricCryptoKey, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getBytesFromData, getBytesFromDataArrayHex, getBytesFromDataHex, getEmailBatch, getEmailCount, getEmailFromCache, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex, hexToUint8Array, importPrivateKey, importPublicKey, importSymmetricCryptoKey, mnemonicToBytes, openDatabase, openEncryptionKeystore, openRecoveryKeystore, publicKeyToBase64, removeEmailFromSearchIndex, searchEmails, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, verifyKeyFromPasswordHex, wrapKey };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/key-wrapper/aesWrapper.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBA8CsB,SAAA,CAAU,YAAA,EAAc,UAAA,EAAY,WAAA,EAAa,SAAA,GAAY,OAAA,CAAQ,SAAA;;;;;;;;iBAuBrE,OAAA,CAAQ,aAAA,EAAe,SAAA,EAAW,WAAA,EAAa,SAAA,GAAY,OAAA,CAAQ,UAAA"}

package/dist/index.d.ts

@@ -1,33 +1,16 @@
-import { t as index_d_exports } from "./asymmetric-crypto.js";
+import { deriveSecretKey, exportPrivateKey, exportPublicKey, generateEccKeys, importPrivateKey, importPublicKey } from "./asymmetric-crypto.js";
 import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, HASH_BIT_LEN, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH } from "./constants.js";
-import { t as index_d_exports$1 } from "./derive-key.js";
-import { _ as PwdProtectedEmail, a as EmailKeysEncrypted, b as User, c as EncryptedKeystore, d as KeystoreType, f as MailCache, g as PublicKeysBase64, h as PublicKeys, i as EmailKeys, l as HybridEncKey, m as PrivateKeysEncrypted, n as EmailBody, o as EmailPublicParameters, p as PrivateKeys, r as EmailBodyEncrypted, s as EmailSearchResult, t as Email, u as HybridEncryptedEmail, v as PwdProtectedKey, x as UserWithPublicKeys, y as StoredEmail } from "./types-Ds3ivE9W.js";
-import { t as index_d_exports$2 } from "./email-crypto.js";
-import { t as index_d_exports$3 } from "./email-search.js";
-import { t as index_d_exports$4 } from "./hash.js";
-import { t as index_d_exports$6 } from "./keystore-crypto.js";
-import { t as index_d_exports$7 } from "./keystore-service.js";
-import { t as index_d_exports$8 } from "./index-CintVUbp.js";
-import { t as index_d_exports$9 } from "./index-CQqgKsbX.js";
-import { t as index_d_exports$10 } from "./symmetric-crypto.js";
-import { t as index_d_exports$11 } from "./utils.js";
+import { deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, verifyKeyFromPasswordHex } from "./derive-key.js";
+import { Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, KeystoreType, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys } from "./types.js";
+import { createPwdProtectedEmail, decryptEmailHybrid, decryptPwdProtectedEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys } from "./email-crypto.js";
+import { addEmailToCache, addEmailToSearchIndex, addEmailsToCache, buildSearchIndexFromCache, closeDatabase, createCacheFromDB, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, encryptAndStoreEmail, encryptAndStoreManyEmail, enforceMaxEmailNumber, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getEmailBatch, getEmailCount, getEmailFromCache, openDatabase, removeEmailFromSearchIndex, searchEmails } from "./email-search.js";
+import { computeMac, getBytesFromData, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex } from "./hash.js";
+import { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore } from "./keystore-crypto.js";
+import { n as encapsulateKyber, r as generateKyberKeys, t as decapsulateKyber } from "./kyber768-DGBB_RS7.js";
+import { decryptSymmetrically, deriveSymmetricCryptoKey, encryptSymmetrically, exportSymmetricCryptoKey, genSymmetricCryptoKey, genSymmetricKey, importSymmetricCryptoKey } from "./symmetric-crypto.js";
+import { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes } from "./utils.js";
 
 //#region src/key-wrapper/aesWrapper.d.ts
-/**
- * Converts wrapping key in Uint8Array into CryptoKey
- *
- * @param key - The wrapping key in Uint8Array representation
- * @returns The resulting CryptoKey
- */
-declare function importWrappingKey(key: Uint8Array): Promise<CryptoKey>;
-/**
- * Derives wrapping key from two secrets
- *
- * @param eccSecret - The secret exchanged via elliptic curves
- * @param kyberSecret - The secret exchanged via Kyber KEM
- * @returns The resulting wrapping CryptoKey
- */
-declare function deriveWrappingKey(eccSecret: Uint8Array, kyberSecret: Uint8Array): Promise<CryptoKey>;
 /**
  * Unwraps the given wrapped key
  *
@@ -44,9 +27,6 @@ declare function unwrapKey(encryptedKey: Uint8Array, wrappingKey: CryptoKey): Pr
  * @returns The resulting ciphertext
  */
 declare function wrapKey(encryptionKey: CryptoKey, wrappingKey: CryptoKey): Promise<Uint8Array>;
-declare namespace index_d_exports$5 {
-  export { deriveWrappingKey, importWrappingKey, unwrapKey, wrapKey };
-}
 //#endregion
-export { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HASH_BIT_LEN, HybridEncKey, HybridEncryptedEmail, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys, index_d_exports as asymmetric, index_d_exports$1 as deriveKey, index_d_exports$2 as emailCrypto, index_d_exports$3 as emailSearch, index_d_exports$4 as hash, index_d_exports$5 as keyWrapper, index_d_exports$6 as keystoreCrypto, index_d_exports$7 as keystoreService, index_d_exports$8 as pq, index_d_exports$9 as storage, index_d_exports$10 as symmetric, index_d_exports$11 as utils };
+export { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HASH_BIT_LEN, HybridEncKey, HybridEncryptedEmail, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, UTF8ToUint8, User, UserWithPublicKeys, addEmailToCache, addEmailToSearchIndex, addEmailsToCache, base64ToPublicKey, base64ToUint8Array, buildSearchIndexFromCache, bytesToMnemonic, bytesToUuid, closeDatabase, computeMac, createCacheFromDB, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, deriveSecretKey, deriveSymmetricCryptoKey, deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, encapsulateKyber, encryptAndStoreEmail, encryptAndStoreManyEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, enforceMaxEmailNumber, exportPrivateKey, exportPublicKey, exportSymmetricCryptoKey, genMnemonic, genSymmetricCryptoKey, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getBytesFromData, getBytesFromDataArrayHex, getBytesFromDataHex, getEmailBatch, getEmailCount, getEmailFromCache, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex, hexToUint8Array, importPrivateKey, importPublicKey, importSymmetricCryptoKey, mnemonicToBytes, openDatabase, openEncryptionKeystore, openRecoveryKeystore, publicKeyToBase64, removeEmailFromSearchIndex, searchEmails, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, verifyKeyFromPasswordHex, wrapKey };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/key-wrapper/aesWrapper.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBA8CsB,SAAA,CAAU,YAAA,EAAc,UAAA,EAAY,WAAA,EAAa,SAAA,GAAY,OAAA,CAAQ,SAAA;;;;;;;;iBAuBrE,OAAA,CAAQ,aAAA,EAAe,SAAA,EAAW,WAAA,EAAa,SAAA,GAAY,OAAA,CAAQ,UAAA"}

package/dist/index.js

@@ -1,16 +1,15 @@
-const require_constants = require('./constants-Ccp21E03.js');
-const require_asymmetric_crypto = require('./asymmetric-crypto-BORmLhnx.js');
-const require_utils = require('./utils-CNs3cyDj.js');
-const require_hash = require('./hash-BoqwNkcd.js');
-const require_symmetric_crypto = require('./symmetric-crypto-D65zB396.js');
-const require_derive_key = require('./derive-key-CBf2WxJd.js');
-const require_post_quantum_crypto = require('./post-quantum-crypto-CAi-cEkV.js');
-const require_email_crypto = require('./email-crypto-BrT98taw.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+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-bOrKZuUC.js');
+const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-Ko7NxkHM.js');
+const require_kyber1024 = require('./kyber1024-jeKS8CXf.js');
+const require_emailKeys = require('./emailKeys-BJGdkLrg.js');
 const require_email_search = require('./email-search.js');
-const require_types = require('./types-52g887Zi.js');
-const require_keystore_crypto = require('./keystore-crypto-B4yCVo9l.js');
-const require_keystore_service = require('./keystore-service.js');
-const require_storage_service = require('./storage-service-BgIK2aYZ.js');
+const require_types = require('./types.js');
+const require_emailEncryptionKey = require('./emailEncryptionKey-DbaDAdoW.js');
 
 exports.AES_ALGORITHM = require_constants.AES_ALGORITHM;
 exports.AES_KEY_BIT_LENGTH = require_constants.AES_KEY_BIT_LENGTH;
@@ -42,75 +41,85 @@ 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;
-Object.defineProperty(exports, 'asymmetric', {
-  enumerable: true,
-  get: function () {
-    return require_asymmetric_crypto.asymmetric_crypto_exports;
-  }
-});
-Object.defineProperty(exports, 'deriveKey', {
-  enumerable: true,
-  get: function () {
-    return require_derive_key.derive_key_exports;
-  }
-});
-Object.defineProperty(exports, 'emailCrypto', {
-  enumerable: true,
-  get: function () {
-    return require_email_crypto.email_crypto_exports;
-  }
-});
-Object.defineProperty(exports, 'emailSearch', {
-  enumerable: true,
-  get: function () {
-    return require_email_search.email_search_exports;
-  }
-});
-Object.defineProperty(exports, 'hash', {
-  enumerable: true,
-  get: function () {
-    return require_hash.hash_exports;
-  }
-});
-Object.defineProperty(exports, 'keyWrapper', {
-  enumerable: true,
-  get: function () {
-    return require_email_crypto.key_wrapper_exports;
-  }
-});
-Object.defineProperty(exports, 'keystoreCrypto', {
-  enumerable: true,
-  get: function () {
-    return require_keystore_crypto.keystore_crypto_exports;
-  }
-});
-Object.defineProperty(exports, 'keystoreService', {
-  enumerable: true,
-  get: function () {
-    return require_keystore_service.keystore_service_exports;
-  }
-});
-Object.defineProperty(exports, 'pq', {
-  enumerable: true,
-  get: function () {
-    return require_post_quantum_crypto.post_quantum_crypto_exports;
-  }
-});
-Object.defineProperty(exports, 'storage', {
-  enumerable: true,
-  get: function () {
-    return require_storage_service.storage_service_exports;
-  }
-});
-Object.defineProperty(exports, 'symmetric', {
-  enumerable: true,
-  get: function () {
-    return require_symmetric_crypto.symmetric_crypto_exports;
-  }
-});
-Object.defineProperty(exports, 'utils', {
-  enumerable: true,
-  get: function () {
-    return require_utils.utils_exports;
-  }
-});
+exports.UTF8ToUint8 = require_genID.UTF8ToUint8;
+exports.addEmailToCache = require_email_search.addEmailToCache;
+exports.addEmailToSearchIndex = require_email_search.addEmailToSearchIndex;
+exports.addEmailsToCache = require_email_search.addEmailsToCache;
+exports.base64ToPublicKey = require_genID.base64ToPublicKey;
+exports.base64ToUint8Array = require_genID.base64ToUint8Array;
+exports.buildSearchIndexFromCache = require_email_search.buildSearchIndexFromCache;
+exports.bytesToMnemonic = require_genID.bytesToMnemonic;
+exports.bytesToUuid = require_genID.bytesToUuid;
+exports.closeDatabase = require_email_search.closeDatabase;
+exports.computeMac = require_mac.computeMac;
+exports.createCacheFromDB = require_email_search.createCacheFromDB;
+exports.createEncryptionAndRecoveryKeystores = require_emailEncryptionKey.createEncryptionAndRecoveryKeystores;
+exports.createPwdProtectedEmail = require_emailKeys.createPwdProtectedEmail;
+exports.decapsulateKyber = require_kyber1024.decapsulateKyber;
+exports.decryptEmailHybrid = require_emailKeys.decryptEmailHybrid;
+exports.decryptPwdProtectedEmail = require_emailKeys.decryptPwdProtectedEmail;
+exports.decryptSymmetrically = require_aes.decryptSymmetrically;
+exports.deleteEmail = require_email_search.deleteEmail;
+exports.deleteEmailFromCache = require_email_search.deleteEmailFromCache;
+exports.deleteOldestEmails = require_email_search.deleteOldestEmails;
+exports.deriveIndexKey = require_email_search.deriveIndexKey;
+exports.deriveSecretKey = require_keys.deriveSecretKey;
+exports.deriveSymmetricCryptoKey = require_aes.deriveSymmetricCryptoKey;
+exports.deriveSymmetricCryptoKeyFromContext = require_deriveKeysFromPassword.deriveSymmetricCryptoKeyFromContext;
+exports.deriveSymmetricCryptoKeyFromTwoKeys = require_deriveKeysFromPassword.deriveSymmetricCryptoKeyFromTwoKeys;
+exports.deriveSymmetricKeyFromContext = require_deriveKeysFromPassword.deriveSymmetricKeyFromContext;
+exports.deriveSymmetricKeyFromTwoKeys = require_deriveKeysFromPassword.deriveSymmetricKeyFromTwoKeys;
+exports.deriveSymmetricKeyFromTwoKeysAndContext = require_deriveKeysFromPassword.deriveSymmetricKeyFromTwoKeysAndContext;
+exports.encapsulateKyber = require_kyber1024.encapsulateKyber;
+exports.encryptAndStoreEmail = require_email_search.encryptAndStoreEmail;
+exports.encryptAndStoreManyEmail = require_email_search.encryptAndStoreManyEmail;
+exports.encryptEmailHybrid = require_emailKeys.encryptEmailHybrid;
+exports.encryptEmailHybridForMultipleRecipients = require_emailKeys.encryptEmailHybridForMultipleRecipients;
+exports.encryptSymmetrically = require_aes.encryptSymmetrically;
+exports.enforceMaxEmailNumber = require_email_search.enforceMaxEmailNumber;
+exports.exportPrivateKey = require_keys.exportPrivateKey;
+exports.exportPublicKey = require_keys.exportPublicKey;
+exports.exportSymmetricCryptoKey = require_aes.exportSymmetricCryptoKey;
+exports.genMnemonic = require_genID.genMnemonic;
+exports.genSymmetricCryptoKey = require_aes.genSymmetricCryptoKey;
+exports.genSymmetricKey = require_aes.genSymmetricKey;
+exports.generateEccKeys = require_keys.generateEccKeys;
+exports.generateEmailKeys = require_emailKeys.generateEmailKeys;
+exports.generateKyberKeys = require_kyber1024.generateKyberKeys;
+exports.generateUuid = require_genID.generateUuid;
+exports.getAllEmailsSortedNewestFirst = require_email_search.getAllEmailsSortedNewestFirst;
+exports.getAllEmailsSortedOldestFirst = require_email_search.getAllEmailsSortedOldestFirst;
+exports.getAndDecryptAllEmails = require_email_search.getAndDecryptAllEmails;
+exports.getAndDecryptEmail = require_email_search.getAndDecryptEmail;
+exports.getBytesFromData = require_mac.getBytesFromData;
+exports.getBytesFromDataArrayHex = require_mac.getBytesFromDataArrayHex;
+exports.getBytesFromDataHex = require_mac.getBytesFromDataHex;
+exports.getEmailBatch = require_email_search.getEmailBatch;
+exports.getEmailCount = require_email_search.getEmailCount;
+exports.getEmailFromCache = require_email_search.getEmailFromCache;
+exports.getKeyFromPassword = require_deriveKeysFromPassword.getKeyFromPassword;
+exports.getKeyFromPasswordAndSalt = require_deriveKeysFromPassword.getKeyFromPasswordAndSalt;
+exports.getKeyFromPasswordAndSaltHex = require_deriveKeysFromPassword.getKeyFromPasswordAndSaltHex;
+exports.getKeyFromPasswordHex = require_deriveKeysFromPassword.getKeyFromPasswordHex;
+exports.hashDataArray = require_mac.hashDataArray;
+exports.hashDataArrayHex = require_mac.hashDataArrayHex;
+exports.hashDataArrayWithKey = require_mac.hashDataArrayWithKey;
+exports.hashDataArrayWithKeyHex = require_mac.hashDataArrayWithKeyHex;
+exports.hexToUint8Array = require_genID.hexToUint8Array;
+exports.importPrivateKey = require_keys.importPrivateKey;
+exports.importPublicKey = require_keys.importPublicKey;
+exports.importSymmetricCryptoKey = require_aes.importSymmetricCryptoKey;
+exports.mnemonicToBytes = require_genID.mnemonicToBytes;
+exports.openDatabase = require_email_search.openDatabase;
+exports.openEncryptionKeystore = require_emailEncryptionKey.openEncryptionKeystore;
+exports.openRecoveryKeystore = require_emailEncryptionKey.openRecoveryKeystore;
+exports.publicKeyToBase64 = require_genID.publicKeyToBase64;
+exports.removeEmailFromSearchIndex = require_email_search.removeEmailFromSearchIndex;
+exports.searchEmails = require_email_search.searchEmails;
+exports.uint8ArrayToBase64 = require_genID.uint8ArrayToBase64;
+exports.uint8ArrayToHex = require_genID.uint8ArrayToHex;
+exports.uint8ToUTF8 = require_genID.uint8ToUTF8;
+exports.unwrapKey = require_emailKeys.unwrapKey;
+exports.uuidToBytes = require_genID.uuidToBytes;
+exports.verifyKeyFromPasswordHex = require_deriveKeysFromPassword.verifyKeyFromPasswordHex;
+exports.wrapKey = require_emailKeys.wrapKey;

package/dist/index.mjs

@@ -1,15 +1,13 @@
-import { C as KYBER512_PUBLIC_KEY_LENGTH, D as KYBER_SEED_LENGTH, E as KYBER768_SECRET_KEY_LENGTH, O as MAX_CACHE_SIZE, S as KYBER1024_SECRET_KEY_LENGTH, T as KYBER768_PUBLIC_KEY_LENGTH, _ as HASH_BIT_LEN, a as ARGON2ID_OUTPUT_BYTE_LENGTH, b as KEY_WRAPPING_ALGORITHM, c as AUX_BYTE_LEN, d as CONTEXT_INDEX, f as CONTEXT_RECOVERY, g as ECC_ALGORITHM, h as DB_VERSION, i as ARGON2ID_MEMORY_SIZE, k as MAX_EMAIL_PER_BATCH, l as CONTEXT_DERIVE, m as DB_LABEL, n as AES_KEY_BIT_LENGTH, o as ARGON2ID_PARALLELISM, p as CONTEXT_WRAPPING, r as ARGON2ID_ITERATIONS, s as ARGON2ID_SALT_BYTE_LENGTH, t as AES_ALGORITHM, u as CONTEXT_ENC_KEYSTORE, v as IV_LEN_BYTES, w as KYBER512_SECRET_KEY_LENGTH, x as KYBER1024_PUBLIC_KEY_LENGTH, y as KEY_FORMAT } from "./constants-kTeX-2T0.mjs";
-import { t as asymmetric_crypto_exports } from "./asymmetric-crypto-CyXsV4XT.mjs";
-import { t as utils_exports } from "./utils-DS04iUcX.mjs";
-import { t as hash_exports } from "./hash-CXeGAwai.mjs";
-import { t as symmetric_crypto_exports } from "./symmetric-crypto-CrdS1Che.mjs";
-import { t as derive_key_exports } from "./derive-key-Be7hS-cN.mjs";
-import { t as post_quantum_crypto_exports } from "./post-quantum-crypto-Vv34t6gX.mjs";
-import { m as key_wrapper_exports, t as email_crypto_exports } from "./email-crypto-DJUEjTxA.mjs";
-import { t as email_search_exports } from "./email-search.mjs";
-import { t as KeystoreType } from "./types-BiEoleqw.mjs";
-import { t as keystore_crypto_exports } from "./keystore-crypto-Bjgriq9h.mjs";
-import { t as keystore_service_exports } from "./keystore-service.mjs";
-import { t as storage_service_exports } from "./storage-service-CubCbhY2.mjs";
+import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, HASH_BIT_LEN, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH } from "./constants.mjs";
+import { a as importPublicKey, i as importPrivateKey, n as exportPublicKey, o as deriveSecretKey, r as generateEccKeys, t as exportPrivateKey } from "./keys-BfcaiAOv.mjs";
+import { a as genMnemonic, c as publicKeyToBase64, d as hexToUint8Array, f as uint8ArrayToBase64, i as bytesToMnemonic, l as UTF8ToUint8, m as uint8ToUTF8, n as generateUuid, o as mnemonicToBytes, p as uint8ArrayToHex, r as uuidToBytes, s as base64ToPublicKey, t as bytesToUuid, u as base64ToUint8Array } from "./genID-3Er5IowC.mjs";
+import { a as getBytesFromDataHex, c as hashDataArrayWithKey, i as getBytesFromDataArrayHex, l as hashDataArrayWithKeyHex, n as getBytesFromData, o as hashDataArray, s as hashDataArrayHex, t as computeMac } from "./mac-ZpRlx8Fs.mjs";
+import { a as genSymmetricCryptoKey, i as exportSymmetricCryptoKey, n as encryptSymmetrically, o as genSymmetricKey, r as deriveSymmetricCryptoKey, s as importSymmetricCryptoKey, t as decryptSymmetrically } from "./aes-DSDxP8uF.mjs";
+import { a as verifyKeyFromPasswordHex, c as deriveSymmetricKeyFromContext, i as getKeyFromPasswordHex, l as deriveSymmetricKeyFromTwoKeys, n as getKeyFromPasswordAndSalt, o as deriveSymmetricCryptoKeyFromContext, r as getKeyFromPasswordAndSaltHex, s as deriveSymmetricCryptoKeyFromTwoKeys, t as getKeyFromPassword, u as deriveSymmetricKeyFromTwoKeysAndContext } from "./deriveKeysFromPassword-DJRWZ8Rw.mjs";
+import { a as generateKyberKeys, i as encapsulateKyber, r as decapsulateKyber } from "./kyber1024-PpwE1rki.mjs";
+import { a as encryptEmailHybrid, i as decryptEmailHybrid, m as wrapKey, n as createPwdProtectedEmail, o as encryptEmailHybridForMultipleRecipients, p as unwrapKey, r as decryptPwdProtectedEmail, t as generateEmailKeys } from "./emailKeys-Fp9WR3wl.mjs";
+import { addEmailToCache, addEmailToSearchIndex, addEmailsToCache, buildSearchIndexFromCache, closeDatabase, createCacheFromDB, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, encryptAndStoreEmail, encryptAndStoreManyEmail, enforceMaxEmailNumber, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getEmailBatch, getEmailCount, getEmailFromCache, openDatabase, removeEmailFromSearchIndex, searchEmails } from "./email-search.mjs";
+import { KeystoreType } from "./types.mjs";
+import { n as openEncryptionKeystore, r as openRecoveryKeystore, t as createEncryptionAndRecoveryKeystores } from "./emailEncryptionKey-27mIHh18.mjs";
 
-export { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, HASH_BIT_LEN, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, asymmetric_crypto_exports as asymmetric, derive_key_exports as deriveKey, email_crypto_exports as emailCrypto, email_search_exports as emailSearch, hash_exports as hash, key_wrapper_exports as keyWrapper, keystore_crypto_exports as keystoreCrypto, keystore_service_exports as keystoreService, post_quantum_crypto_exports as pq, storage_service_exports as storage, symmetric_crypto_exports as symmetric, utils_exports as utils };
+export { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, HASH_BIT_LEN, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, UTF8ToUint8, addEmailToCache, addEmailToSearchIndex, addEmailsToCache, base64ToPublicKey, base64ToUint8Array, buildSearchIndexFromCache, bytesToMnemonic, bytesToUuid, closeDatabase, computeMac, createCacheFromDB, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, deriveSecretKey, deriveSymmetricCryptoKey, deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, encapsulateKyber, encryptAndStoreEmail, encryptAndStoreManyEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, enforceMaxEmailNumber, exportPrivateKey, exportPublicKey, exportSymmetricCryptoKey, genMnemonic, genSymmetricCryptoKey, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getBytesFromData, getBytesFromDataArrayHex, getBytesFromDataHex, getEmailBatch, getEmailCount, getEmailFromCache, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex, hexToUint8Array, importPrivateKey, importPublicKey, importSymmetricCryptoKey, mnemonicToBytes, openDatabase, openEncryptionKeystore, openRecoveryKeystore, publicKeyToBase64, removeEmailFromSearchIndex, searchEmails, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, verifyKeyFromPasswordHex, wrapKey };

package/dist/{asymmetric-crypto-CyXsV4XT.mjs → keys-BfcaiAOv.mjs}

@@ -1,5 +1,4 @@
-import { t as __exportAll } from "./chunk-DWirmd9C.mjs";
-import { g as ECC_ALGORITHM, n as AES_KEY_BIT_LENGTH } from "./constants-kTeX-2T0.mjs";
+import { AES_KEY_BIT_LENGTH, ECC_ALGORITHM } from "./constants.mjs";
 
 //#region src/asymmetric-crypto/ellipticCurve.ts
 /**
@@ -87,16 +86,5 @@ async function importPrivateKey(pkcs8KeyData) {
 }
 
 //#endregion
-//#region src/asymmetric-crypto/index.ts
-var asymmetric_crypto_exports = /* @__PURE__ */ __exportAll({
-	deriveSecretKey: () => deriveSecretKey,
-	exportPrivateKey: () => exportPrivateKey,
-	exportPublicKey: () => exportPublicKey,
-	generateEccKeys: () => generateEccKeys,
-	importPrivateKey: () => importPrivateKey,
-	importPublicKey: () => importPublicKey
-});
-
-//#endregion
-export { importPrivateKey as a, generateEccKeys as i, exportPrivateKey as n, importPublicKey as o, exportPublicKey as r, deriveSecretKey as s, asymmetric_crypto_exports as t };
-//# sourceMappingURL=asymmetric-crypto-CyXsV4XT.mjs.map
+export { importPublicKey as a, importPrivateKey as i, exportPublicKey as n, deriveSecretKey as o, generateEccKeys as r, exportPrivateKey as t };
+//# sourceMappingURL=keys-BfcaiAOv.mjs.map

package/dist/keys-BfcaiAOv.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys-BfcaiAOv.mjs","names":[],"sources":["../src/asymmetric-crypto/ellipticCurve.ts","../src/asymmetric-crypto/keys.ts"],"sourcesContent":["import { ECC_ALGORITHM, AES_KEY_BIT_LENGTH } from '../constants';\n\n/**\n * Derives secret key from the other user's public key and own private key\n *\n * @param otherUserPublicKey - The public key of the other user\n * @param ownPrivateKey - The private key\n * @returns The derived secret key bits\n */\nexport async function deriveSecretKey(otherUserPublicKey: CryptoKey, ownPrivateKey: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.deriveBits(\n      {\n        name: ECC_ALGORITHM,\n        public: otherUserPublicKey,\n      },\n      ownPrivateKey,\n      AES_KEY_BIT_LENGTH,\n    );\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to derive elliptic curve secret key', { cause: error });\n  }\n}\n","import { ECC_ALGORITHM } from '../constants';\n\n/**\n * Generates elliptic curve key pair\n *\n * @returns The generated key pair\n */\nexport async function generateEccKeys(): Promise<CryptoKeyPair> {\n  try {\n    return (await crypto.subtle.generateKey(\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      ['deriveBits'],\n    )) as CryptoKeyPair;\n  } catch (error) {\n    throw new Error('Failed to generate elliptic curve key pair', { cause: error });\n  }\n}\n\n/**\n * Converts public CryptoKey into Uint8Array using SubjectPublicKeyInfo format (RFC 5280)\n *\n * @returns The Uint8Array representation of the public key\n */\nexport async function exportPublicKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.exportKey('spki', key);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to export public key', { cause: error });\n  }\n}\n\n/**\n * Converts public key in SubjectPublicKeyInfo format (RFC 5280) to CryptoKey\n *\n * @returns The CryptoKey representation of the public key\n */\nexport async function importPublicKey(spkiKeyData: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(\n      'spki',\n      spkiKeyData as BufferSource,\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      [],\n    );\n  } catch (error) {\n    throw new Error('Failed to import public key', { cause: error });\n  }\n}\n\n/**\n * Converts private key in CryptoKey to PKCS #8 format (RFC 5208)\n *\n * @returns The Uint8Array representation of the private key\n */\nexport async function exportPrivateKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.exportKey('pkcs8', key);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to export private key', { cause: error });\n  }\n}\n\n/**\n * Converts private key in PKCS #8 format (RFC 5208) to CryptoKey\n *\n * @returns The CryptoKey representation of the private key\n */\nexport async function importPrivateKey(pkcs8KeyData: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(\n      'pkcs8',\n      pkcs8KeyData as BufferSource,\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      ['deriveBits'],\n    );\n  } catch (error) {\n    throw new Error('Failed to import private key', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;AASA,eAAsB,gBAAgB,oBAA+B,eAA+C;AAClH,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,WACjC;GACE,MAAM;GACN,QAAQ;GACT,EACD,eACA,mBACD;AACD,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;ACdnF,eAAsB,kBAA0C;AAC9D,KAAI;AACF,SAAQ,MAAM,OAAO,OAAO,YAC1B,EACE,MAAM,eACP,EACD,MACA,CAAC,aAAa,CACf;UACM,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASnF,eAAsB,gBAAgB,KAAqC;AACzE,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,QAAQ,IAAI;AACzD,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,+BAA+B,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASpE,eAAsB,gBAAgB,aAA6C;AACjF,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,QACA,aACA,EACE,MAAM,eACP,EACD,MACA,EAAE,CACH;UACM,OAAO;AACd,QAAM,IAAI,MAAM,+BAA+B,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASpE,eAAsB,iBAAiB,KAAqC;AAC1E,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,SAAS,IAAI;AAC1D,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASrE,eAAsB,iBAAiB,cAA8C;AACnF,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,SACA,cACA,EACE,MAAM,eACP,EACD,MACA,CAAC,aAAa,CACf;UACM,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC"}

package/dist/{asymmetric-crypto-BORmLhnx.js → keys-CinT7kEY.js}

@@ -1,5 +1,4 @@
-const require_chunk = require('./chunk-Dt-PWiN7.js');
-const require_constants = require('./constants-Ccp21E03.js');
+const require_constants = require('./constants.js');
 
 //#region src/asymmetric-crypto/ellipticCurve.ts
 /**
@@ -87,23 +86,6 @@ async function importPrivateKey(pkcs8KeyData) {
 }
 
 //#endregion
-//#region src/asymmetric-crypto/index.ts
-var asymmetric_crypto_exports = /* @__PURE__ */ require_chunk.__exportAll({
-	deriveSecretKey: () => deriveSecretKey,
-	exportPrivateKey: () => exportPrivateKey,
-	exportPublicKey: () => exportPublicKey,
-	generateEccKeys: () => generateEccKeys,
-	importPrivateKey: () => importPrivateKey,
-	importPublicKey: () => importPublicKey
-});
-
-//#endregion
-Object.defineProperty(exports, 'asymmetric_crypto_exports', {
-  enumerable: true,
-  get: function () {
-    return asymmetric_crypto_exports;
-  }
-});
 Object.defineProperty(exports, 'deriveSecretKey', {
   enumerable: true,
   get: function () {
@@ -140,4 +122,4 @@ Object.defineProperty(exports, 'importPublicKey', {
     return importPublicKey;
   }
 });
-//# sourceMappingURL=asymmetric-crypto-BORmLhnx.js.map
+//# sourceMappingURL=keys-CinT7kEY.js.map

package/dist/keys-CinT7kEY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys-CinT7kEY.js","names":["ECC_ALGORITHM","AES_KEY_BIT_LENGTH","ECC_ALGORITHM"],"sources":["../src/asymmetric-crypto/ellipticCurve.ts","../src/asymmetric-crypto/keys.ts"],"sourcesContent":["import { ECC_ALGORITHM, AES_KEY_BIT_LENGTH } from '../constants';\n\n/**\n * Derives secret key from the other user's public key and own private key\n *\n * @param otherUserPublicKey - The public key of the other user\n * @param ownPrivateKey - The private key\n * @returns The derived secret key bits\n */\nexport async function deriveSecretKey(otherUserPublicKey: CryptoKey, ownPrivateKey: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.deriveBits(\n      {\n        name: ECC_ALGORITHM,\n        public: otherUserPublicKey,\n      },\n      ownPrivateKey,\n      AES_KEY_BIT_LENGTH,\n    );\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to derive elliptic curve secret key', { cause: error });\n  }\n}\n","import { ECC_ALGORITHM } from '../constants';\n\n/**\n * Generates elliptic curve key pair\n *\n * @returns The generated key pair\n */\nexport async function generateEccKeys(): Promise<CryptoKeyPair> {\n  try {\n    return (await crypto.subtle.generateKey(\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      ['deriveBits'],\n    )) as CryptoKeyPair;\n  } catch (error) {\n    throw new Error('Failed to generate elliptic curve key pair', { cause: error });\n  }\n}\n\n/**\n * Converts public CryptoKey into Uint8Array using SubjectPublicKeyInfo format (RFC 5280)\n *\n * @returns The Uint8Array representation of the public key\n */\nexport async function exportPublicKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.exportKey('spki', key);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to export public key', { cause: error });\n  }\n}\n\n/**\n * Converts public key in SubjectPublicKeyInfo format (RFC 5280) to CryptoKey\n *\n * @returns The CryptoKey representation of the public key\n */\nexport async function importPublicKey(spkiKeyData: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(\n      'spki',\n      spkiKeyData as BufferSource,\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      [],\n    );\n  } catch (error) {\n    throw new Error('Failed to import public key', { cause: error });\n  }\n}\n\n/**\n * Converts private key in CryptoKey to PKCS #8 format (RFC 5208)\n *\n * @returns The Uint8Array representation of the private key\n */\nexport async function exportPrivateKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.exportKey('pkcs8', key);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to export private key', { cause: error });\n  }\n}\n\n/**\n * Converts private key in PKCS #8 format (RFC 5208) to CryptoKey\n *\n * @returns The CryptoKey representation of the private key\n */\nexport async function importPrivateKey(pkcs8KeyData: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(\n      'pkcs8',\n      pkcs8KeyData as BufferSource,\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      ['deriveBits'],\n    );\n  } catch (error) {\n    throw new Error('Failed to import private key', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;AASA,eAAsB,gBAAgB,oBAA+B,eAA+C;AAClH,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,WACjC;GACE,MAAMA;GACN,QAAQ;GACT,EACD,eACAC,qCACD;AACD,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;ACdnF,eAAsB,kBAA0C;AAC9D,KAAI;AACF,SAAQ,MAAM,OAAO,OAAO,YAC1B,EACE,MAAMC,iCACP,EACD,MACA,CAAC,aAAa,CACf;UACM,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASnF,eAAsB,gBAAgB,KAAqC;AACzE,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,QAAQ,IAAI;AACzD,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,+BAA+B,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASpE,eAAsB,gBAAgB,aAA6C;AACjF,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,QACA,aACA,EACE,MAAMA,iCACP,EACD,MACA,EAAE,CACH;UACM,OAAO;AACd,QAAM,IAAI,MAAM,+BAA+B,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASpE,eAAsB,iBAAiB,KAAqC;AAC1E,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,SAAS,IAAI;AAC1D,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASrE,eAAsB,iBAAiB,cAA8C;AACnF,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,SACA,cACA,EACE,MAAMA,iCACP,EACD,MACA,CAAC,aAAa,CACf;UACM,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC"}

package/dist/keystore-crypto.d.mts

@@ -1,4 +1,4 @@
-import { c as EncryptedKeystore, i as EmailKeys } from "./types-DwQJtrTx.mjs";
+import { EmailKeys, EncryptedKeystore } from "./types.mjs";
 
 //#region src/keystore-crypto/emailEncryptionKey.d.ts
 /**
@@ -32,9 +32,6 @@ declare function openEncryptionKeystore(encryptedKeystore: EncryptedKeystore, ba
  * @returns The encryption keys
  */
 declare function openRecoveryKeystore(recoveryCodes: string, encryptedKeystore: EncryptedKeystore): Promise<EmailKeys>;
-declare namespace index_d_exports {
-  export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };
-}
 //#endregion
-export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore, index_d_exports as t };
+export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };
 //# sourceMappingURL=keystore-crypto.d.mts.map

package/dist/keystore-crypto.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keystore-crypto.d.mts","names":[],"sources":["../src/keystore-crypto/emailEncryptionKey.ts"],"mappings":";;;;;AAYA;;;;;iBAAsB,oCAAA,CACpB,SAAA,UACA,OAAA,EAAS,UAAA,GACR,OAAA;EACD,kBAAA,EAAoB,iBAAA;EACpB,gBAAA,EAAkB,iBAAA;EAClB,aAAA;EACA,IAAA,EAAM,SAAA;AAAA;;;;;;;;;iBA0Bc,sBAAA,CACpB,iBAAA,EAAmB,iBAAA,EACnB,OAAA,EAAS,UAAA,GACR,OAAA,CAAQ,SAAA;;;;AAHX;;;;;iBAwBsB,oBAAA,CACpB,aAAA,UACA,iBAAA,EAAmB,iBAAA,GAClB,OAAA,CAAQ,SAAA"}

package/dist/keystore-crypto.d.ts

@@ -1,4 +1,4 @@
-import { c as EncryptedKeystore, i as EmailKeys } from "./types-Ds3ivE9W.js";
+import { EmailKeys, EncryptedKeystore } from "./types.js";
 
 //#region src/keystore-crypto/emailEncryptionKey.d.ts
 /**
@@ -32,9 +32,6 @@ declare function openEncryptionKeystore(encryptedKeystore: EncryptedKeystore, ba
  * @returns The encryption keys
  */
 declare function openRecoveryKeystore(recoveryCodes: string, encryptedKeystore: EncryptedKeystore): Promise<EmailKeys>;
-declare namespace index_d_exports {
-  export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };
-}
 //#endregion
-export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore, index_d_exports as t };
+export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };
 //# sourceMappingURL=keystore-crypto.d.ts.map

package/dist/keystore-crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keystore-crypto.d.ts","names":[],"sources":["../src/keystore-crypto/emailEncryptionKey.ts"],"mappings":";;;;;AAYA;;;;;iBAAsB,oCAAA,CACpB,SAAA,UACA,OAAA,EAAS,UAAA,GACR,OAAA;EACD,kBAAA,EAAoB,iBAAA;EACpB,gBAAA,EAAkB,iBAAA;EAClB,aAAA;EACA,IAAA,EAAM,SAAA;AAAA;;;;;;;;;iBA0Bc,sBAAA,CACpB,iBAAA,EAAmB,iBAAA,EACnB,OAAA,EAAS,UAAA,GACR,OAAA,CAAQ,SAAA;;;;AAHX;;;;;iBAwBsB,oBAAA,CACpB,aAAA,UACA,iBAAA,EAAmB,iBAAA,GAClB,OAAA,CAAQ,SAAA"}