favalib 0.0.12 → 0.0.14

package/build/TwoFALibError.d.mts

@@ -14,7 +14,7 @@ export declare class TwoFALibError extends Error {
 export declare class InitializationError extends TwoFALibError {
 }
 /**
- * Error thrown during authentication, e.g. wrong passphrase for locked vault.
+ * Error thrown during authentication, e.g. wrong password for locked vault.
  */
 export declare class AuthenticationError extends TwoFALibError {
 }

package/build/TwoFALibError.mjs

@@ -18,7 +18,7 @@ export class TwoFALibError extends Error {
 export class InitializationError extends TwoFALibError {
 }
 /**
- * Error thrown during authentication, e.g. wrong passphrase for locked vault.
+ * Error thrown during authentication, e.g. wrong password for locked vault.
  */
 export class AuthenticationError extends TwoFALibError {
 }

package/build/TwoFaLib.d.mts

@@ -3,7 +3,7 @@ import type { PlatformProviders } from './interfaces/PlatformProviders.mjs';
 import type { EncryptedPrivateKey, EncryptedSymmetricKey, PrivateKey, PublicKey, Salt, SymmetricKey } from './interfaces/CryptoLib.mjs';
 import type { DeviceFriendlyName, DeviceType } from './interfaces/SyncTypes.mjs';
 import type { TwoFaLibEventMapEvents } from './interfaces/Events.mjs';
-import type { PassphraseExtraDict } from './interfaces/PassphraseExtraDict.js';
+import type { PasswordExtraDict } from './interfaces/PasswordExtraDict.js';
 import type { Vault, VaultSyncState } from './interfaces/Vault.mjs';
 import type { SaveFunction } from './interfaces/SaveFunction.mjs';
 import type { FavaMeta } from './interfaces/FavaMeta.mjs';
@@ -35,7 +35,7 @@ declare class TwoFaLib extends TypedEventTarget<TwoFaLibEventMapEvents> {
      * Constructs a new instance of TwoFaLib. If a serverUrl is provided, the library will use it for its sync operations.
      * @param deviceType - The identifier for this device type (e.g. 2fa-cli).
      * @param platformProviders - The platform-specific providers containing CryptoLib and other providers.
-     * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+     * @param passwordExtraDict - Additional words to be used for password strength evaluation.
      * @param privateKey - The private key used for cryptographic operations.
      * @param symmetricKey - The symmetric key used for cryptographic operations.
      * @param encryptedPrivateKey - The encrypted private key
@@ -48,9 +48,9 @@ declare class TwoFaLib extends TypedEventTarget<TwoFaLibEventMapEvents> {
      * @param syncState - The state of the sync, includes the serverUrl
      * @returns A promise that resolves when initialization is complete.
      * @throws {InitializationError} If some parameter has an invalid value
-     * @throws {AuthenticationError} If the provided passphrase is incorrect.
+     * @throws {AuthenticationError} If the provided password is incorrect.
      */
-    constructor(deviceType: DeviceType, platformProviders: PlatformProviders, passphraseExtraDict: PassphraseExtraDict, privateKey: PrivateKey, symmetricKey: SymmetricKey, encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, publicKey: PublicKey, favaMeta: FavaMeta, vault?: Vault, saveFunction?: SaveFunction, syncState?: VaultSyncState);
+    constructor(deviceType: DeviceType, platformProviders: PlatformProviders, passwordExtraDict: PasswordExtraDict, privateKey: PrivateKey, symmetricKey: SymmetricKey, encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, publicKey: PublicKey, favaMeta: FavaMeta, vault?: Vault, saveFunction?: SaveFunction, syncState?: VaultSyncState);
     /**
      * @returns The persistent storage manager instance which can be used to store data.
      */

package/build/TwoFaLib.mjs

@@ -31,7 +31,7 @@ class TwoFaLib extends TypedEventTarget {
      * Constructs a new instance of TwoFaLib. If a serverUrl is provided, the library will use it for its sync operations.
      * @param deviceType - The identifier for this device type (e.g. 2fa-cli).
      * @param platformProviders - The platform-specific providers containing CryptoLib and other providers.
-     * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+     * @param passwordExtraDict - Additional words to be used for password strength evaluation.
      * @param privateKey - The private key used for cryptographic operations.
      * @param symmetricKey - The symmetric key used for cryptographic operations.
      * @param encryptedPrivateKey - The encrypted private key
@@ -44,9 +44,9 @@ class TwoFaLib extends TypedEventTarget {
      * @param syncState - The state of the sync, includes the serverUrl
      * @returns A promise that resolves when initialization is complete.
      * @throws {InitializationError} If some parameter has an invalid value
-     * @throws {AuthenticationError} If the provided passphrase is incorrect.
+     * @throws {AuthenticationError} If the provided password is incorrect.
      */
-    constructor(deviceType, platformProviders, passphraseExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, favaMeta, vault, saveFunction, syncState) {
+    constructor(deviceType, platformProviders, passwordExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, favaMeta, vault, saveFunction, syncState) {
         super();
         if (!deviceType) {
             throw new InitializationError('Device type is required');
@@ -61,8 +61,8 @@ class TwoFaLib extends TypedEventTarget {
             favaMeta.deviceFriendlyName.length > 256) {
             throw new InitializationError('Device friendly name is too long, max 256 characters');
         }
-        if (passphraseExtraDict?.length === 0) {
-            throw new InitializationError('Passphrase extra dictionary is required and must contain at least one element (eg phone)');
+        if (passwordExtraDict?.length === 0) {
+            throw new InitializationError('Password extra dictionary is required and must contain at least one element (eg phone)');
         }
         this.favaMeta = favaMeta;
         this.deviceType = deviceType;
@@ -73,7 +73,7 @@ class TwoFaLib extends TypedEventTarget {
             ['libraryLoader', new LibraryLoader(platformProviders)],
             [
                 'persistentStorageManager',
-                new PersistentStorageManager(this.mediator, passphraseExtraDict, favaMeta, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, saveFunction),
+                new PersistentStorageManager(this.mediator, passwordExtraDict, favaMeta, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, saveFunction),
             ],
             ['vaultDataManager', new VaultDataManager(this.mediator)],
             ['commandManager', new CommandManager(this.mediator)],
@@ -81,7 +81,7 @@ class TwoFaLib extends TypedEventTarget {
             ['storageOperationsManager', new StorageOperationsManager(this.mediator)],
             [
                 'exportImportManager',
-                new ExportImportManager(this.mediator, passphraseExtraDict),
+                new ExportImportManager(this.mediator, passwordExtraDict),
             ],
             ['dispatchLibEvent', this.dispatchLibEvent.bind(this)],
             ['log', this.log.bind(this)],

package/build/interfaces/CryptoLib.d.mts

@@ -1,9 +1,9 @@
 import type { Tagged } from 'type-fest';
 export type Encrypted<T extends string> = Tagged<T, 'Encrypted'>;
-/** Represents a passphrase  */
-export type Passphrase = Tagged<string, 'Passphrase'>;
-/** Represents a passphraseHash  */
-export type PassphraseHash = Tagged<string, 'PassphraseHash'>;
+/** Represents a password  */
+export type Password = Tagged<string, 'Password'>;
+/** Represents a passwordHash  */
+export type PasswordHash = Tagged<string, 'PasswordHash'>;
 /** Represents a salt (base64 encoded) */
 export type Salt = Tagged<string, 'Salt'>;
 /** Represents a private key */
@@ -33,12 +33,12 @@ interface CryptoLib {
     getRandomBytes: (count: number) => Promise<Uint8Array>;
     /**
      * Creates the keys required for further operations.
-     * It first creates a public/private key pair, with the private key being encrypted using the passphrase.
+     * It first creates a public/private key pair, with the private key being encrypted using the password.
      * It then generates a symmetricKey. It will then encrypt this symmetricKey using the generated public key.
-     * @param passphrase - The passphrase to encrypt the private key with
+     * @param password - The password to encrypt the private key with
      * @returns A promise that resolves to an object containing the encrypted private key, encrypted symmetric key and public key
      */
-    createKeys: (passphrase: Passphrase) => Promise<{
+    createKeys: (password: Password) => Promise<{
         privateKey: PrivateKey;
         symmetricKey: SymmetricKey;
         encryptedPrivateKey: EncryptedPrivateKey;
@@ -50,10 +50,10 @@ interface CryptoLib {
      * Decrypts the keys required for further operations
      * @param encryptedPrivateKey - The encrypted private key
      * @param encryptedSymmetricKey - The encrypted symmetric key
-     * @param passphrase - The passphrase to decrypt the private key with
+     * @param password - The password to decrypt the private key with
      * @returns A promise that resolves to an object containing the decrypted private, symmetric and public key
      */
-    decryptKeys: (encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, passphrase: Passphrase) => Promise<{
+    decryptKeys: (encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, password: Password) => Promise<{
         privateKey: PrivateKey;
         symmetricKey: SymmetricKey;
         publicKey: PublicKey;
@@ -62,10 +62,10 @@ interface CryptoLib {
      * Encrypts the keys required for further operation
      * @param privateKey - The private key to encrypt
      * @param symmetricKey - The symmetric key to encrypt
-     * @param passphrase - The passphrase to encrypt the private key with
+     * @param password - The password to encrypt the private key with
      * @returns A promise that resolves to an object containing the encrypted private and symmetricKey key
      */
-    encryptKeys: (privateKey: PrivateKey, symmetricKey: SymmetricKey, salt: Salt, passphrase: Passphrase) => Promise<{
+    encryptKeys: (privateKey: PrivateKey, symmetricKey: SymmetricKey, salt: Salt, password: Password) => Promise<{
         encryptedPrivateKey: EncryptedPrivateKey;
         encryptedSymmetricKey: EncryptedSymmetricKey;
     }>;

package/build/interfaces/PasswordExtraDict.d.ts

@@ -0,0 +1,2 @@
+import type { NonEmptyTuple } from 'type-fest';
+export type PasswordExtraDict = NonEmptyTuple<string>;

package/build/main.d.mts

@@ -2,7 +2,7 @@ import TwoFaLib from './TwoFaLib.mjs';
 import type Entry from './interfaces/Entry.mjs';
 import type { EntryId, NewEntry, EntryMeta, EntryType, TotpPayload, Token, EntryMetaWithToken } from './interfaces/Entry.mjs';
 import type CryptoLib from './interfaces/CryptoLib.mjs';
-import type { Encrypted, EncryptedPrivateKey, EncryptedSymmetricKey, EncryptedPublicKey, PrivateKey, SymmetricKey, PublicKey, Passphrase, Salt } from './interfaces/CryptoLib.mjs';
+import type { Encrypted, EncryptedPrivateKey, EncryptedSymmetricKey, EncryptedPublicKey, PrivateKey, SymmetricKey, PublicKey, Password, Salt } from './interfaces/CryptoLib.mjs';
 import type { PublicSyncDevice, DeviceId, DeviceType, DeviceFriendlyName, DeviceInfo } from './interfaces/SyncTypes.mjs';
 import type { EncryptedVaultStateString, LockedRepresentationString } from './interfaces/Vault.mjs';
 import type { SaveFunction } from './interfaces/SaveFunction.mjs';
@@ -11,4 +11,4 @@ import { TwoFALibError, InitializationError, AuthenticationError, EntryNotFoundE
 import { TwoFaLibEvent } from './TwoFaLibEvent.mjs';
 import { getTwoFaLibVaultCreationUtils } from './utils/creationUtils.mjs';
 export { TwoFaLib, TwoFALibError, getTwoFaLibVaultCreationUtils, InitializationError, AuthenticationError, EntryNotFoundError, TokenGenerationError, TwoFaLibEvent, };
-export type { Entry, EntryId, NewEntry, EntryMeta, EntryMetaWithToken, EntryType, TotpPayload, Token, EncryptedVaultStateString, LockedRepresentationString, CryptoLib, Encrypted, EncryptedPrivateKey, EncryptedPublicKey, EncryptedSymmetricKey, PrivateKey, SymmetricKey, PublicKey, Passphrase, Salt, DeviceId, DeviceType, DeviceFriendlyName, DeviceInfo, PublicSyncDevice, SaveFunction, PlatformProviders, };
+export type { Entry, EntryId, NewEntry, EntryMeta, EntryMetaWithToken, EntryType, TotpPayload, Token, EncryptedVaultStateString, LockedRepresentationString, CryptoLib, Encrypted, EncryptedPrivateKey, EncryptedPublicKey, EncryptedSymmetricKey, PrivateKey, SymmetricKey, PublicKey, Password, Salt, DeviceId, DeviceType, DeviceFriendlyName, DeviceInfo, PublicSyncDevice, SaveFunction, PlatformProviders, };

package/build/platformProviders/browser/cryptoLib.d.mts

@@ -1,12 +1,12 @@
 import type CryptoLib from '../../interfaces/CryptoLib.mjs';
-import type { Encrypted, EncryptedPrivateKey, EncryptedSymmetricKey, Passphrase, PassphraseHash, PrivateKey, PublicKey, Salt, SymmetricKey, SyncKey } from '../../interfaces/CryptoLib.mjs';
+import type { Encrypted, EncryptedPrivateKey, EncryptedSymmetricKey, Password, PasswordHash, PrivateKey, PublicKey, Salt, SymmetricKey, SyncKey } from '../../interfaces/CryptoLib.mjs';
 /**
  * Create a password hash
  * @param salt - The salt to use
- * @param passphrase - The passphrase to hash
+ * @param password - The password to hash
  * @returns The calculated password hash
  */
-export declare const generatePassphraseHash: (salt: Salt, passphrase: string) => Promise<PassphraseHash>;
+export declare const generatePasswordHash: (salt: Salt, password: string) => Promise<PasswordHash>;
 /**
  * @inheritdoc
  */
@@ -18,7 +18,7 @@ declare class BrowserCryptoLib implements CryptoLib {
     /**
      * @inheritdoc
      */
-    createKeys(passphrase: Passphrase): Promise<{
+    createKeys(password: Password): Promise<{
         privateKey: PrivateKey;
         symmetricKey: SymmetricKey;
         encryptedPrivateKey: EncryptedPrivateKey;
@@ -29,14 +29,14 @@ declare class BrowserCryptoLib implements CryptoLib {
     /**
      * @inheritdoc
      */
-    encryptKeys(privateKey: PrivateKey, symmetricKey: SymmetricKey, salt: Salt, passphrase: Passphrase): Promise<{
+    encryptKeys(privateKey: PrivateKey, symmetricKey: SymmetricKey, salt: Salt, password: Password): Promise<{
         encryptedPrivateKey: EncryptedPrivateKey;
         encryptedSymmetricKey: EncryptedSymmetricKey;
     }>;
     /**
      * @inheritdoc
      */
-    decryptKeys(encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, passphrase: Passphrase): Promise<{
+    decryptKeys(encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, password: Password): Promise<{
         privateKey: PrivateKey;
         publicKey: PublicKey;
         symmetricKey: SymmetricKey;

package/build/platformProviders/browser/cryptoLib.mjs

@@ -14,12 +14,12 @@ const normalizeLineEndings = (str) => {
 /**
  * Create a password hash
  * @param salt - The salt to use
- * @param passphrase - The passphrase to hash
+ * @param password - The password to hash
  * @returns The calculated password hash
  */
-export const generatePassphraseHash = (salt, passphrase) => {
+export const generatePasswordHash = (salt, password) => {
     return argon2id({
-        password: passphrase,
+        password,
         salt,
         parallelism: 1,
         iterations: 256,
@@ -41,12 +41,12 @@ class BrowserCryptoLib {
     /**
      * @inheritdoc
      */
-    async createKeys(passphrase) {
+    async createKeys(password) {
         // create random salt
         const salt = uint8ArrayToBase64(window.crypto.getRandomValues(new Uint8Array(16)));
         // create passwordHash
-        const passphraseHash = await generatePassphraseHash(salt, passphrase);
-        const { privateKey, encryptedPrivateKey, publicKey } = await this.createKeyPair(passphraseHash);
+        const passwordHash = await generatePasswordHash(salt, password);
+        const { privateKey, encryptedPrivateKey, publicKey } = await this.createKeyPair(passwordHash);
         const symmetricKey = await this.createSymmetricKey();
         const encryptedSymmetricKey = await this.encrypt(publicKey, symmetricKey);
         return {
@@ -61,10 +61,10 @@ class BrowserCryptoLib {
     /**
      * @inheritdoc
      */
-    async encryptKeys(privateKey, symmetricKey, salt, passphrase) {
+    async encryptKeys(privateKey, symmetricKey, salt, password) {
         // recreate passwordHash
-        const passphraseHash = await generatePassphraseHash(salt, passphrase);
-        const encryptedPrivateKey = await this.encryptPrivateKey(privateKey, passphraseHash);
+        const passwordHash = await generatePasswordHash(salt, password);
+        const encryptedPrivateKey = await this.encryptPrivateKey(privateKey, passwordHash);
         const publicKey = await this.getPublicKeyFromPrivateKey(privateKey);
         const encryptedSymmetricKey = await this.encrypt(publicKey, symmetricKey);
         return {
@@ -75,10 +75,10 @@ class BrowserCryptoLib {
     /**
      * @inheritdoc
      */
-    async decryptKeys(encryptedPrivateKey, encryptedSymmetricKey, salt, passphrase) {
+    async decryptKeys(encryptedPrivateKey, encryptedSymmetricKey, salt, password) {
         // recreate passwordHash
-        const passphraseHash = await generatePassphraseHash(salt, passphrase);
-        const { privateKey, publicKey } = await this.decryptPrivateKey(encryptedPrivateKey, passphraseHash);
+        const passwordHash = await generatePasswordHash(salt, password);
+        const { privateKey, publicKey } = await this.decryptPrivateKey(encryptedPrivateKey, passwordHash);
         const symmetricKey = (await this.decrypt(privateKey, encryptedSymmetricKey));
         return { privateKey, publicKey, symmetricKey };
     }
@@ -146,18 +146,18 @@ class BrowserCryptoLib {
         });
         return uint8ArrayToBase64(key);
     }
-    async encryptPrivateKey(privateKey, passphraseHash) {
+    async encryptPrivateKey(privateKey, passwordHash) {
         const privateKeyObj = forge.pki.privateKeyFromPem(privateKey);
-        const encryptedPrivateKey = forge.pki.encryptRsaPrivateKey(privateKeyObj, passphraseHash, {
+        const encryptedPrivateKey = forge.pki.encryptRsaPrivateKey(privateKeyObj, passwordHash, {
             algorithm: 'aes256',
         });
         return Promise.resolve(encryptedPrivateKey);
     }
-    async decryptPrivateKey(encryptedPrivateKey, passphraseHash) {
+    async decryptPrivateKey(encryptedPrivateKey, passwordHash) {
         try {
-            const privateKeyPem = forge.pki.decryptRsaPrivateKey(encryptedPrivateKey, passphraseHash);
+            const privateKeyPem = forge.pki.decryptRsaPrivateKey(encryptedPrivateKey, passwordHash);
             if (!privateKeyPem) {
-                throw new CryptoError('Invalid passphrase');
+                throw new CryptoError('Invalid password');
             }
             const privateKey = forge.pki.privateKeyToPem(privateKeyPem);
             const publicKey = forge.pki.publicKeyToPem(forge.pki.setRsaPublicKey(privateKeyPem.n, privateKeyPem.e));
@@ -169,8 +169,8 @@ class BrowserCryptoLib {
         catch (err) {
             // eslint-disable-next-line no-restricted-globals
             if (err instanceof Error) {
-                if (err.message === 'Invalid passphrase') {
-                    throw new CryptoError('Invalid passphrase');
+                if (err.message === 'Invalid password') {
+                    throw new CryptoError('Invalid password');
                 }
                 if (err.message.includes('Unsupported private key')) {
                     throw new CryptoError('Invalid private key');
@@ -179,7 +179,7 @@ class BrowserCryptoLib {
             throw err;
         }
     }
-    async createKeyPair(passphrase) {
+    async createKeyPair(password) {
         return new Promise((resolve, reject) => {
             forge.pki.rsa.generateKeyPair({ bits: 4096 }, (err, keyPair) => {
                 if (err) {
@@ -188,7 +188,7 @@ class BrowserCryptoLib {
                 else {
                     const publicKey = forge.pki.publicKeyToPem(keyPair.publicKey);
                     const privateKey = forge.pki.privateKeyToPem(keyPair.privateKey);
-                    const encryptedPrivateKey = forge.pki.encryptRsaPrivateKey(keyPair.privateKey, passphrase, {
+                    const encryptedPrivateKey = forge.pki.encryptRsaPrivateKey(keyPair.privateKey, password, {
                         algorithm: 'aes256',
                     });
                     resolve({

package/build/platformProviders/node/cryptoLib.d.mts

@@ -1,5 +1,5 @@
 import type CryptoLib from '../../interfaces/CryptoLib.mjs';
-import type { Encrypted, EncryptedPrivateKey, EncryptedSymmetricKey, Passphrase, PrivateKey, PublicKey, Salt, SymmetricKey, SyncKey } from '../../interfaces/CryptoLib.mjs';
+import type { Encrypted, EncryptedPrivateKey, EncryptedSymmetricKey, Password, PrivateKey, PublicKey, Salt, SymmetricKey, SyncKey } from '../../interfaces/CryptoLib.mjs';
 /**
  * @inheritdoc
  */
@@ -11,7 +11,7 @@ declare class NodeCryptoLib implements CryptoLib {
     /**
      * @inheritdoc
      */
-    createKeys(passphrase: Passphrase): Promise<{
+    createKeys(password: Password): Promise<{
         privateKey: PrivateKey;
         symmetricKey: SymmetricKey;
         publicKey: PublicKey;
@@ -22,14 +22,14 @@ declare class NodeCryptoLib implements CryptoLib {
     /**
      * @inheritdoc
      */
-    encryptKeys(privateKey: PrivateKey, symmetricKey: SymmetricKey, salt: Salt, passphrase: Passphrase): Promise<{
+    encryptKeys(privateKey: PrivateKey, symmetricKey: SymmetricKey, salt: Salt, password: Password): Promise<{
         encryptedPrivateKey: EncryptedPrivateKey;
         encryptedSymmetricKey: EncryptedSymmetricKey;
     }>;
     /**
      * @inheritdoc
      */
-    decryptKeys(encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, passphrase: Passphrase): Promise<{
+    decryptKeys(encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, password: Password): Promise<{
         privateKey: PrivateKey;
         publicKey: PublicKey;
         symmetricKey: SymmetricKey;

package/build/platformProviders/node/cryptoLib.mjs

@@ -4,7 +4,7 @@ import { generateKeyPair as generateKeyPairCb, generateKey as generateKeyCb, pub
 import { argon2id } from 'hash-wasm';
 import { toUint8Array } from 'uint8array-extras';
 import { CryptoError } from '../../TwoFALibError.mjs';
-import { generatePassphraseHash } from '../browser/cryptoLib.mjs';
+import { generatePasswordHash } from '../browser/cryptoLib.mjs';
 const generateKeyPair = promisify(generateKeyPairCb);
 const generateKey = promisify(generateKeyCb);
 /**
@@ -20,11 +20,11 @@ class NodeCryptoLib {
     /**
      * @inheritdoc
      */
-    async createKeys(passphrase) {
+    async createKeys(password) {
         // create random salt
         const salt = randomBytes(16).toString('base64');
         // create passwordHash
-        const passphraseHash = await generatePassphraseHash(salt, passphrase);
+        const passwordHash = await generatePasswordHash(salt, password);
         // Generate public/private key pair
         const { publicKey, privateKey: encryptedPrivateKey } = await generateKeyPair('rsa', {
             modulusLength: 4096,
@@ -36,13 +36,13 @@ class NodeCryptoLib {
                 type: 'pkcs8',
                 format: 'pem',
                 cipher: 'aes-256-cbc',
-                passphrase: passphraseHash,
+                passphrase: passwordHash,
             },
         });
         // Create and encrypt symmetric key with public key
         const symmetricKey = await this.createSymmetricKey();
         const encryptedSymmetricKey = await this.encrypt(publicKey, symmetricKey);
-        const { privateKey } = await this.decryptKeys(encryptedPrivateKey, encryptedSymmetricKey, salt, passphrase);
+        const { privateKey } = await this.decryptKeys(encryptedPrivateKey, encryptedSymmetricKey, salt, password);
         return {
             privateKey: privateKey,
             symmetricKey,
@@ -55,9 +55,9 @@ class NodeCryptoLib {
     /**
      * @inheritdoc
      */
-    async encryptKeys(privateKey, symmetricKey, salt, passphrase) {
+    async encryptKeys(privateKey, symmetricKey, salt, password) {
         // recreate passwordHash
-        const passphraseHash = await generatePassphraseHash(salt, passphrase);
+        const passwordHash = await generatePasswordHash(salt, password);
         // Encrypt private key
         const privateKeyObject = createPrivateKey({
             key: privateKey,
@@ -67,7 +67,7 @@ class NodeCryptoLib {
             type: 'pkcs8',
             format: 'pem',
             cipher: 'aes-256-cbc',
-            passphrase: passphraseHash,
+            passphrase: passwordHash,
         });
         // Encrypt symmetric key with public key
         const publicKeyObject = createPublicKey(privateKeyObject);
@@ -84,9 +84,9 @@ class NodeCryptoLib {
     /**
      * @inheritdoc
      */
-    async decryptKeys(encryptedPrivateKey, encryptedSymmetricKey, salt, passphrase) {
+    async decryptKeys(encryptedPrivateKey, encryptedSymmetricKey, salt, password) {
         // recreate passwordHash
-        const passphraseHash = await generatePassphraseHash(salt, passphrase);
+        const passwordHash = await generatePasswordHash(salt, password);
         let privateKeyObject;
         let privateKey;
         try {
@@ -94,7 +94,7 @@ class NodeCryptoLib {
                 key: encryptedPrivateKey,
                 type: 'pkcs8',
                 format: 'pem',
-                passphrase: passphraseHash,
+                passphrase: passwordHash,
             });
             privateKey = privateKeyObject.export({
                 type: 'pkcs8',
@@ -105,7 +105,7 @@ class NodeCryptoLib {
             // eslint-disable-next-line no-restricted-globals
             if (err instanceof Error && 'code' in err) {
                 if (err.code === 'ERR_OSSL_BAD_DECRYPT') {
-                    throw new CryptoError('Invalid passphrase');
+                    throw new CryptoError('Invalid password');
                 }
                 if (err.code === 'ERR_OSSL_UNSUPPORTED') {
                     throw new CryptoError('Invalid private key');

package/build/subclasses/ExportImportManager.d.mts

@@ -1,18 +1,18 @@
 import { EntryId } from '../interfaces/Entry.mjs';
-import type { PassphraseExtraDict } from '../interfaces/PassphraseExtraDict.js';
+import type { PasswordExtraDict } from '../interfaces/PasswordExtraDict.js';
 import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
 /**
  * Manages the export and import of entries in various formats.
  */
 declare class ExportImportManager {
     private readonly mediator;
-    private readonly passphraseExtraDict;
+    private readonly passwordExtraDict;
     /**
      * Constructs a new instance of ExportImportManager.
      * @param mediator - The mediator for accessing other components.
-     * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+     * @param passwordExtraDict - Additional words to be used for password strength evaluation.
      */
-    constructor(mediator: TwoFaLibMediator, passphraseExtraDict: PassphraseExtraDict);
+    constructor(mediator: TwoFaLibMediator, passwordExtraDict: PasswordExtraDict);
     private get libraryLoader();
     private get vaultDataManager();
     private get vaultOperationsManager();
@@ -21,21 +21,21 @@ declare class ExportImportManager {
      * Export entries in the specified format, optionally (when a password is provided) encrypted.
      * If the password is not provided, the user be warned about the dangers of exporting clear text.
      * @param format - The export format ('text' or 'html').
-     * @param passphrase - Optional password for encryption.
+     * @param password - Optional password for encryption.
      * @param userWasWarnedAboutExportingClearText - Whether the user was warned about exporting clear text.
      * @returns A promise that resolves to the exported data as a string.
      */
-    exportEntries(format: 'text' | 'html', passphrase?: string, userWasWarnedAboutExportingClearText?: boolean): Promise<string>;
+    exportEntries(format: 'text' | 'html', password?: string, userWasWarnedAboutExportingClearText?: boolean): Promise<string>;
     private generateTextExport;
     private generateHtmlExport;
     /**
      * Import entries from a text file, optionally (when a password is provided) decrypt first
      * @param fileContents - The contents of the text file.
-     * @param passphrase - Optional password for decryption.
+     * @param password - Optional password for decryption.
      * @returns A promise that resolves to an array of objects, each containing the line number,
      *          the EntryId or null if it was not a valid entry and the error if there was one.
      */
-    importFromTextFile(fileContents: string, passphrase?: string): Promise<{
+    importFromTextFile(fileContents: string, password?: string): Promise<{
         lineNr: number;
         entryId: EntryId | null;
         error: unknown;

package/build/subclasses/ExportImportManager.mjs

@@ -1,7 +1,7 @@
 import { parseOtpUri, generateHtmlExport, generateTextExport, processImportLines, encryptExport, decryptExport, } from '../utils/exportImportUtils.mjs';
 import { getDataFromQRImage } from '../utils/qrUtils.mjs';
 import { ExportImportError } from '../TwoFALibError.mjs';
-import { validatePassphraseStrength } from '../utils/creationUtils.mjs';
+import { validatePasswordStrength } from '../utils/creationUtils.mjs';
 /**
  * Manages the export and import of entries in various formats.
  */
@@ -9,11 +9,11 @@ class ExportImportManager {
     /**
      * Constructs a new instance of ExportImportManager.
      * @param mediator - The mediator for accessing other components.
-     * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+     * @param passwordExtraDict - Additional words to be used for password strength evaluation.
      */
-    constructor(mediator, passphraseExtraDict) {
+    constructor(mediator, passwordExtraDict) {
         this.mediator = mediator;
-        this.passphraseExtraDict = passphraseExtraDict;
+        this.passwordExtraDict = passwordExtraDict;
     }
     get libraryLoader() {
         return this.mediator.getComponent('libraryLoader');
@@ -31,13 +31,13 @@ class ExportImportManager {
      * Export entries in the specified format, optionally (when a password is provided) encrypted.
      * If the password is not provided, the user be warned about the dangers of exporting clear text.
      * @param format - The export format ('text' or 'html').
-     * @param passphrase - Optional password for encryption.
+     * @param password - Optional password for encryption.
      * @param userWasWarnedAboutExportingClearText - Whether the user was warned about exporting clear text.
      * @returns A promise that resolves to the exported data as a string.
      */
-    async exportEntries(format, passphrase, userWasWarnedAboutExportingClearText) {
+    async exportEntries(format, password, userWasWarnedAboutExportingClearText) {
         let exportData;
-        if (!passphrase && !userWasWarnedAboutExportingClearText) {
+        if (!password && !userWasWarnedAboutExportingClearText) {
             throw new ExportImportError('User was not warned about the dangers of unencrypted exporting');
         }
         if (format === 'text') {
@@ -49,9 +49,9 @@ class ExportImportManager {
         else {
             throw new ExportImportError('Invalid export format');
         }
-        if (passphrase) {
-            await validatePassphraseStrength(this.libraryLoader, passphrase, this.passphraseExtraDict);
-            return encryptExport(this.libraryLoader.getOpenPGPLib(), exportData, passphrase);
+        if (password) {
+            await validatePasswordStrength(this.libraryLoader, this.passwordExtraDict, password);
+            return encryptExport(this.libraryLoader.getOpenPGPLib(), exportData, password);
         }
         return exportData;
     }
@@ -65,13 +65,13 @@ class ExportImportManager {
     /**
      * Import entries from a text file, optionally (when a password is provided) decrypt first
      * @param fileContents - The contents of the text file.
-     * @param passphrase - Optional password for decryption.
+     * @param password - Optional password for decryption.
      * @returns A promise that resolves to an array of objects, each containing the line number,
      *          the EntryId or null if it was not a valid entry and the error if there was one.
      */
-    async importFromTextFile(fileContents, passphrase) {
-        if (passphrase) {
-            const decrypted = await decryptExport(this.libraryLoader.getOpenPGPLib(), fileContents, passphrase);
+    async importFromTextFile(fileContents, password) {
+        if (password) {
+            const decrypted = await decryptExport(this.libraryLoader.getOpenPGPLib(), fileContents, password);
             return this.importFromTextFile(decrypted);
         }
         const lines = fileContents.trim().split('\n');

package/build/subclasses/PersistentStorageManager.d.mts

@@ -1,8 +1,8 @@
-import type { EncryptedPrivateKey, EncryptedSymmetricKey, Passphrase, PrivateKey, Salt, SymmetricKey } from '../interfaces/CryptoLib.mjs';
+import type { EncryptedPrivateKey, EncryptedSymmetricKey, Password, PrivateKey, Salt, SymmetricKey } from '../interfaces/CryptoLib.mjs';
 import { EncryptedVaultStateString, LockedRepresentationString } from '../interfaces/Vault.mjs';
 import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
 import type { FavaMeta } from '../interfaces/FavaMeta.mjs';
-import type { PassphraseExtraDict } from '../interfaces/PassphraseExtraDict.js';
+import type { PasswordExtraDict } from '../interfaces/PasswordExtraDict.js';
 import type { SaveFunction } from '../interfaces/SaveFunction.mjs';
 import type { DeviceId } from '../interfaces/SyncTypes.mjs';
 /**
@@ -10,7 +10,7 @@ import type { DeviceId } from '../interfaces/SyncTypes.mjs';
  */
 declare class PersistentStorageManager {
     private mediator;
-    private readonly passphraseExtraDict;
+    private readonly passwordExtraDict;
     private readonly favaMeta;
     private readonly privateKey;
     private readonly symmetricKey;
@@ -23,7 +23,7 @@ declare class PersistentStorageManager {
     /**
      * Constructs a new instance of PersistentStorageManager.
      * @param mediator - The mediator for accessing other components.
-     * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+     * @param passwordExtraDict - Additional words to be used for password strength evaluation.
      * @param favaMeta - Meta info containing at least a unique identifier for this device.
      * @param privateKey - The private key used for cryptographic operations.
      * @param symmetricKey - The symmetric key used for cryptographic operations.
@@ -32,7 +32,7 @@ declare class PersistentStorageManager {
      * @param salt - The salt used for key derivation.
      * @param saveFunction - The function to save the data.
      */
-    constructor(mediator: TwoFaLibMediator, passphraseExtraDict: PassphraseExtraDict, favaMeta: FavaMeta, privateKey: PrivateKey, symmetricKey: SymmetricKey, encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, saveFunction?: SaveFunction | undefined);
+    constructor(mediator: TwoFaLibMediator, passwordExtraDict: PasswordExtraDict, favaMeta: FavaMeta, privateKey: PrivateKey, symmetricKey: SymmetricKey, encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, saveFunction?: SaveFunction | undefined);
     private get cryptoLib();
     private get vaultDataManager();
     private get syncManager();
@@ -46,7 +46,7 @@ declare class PersistentStorageManager {
     getEncryptedVaultState(key?: SymmetricKey, forDeviceId?: DeviceId): Promise<EncryptedVaultStateString>;
     /**
      * Creates a partially encrypted representation of all data, except for
-     * the passphrase, that is needed to load the library. This can be used
+     * the password, that is needed to load the library. This can be used
      * for secure storage of the library's data.
      * @returns A promise that resolves with a json encoded string of
      * the partially encrypted library's data.
@@ -67,19 +67,19 @@ declare class PersistentStorageManager {
      */
     private performSave;
     /**
-     * Validates the provided passphrase against the current library passphrase.
+     * Validates the provided password against the current library password.
      * @param salt - The salt used for key derivation.
-     * @param passphrase - The passphrase to validate.
-     * @returns A promise that resolves with a boolean indicating whether the passphrase is valid.
+     * @param password - The password to validate.
+     * @returns A promise that resolves with a boolean indicating whether the password is valid.
      */
-    validatePassphrase(salt: Salt, passphrase: Passphrase): Promise<boolean>;
+    validatePassword(salt: Salt, password: Password): Promise<boolean>;
     /**
-     * Changes the library's passphrase.
-     * @param oldPassphrase - The current passphrase.
-     * @param newPassphrase - The new passphrase to set.
-     * @returns A promise that resolves when the passphrase change is complete.
-     * @throws {AuthenticationError} If the provided old passphrase is incorrect.
+     * Changes the library's password.
+     * @param oldPassword - The current password.
+     * @param newPassword - The new password to set.
+     * @returns A promise that resolves when the password change is complete.
+     * @throws {AuthenticationError} If the provided old password is incorrect.
      */
-    changePassphrase(oldPassphrase: Passphrase, newPassphrase: Passphrase): Promise<void>;
+    changePassword(oldPassword: Password, newPassword: Password): Promise<void>;
 }
 export default PersistentStorageManager;

package/build/subclasses/PersistentStorageManager.mjs

@@ -1,6 +1,6 @@
 import { AuthenticationError } from '../TwoFALibError.mjs';
 import TwoFaLib from '../TwoFaLib.mjs';
-import { validatePassphraseStrength } from '../utils/creationUtils.mjs';
+import { validatePasswordStrength } from '../utils/creationUtils.mjs';
 /**
  * Manages all storage of data that should be persistent.
  */
@@ -9,7 +9,7 @@ class PersistentStorageManager {
     /**
      * Constructs a new instance of PersistentStorageManager.
      * @param mediator - The mediator for accessing other components.
-     * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+     * @param passwordExtraDict - Additional words to be used for password strength evaluation.
      * @param favaMeta - Meta info containing at least a unique identifier for this device.
      * @param privateKey - The private key used for cryptographic operations.
      * @param symmetricKey - The symmetric key used for cryptographic operations.
@@ -18,9 +18,9 @@ class PersistentStorageManager {
      * @param salt - The salt used for key derivation.
      * @param saveFunction - The function to save the data.
      */
-    constructor(mediator, passphraseExtraDict, favaMeta, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, saveFunction) {
+    constructor(mediator, passwordExtraDict, favaMeta, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, saveFunction) {
         this.mediator = mediator;
-        this.passphraseExtraDict = passphraseExtraDict;
+        this.passwordExtraDict = passwordExtraDict;
         this.favaMeta = favaMeta;
         this.privateKey = privateKey;
         this.symmetricKey = symmetricKey;
@@ -67,7 +67,7 @@ class PersistentStorageManager {
     }
     /**
      * Creates a partially encrypted representation of all data, except for
-     * the passphrase, that is needed to load the library. This can be used
+     * the password, that is needed to load the library. This can be used
      * for secure storage of the library's data.
      * @returns A promise that resolves with a json encoded string of
      * the partially encrypted library's data.
@@ -122,14 +122,14 @@ class PersistentStorageManager {
         await this.saveFunction(lockedRepresentation);
     }
     /**
-     * Validates the provided passphrase against the current library passphrase.
+     * Validates the provided password against the current library password.
      * @param salt - The salt used for key derivation.
-     * @param passphrase - The passphrase to validate.
-     * @returns A promise that resolves with a boolean indicating whether the passphrase is valid.
+     * @param password - The password to validate.
+     * @returns A promise that resolves with a boolean indicating whether the password is valid.
      */
-    async validatePassphrase(salt, passphrase) {
+    async validatePassword(salt, password) {
         try {
-            await this.cryptoLib.decryptKeys(this.encryptedPrivateKey, this.encryptedSymmetricKey, salt, passphrase);
+            await this.cryptoLib.decryptKeys(this.encryptedPrivateKey, this.encryptedSymmetricKey, salt, password);
             return true;
         }
         catch {
@@ -137,18 +137,18 @@ class PersistentStorageManager {
         }
     }
     /**
-     * Changes the library's passphrase.
-     * @param oldPassphrase - The current passphrase.
-     * @param newPassphrase - The new passphrase to set.
-     * @returns A promise that resolves when the passphrase change is complete.
-     * @throws {AuthenticationError} If the provided old passphrase is incorrect.
+     * Changes the library's password.
+     * @param oldPassword - The current password.
+     * @param newPassword - The new password to set.
+     * @returns A promise that resolves when the password change is complete.
+     * @throws {AuthenticationError} If the provided old password is incorrect.
      */
-    async changePassphrase(oldPassphrase, newPassphrase) {
-        await validatePassphraseStrength(this.mediator.getComponent('libraryLoader'), newPassphrase, this.passphraseExtraDict);
-        const isValid = await this.validatePassphrase(this.salt, oldPassphrase);
+    async changePassword(oldPassword, newPassword) {
+        await validatePasswordStrength(this.mediator.getComponent('libraryLoader'), this.passwordExtraDict, newPassword);
+        const isValid = await this.validatePassword(this.salt, oldPassword);
         if (!isValid)
-            throw new AuthenticationError('Invalid old passphrase');
-        const { encryptedPrivateKey: newEncryptedPrivateKey, encryptedSymmetricKey: newEncryptedSymmetricKey, } = await this.cryptoLib.encryptKeys(this.privateKey, this.symmetricKey, this.salt, newPassphrase);
+            throw new AuthenticationError('Invalid old password');
+        const { encryptedPrivateKey: newEncryptedPrivateKey, encryptedSymmetricKey: newEncryptedSymmetricKey, } = await this.cryptoLib.encryptKeys(this.privateKey, this.symmetricKey, this.salt, newPassword);
         this.encryptedPrivateKey = newEncryptedPrivateKey;
         this.encryptedSymmetricKey = newEncryptedSymmetricKey;
         await this.save();

package/build/subclasses/StorageOperationsManager.d.mts

@@ -1,5 +1,5 @@
 import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
-import type { Passphrase } from '../interfaces/CryptoLib.mjs';
+import type { Password } from '../interfaces/CryptoLib.mjs';
 import type { SaveFunction } from '../interfaces/SaveFunction.mjs';
 /**
  * Manages the public operations related to the vault storage
@@ -21,13 +21,13 @@ declare class StorageOperationsManager {
      */
     forceSave(): Promise<void>;
     /**
-     * Changes the library's passphrase.
-     * @param oldPassphrase - The current passphrase.
-     * @param newPassphrase - The new passphrase to set.
-     * @returns A promise that resolves when the passphrase change is complete.
-     * @throws {AuthenticationError} If the provided old passphrase is incorrect.
+     * Changes the library's password.
+     * @param oldPassword - The current password.
+     * @param newPassword - The new password to set.
+     * @returns A promise that resolves when the password change is complete.
+     * @throws {AuthenticationError} If the provided old password is incorrect.
      */
-    changePassphrase(oldPassphrase: Passphrase, newPassphrase: Passphrase): Promise<void>;
+    changePassword(oldPassword: Password, newPassword: Password): Promise<void>;
     /**
      * Sets the save function for the library.
      * @param saveFunction - The save function to set.

package/build/subclasses/StorageOperationsManager.mjs

@@ -23,14 +23,14 @@ class StorageOperationsManager {
         return this.persistentStorage.save();
     }
     /**
-     * Changes the library's passphrase.
-     * @param oldPassphrase - The current passphrase.
-     * @param newPassphrase - The new passphrase to set.
-     * @returns A promise that resolves when the passphrase change is complete.
-     * @throws {AuthenticationError} If the provided old passphrase is incorrect.
+     * Changes the library's password.
+     * @param oldPassword - The current password.
+     * @param newPassword - The new password to set.
+     * @returns A promise that resolves when the password change is complete.
+     * @throws {AuthenticationError} If the provided old password is incorrect.
      */
-    async changePassphrase(oldPassphrase, newPassphrase) {
-        return this.persistentStorage.changePassphrase(oldPassphrase, newPassphrase);
+    async changePassword(oldPassword, newPassword) {
+        return this.persistentStorage.changePassword(oldPassword, newPassword);
     }
     /**
      * Sets the save function for the library.

package/build/utils/creationUtils.d.mts

@@ -1,45 +1,45 @@
 import type { ZxcvbnResult } from '@zxcvbn-ts/core';
 import type { PlatformProviders } from '../interfaces/PlatformProviders.mjs';
-import type { Passphrase } from '../interfaces/CryptoLib.mjs';
+import type { Password } from '../interfaces/CryptoLib.mjs';
 import type { DeviceType } from '../interfaces/SyncTypes.mjs';
 import TwoFaLib from '../TwoFaLib.mjs';
 import LibraryLoader from '../subclasses/LibraryLoader.mjs';
 import type { LockedRepresentationString } from '../interfaces/Vault.mjs';
-import type { PassphraseExtraDict } from '../interfaces/PassphraseExtraDict.js';
+import type { PasswordExtraDict } from '../interfaces/PasswordExtraDict.js';
 import { SaveFunction } from '../interfaces/SaveFunction.mjs';
 /**
- * Evaluates the strength of a passphrase.
+ * Evaluates the strength of a password.
  * @param libraryLoader - An instance of LibraryLoader.
- * @param passphrase - The passphrase to evaluate.
- * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
- * @returns Promise resolving to the passphrase strength result.
+ * @param passwordExtraDict - Additional words to be used for password strength evaluation.
+ * @param password - The password to evaluate.
+ * @returns Promise resolving to the password strength result.
  */
-export declare const getPassphraseStrength: (libraryLoader: LibraryLoader, passphrase: Passphrase, passphraseExtraDict: PassphraseExtraDict) => Promise<ZxcvbnResult>;
+export declare const getPasswordStrength: (libraryLoader: LibraryLoader, passwordExtraDict: PasswordExtraDict, password: Password) => Promise<ZxcvbnResult>;
 /**
- * Validates the strength of a passphrase.
+ * Validates the strength of a password.
  * @param libraryLoader - An instance of LibraryLoader.
- * @param passphrase - The passphrase to validate.
- * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
- * @throws {InitializationError} If the passphrase is too weak.
+ * @param passwordExtraDict - Additional words to be used for password strength evaluation.
+ * @param password - The password to validate.
+ * @throws {InitializationError} If the password is too weak.
  */
-export declare const validatePassphraseStrength: (libraryLoader: LibraryLoader, passphrase: Passphrase, passphraseExtraDict: PassphraseExtraDict) => Promise<void>;
+export declare const validatePasswordStrength: (libraryLoader: LibraryLoader, passwordExtraDict: PasswordExtraDict, password: Password) => Promise<void>;
 /**
  * Returns utility functions useful in creating a new twoFaLib vault
  * @param platformProviders - The platform-specific providers containing CryptoLib and other providers.
  * @param deviceType - A unique identifier for this device type (e.g. 2fa-cli).
- * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @param passwordExtraDict - Additional words to be used for password strength evaluation.
  * @param saveFunction - The function to save the data.
  * @param serverUrl - The server URL for syncing.
- * @returns An object with methods to evaluate passphrase strength and create a new TwoFaLib vault.
+ * @returns An object with methods to evaluate password strength and create a new TwoFaLib vault.
  */
-export declare const getTwoFaLibVaultCreationUtils: (platformProviders: PlatformProviders, deviceType: DeviceType, passphraseExtraDict: PassphraseExtraDict, saveFunction?: SaveFunction, serverUrl?: string) => {
-    getPassphraseStrength: (passphrase: Passphrase, passphraseExtraDict: PassphraseExtraDict) => Promise<ZxcvbnResult>;
-    createNewTwoFaLibVault: (passphrase: Passphrase) => Promise<{
+export declare const getTwoFaLibVaultCreationUtils: (platformProviders: PlatformProviders, deviceType: DeviceType, passwordExtraDict: PasswordExtraDict, saveFunction?: SaveFunction, serverUrl?: string) => {
+    getPasswordStrength: (password: Password) => Promise<ZxcvbnResult>;
+    createNewTwoFaLibVault: (password: Password) => Promise<{
         twoFaLib: TwoFaLib;
         publicKey: import("../interfaces/CryptoLib.mjs").PublicKey;
         encryptedPrivateKey: import("../interfaces/CryptoLib.mjs").EncryptedPrivateKey;
         encryptedSymmetricKey: import("../interfaces/CryptoLib.mjs").EncryptedSymmetricKey;
         salt: import("../interfaces/CryptoLib.mjs").Salt;
     }>;
-    loadTwoFaLibFromLockedRepesentation: (lockedRepresentationString: LockedRepresentationString, passphrase: Passphrase) => Promise<TwoFaLib>;
+    loadTwoFaLibFromLockedRepesentation: (lockedRepresentationString: LockedRepresentationString, password: Password) => Promise<TwoFaLib>;
 };

package/build/utils/creationUtils.mjs

@@ -3,15 +3,15 @@ import TwoFaLib from '../TwoFaLib.mjs';
 import { InitializationError, TwoFALibError } from '../TwoFALibError.mjs';
 import LibraryLoader from '../subclasses/LibraryLoader.mjs';
 /**
- * Evaluates the strength of a passphrase.
+ * Evaluates the strength of a password.
  * @param libraryLoader - An instance of LibraryLoader.
- * @param passphrase - The passphrase to evaluate.
- * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
- * @returns Promise resolving to the passphrase strength result.
+ * @param passwordExtraDict - Additional words to be used for password strength evaluation.
+ * @param password - The password to evaluate.
+ * @returns Promise resolving to the password strength result.
  */
-export const getPassphraseStrength = async (libraryLoader, passphrase, passphraseExtraDict) => {
+export const getPasswordStrength = async (libraryLoader, passwordExtraDict, password) => {
     const zxcvbn = await libraryLoader.getZxcvbn();
-    return zxcvbn(passphrase, [
+    return zxcvbn(password, [
         'twofactor',
         'authentication',
         'token',
@@ -34,20 +34,20 @@ export const getPassphraseStrength = async (libraryLoader, passphrase, passphras
         'key',
         'trust',
         'secure',
-        ...passphraseExtraDict,
+        ...passwordExtraDict,
     ]);
 };
 /**
- * Validates the strength of a passphrase.
+ * Validates the strength of a password.
  * @param libraryLoader - An instance of LibraryLoader.
- * @param passphrase - The passphrase to validate.
- * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
- * @throws {InitializationError} If the passphrase is too weak.
+ * @param passwordExtraDict - Additional words to be used for password strength evaluation.
+ * @param password - The password to validate.
+ * @throws {InitializationError} If the password is too weak.
  */
-export const validatePassphraseStrength = async (libraryLoader, passphrase, passphraseExtraDict) => {
-    const passphraseStrength = await getPassphraseStrength(libraryLoader, passphrase, passphraseExtraDict);
-    if (passphraseStrength.score < 3) {
-        throw new TwoFALibError('Passphrase is too weak');
+export const validatePasswordStrength = async (libraryLoader, passwordExtraDict, password) => {
+    const passwordStrength = await getPasswordStrength(libraryLoader, passwordExtraDict, password);
+    if (passwordStrength.score < 3) {
+        throw new TwoFALibError('Password is too weak');
     }
 };
 /**
@@ -55,18 +55,18 @@ export const validatePassphraseStrength = async (libraryLoader, passphrase, pass
  * @param libraryLoader - An instance of LibraryLoader.
  * @param deviceType - A unique identifier for the device type e.g. 2fa-cli.
  * @param serverUrl - The server URL for syncing.
- * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @param passwordExtraDict - Additional words to be used for password strength evaluation.
  * @param saveFunction - The function to save the data.
- * @param passphrase - The passphrase to be used to encrypt the private key.
+ * @param password - The password to be used to encrypt the private key.
  * @returns Promise resolving to an object containing the newly created TwoFaLib instance and related data.
  */
-const createNewTwoFaLibVault = async (libraryLoader, deviceType, serverUrl, passphraseExtraDict, saveFunction, passphrase) => {
+const createNewTwoFaLibVault = async (libraryLoader, deviceType, serverUrl, passwordExtraDict, saveFunction, password) => {
     const cryptoLib = libraryLoader.getCryptoLib();
     const platformProviders = libraryLoader.getPlatformProviders();
-    const { publicKey, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, } = await cryptoLib.createKeys(passphrase);
-    await validatePassphraseStrength(libraryLoader, passphrase, passphraseExtraDict);
+    const { publicKey, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, } = await cryptoLib.createKeys(password);
+    await validatePasswordStrength(libraryLoader, passwordExtraDict, password);
     const deviceId = genUuidV4();
-    const twoFaLib = new TwoFaLib(deviceType, platformProviders, passphraseExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, {
+    const twoFaLib = new TwoFaLib(deviceType, platformProviders, passwordExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, {
         deviceId,
     }, [], saveFunction, {
         serverUrl,
@@ -85,14 +85,14 @@ const createNewTwoFaLibVault = async (libraryLoader, deviceType, serverUrl, pass
  * Loads the library state from a previously locked representation.
  * @param libraryLoader - An instance of LibraryLoader.
  * @param deviceType - A unique identifier for this device type (e.g. 2fa-cli).
- * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @param passwordExtraDict - Additional words to be used for password strength evaluation.
  * @param saveFunction - The function to save the data.
  * @param lockedRepresentationString - The string representation of the locked library state representation.
- * @param passphrase - The passphrase for decrypting the keys.
+ * @param password - The password for decrypting the keys.
  * @returns A promise that resolves when loading is complete.
  * @throws {InitializationError} If loading fails due to invalid or corrupted data.
  */
-const loadTwoFaLibFromLockedRepesentation = async (libraryLoader, deviceType, passphraseExtraDict, saveFunction, lockedRepresentationString, passphrase) => {
+const loadTwoFaLibFromLockedRepesentation = async (libraryLoader, deviceType, passwordExtraDict, saveFunction, lockedRepresentationString, password) => {
     const cryptoLib = libraryLoader.getCryptoLib();
     const platformProviders = libraryLoader.getPlatformProviders();
     const lockedRepresentation = JSON.parse(lockedRepresentationString);
@@ -103,7 +103,7 @@ const loadTwoFaLibFromLockedRepesentation = async (libraryLoader, deviceType, pa
         !lockedRepresentation.encryptedVaultState) {
         throw new InitializationError('lockedRepresentation is incomplete or corrupted');
     }
-    const { privateKey, symmetricKey, publicKey } = await cryptoLib.decryptKeys(lockedRepresentation.encryptedPrivateKey, lockedRepresentation.encryptedSymmetricKey, lockedRepresentation.salt, passphrase);
+    const { privateKey, symmetricKey, publicKey } = await cryptoLib.decryptKeys(lockedRepresentation.encryptedPrivateKey, lockedRepresentation.encryptedSymmetricKey, lockedRepresentation.salt, password);
     const vaultState = JSON.parse(await cryptoLib.decryptSymmetric(symmetricKey, lockedRepresentation.encryptedVaultState));
     if (!vaultState ||
         !vaultState.deviceId ||
@@ -111,7 +111,7 @@ const loadTwoFaLibFromLockedRepesentation = async (libraryLoader, deviceType, pa
         !vaultState.sync?.devices) {
         throw new InitializationError('encryptedVaultState is incomplete or corrupted');
     }
-    return new TwoFaLib(deviceType, platformProviders, passphraseExtraDict, privateKey, symmetricKey, lockedRepresentation.encryptedPrivateKey, lockedRepresentation.encryptedSymmetricKey, lockedRepresentation.salt, publicKey, {
+    return new TwoFaLib(deviceType, platformProviders, passwordExtraDict, privateKey, symmetricKey, lockedRepresentation.encryptedPrivateKey, lockedRepresentation.encryptedSymmetricKey, lockedRepresentation.salt, publicKey, {
         deviceId: vaultState.deviceId,
         deviceFriendlyName: vaultState.deviceFriendlyName,
     }, vaultState.vault, saveFunction, vaultState.sync);
@@ -120,16 +120,16 @@ const loadTwoFaLibFromLockedRepesentation = async (libraryLoader, deviceType, pa
  * Returns utility functions useful in creating a new twoFaLib vault
  * @param platformProviders - The platform-specific providers containing CryptoLib and other providers.
  * @param deviceType - A unique identifier for this device type (e.g. 2fa-cli).
- * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @param passwordExtraDict - Additional words to be used for password strength evaluation.
  * @param saveFunction - The function to save the data.
  * @param serverUrl - The server URL for syncing.
- * @returns An object with methods to evaluate passphrase strength and create a new TwoFaLib vault.
+ * @returns An object with methods to evaluate password strength and create a new TwoFaLib vault.
  */
-export const getTwoFaLibVaultCreationUtils = (platformProviders, deviceType, passphraseExtraDict, saveFunction, serverUrl) => {
+export const getTwoFaLibVaultCreationUtils = (platformProviders, deviceType, passwordExtraDict, saveFunction, serverUrl) => {
     const libraryLoader = new LibraryLoader(platformProviders);
     return {
-        getPassphraseStrength: getPassphraseStrength.bind(null, libraryLoader),
-        createNewTwoFaLibVault: createNewTwoFaLibVault.bind(null, libraryLoader, deviceType, serverUrl, passphraseExtraDict, saveFunction),
-        loadTwoFaLibFromLockedRepesentation: loadTwoFaLibFromLockedRepesentation.bind(null, libraryLoader, deviceType, passphraseExtraDict, saveFunction),
+        getPasswordStrength: getPasswordStrength.bind(null, libraryLoader, passwordExtraDict),
+        createNewTwoFaLibVault: createNewTwoFaLibVault.bind(null, libraryLoader, deviceType, serverUrl, passwordExtraDict, saveFunction),
+        loadTwoFaLibFromLockedRepesentation: loadTwoFaLibFromLockedRepesentation.bind(null, libraryLoader, deviceType, passwordExtraDict, saveFunction),
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "favalib",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "",
   "type": "module",
   "exports": {

package/build/interfaces/PassphraseExtraDict.d.ts

@@ -1,2 +0,0 @@
-import type { NonEmptyTuple } from 'type-fest';
-export type PassphraseExtraDict = NonEmptyTuple<string>;