favalib 0.0.11 → 0.0.13

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

@@ -1,9 +1,9 @@
 import { TypedEventTarget } from 'typescript-event-target';
-import type CryptoLib from './interfaces/CryptoLib.mjs';
+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';
@@ -34,8 +34,8 @@ 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 cryptoLib - An instance of CryptoLib that is compatible with the environment.
-     * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+     * @param platformProviders - The platform-specific providers containing CryptoLib and other providers.
+     * @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, cryptoLib: CryptoLib, 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

@@ -30,8 +30,8 @@ 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 cryptoLib - An instance of CryptoLib that is compatible with the environment.
-     * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+     * @param platformProviders - The platform-specific providers containing CryptoLib and other providers.
+     * @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, cryptoLib, 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;
@@ -70,10 +70,10 @@ class TwoFaLib extends TypedEventTarget {
         this.privateKey = privateKey;
         this.mediator = new TwoFaLibMediator();
         this.mediator.registerComponents([
-            ['libraryLoader', new LibraryLoader(cryptoLib)],
+            ['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)],
@@ -153,9 +153,10 @@ class TwoFaLib extends TypedEventTarget {
      * @param force - Force setting the sync server url, even if no connection can be made
      */
     async setSyncServerUrl(serverUrl, force = false) {
-        if (this.sync) {
+        const oldSyncManager = this.sync;
+        if (oldSyncManager) {
             // close connection so no data is send to the old syncServer
-            this.sync.closeServerConnection();
+            oldSyncManager.closeServerConnection();
         }
         const newSyncState = {
             serverUrl,
@@ -163,6 +164,9 @@ class TwoFaLib extends TypedEventTarget {
             commandSendQueue: [],
         };
         const newSyncManager = new SyncManager(this.mediator, this.publicKey, this.privateKey, this.favaMeta, newSyncState, this.deviceType);
+        // Temporarily register the new sync manager so its events can be heard
+        this.mediator.unRegisterComponent('syncManager');
+        this.mediator.registerComponent('syncManager', newSyncManager);
         const success = await new Promise((resolve) => {
             this.addEventListener(TwoFaLibEvent.ConnectionToSyncServerStatusChanged, (event) => {
                 if (event.detail.newStatus === ConnectionStatus.CONNECTED) {
@@ -178,18 +182,18 @@ class TwoFaLib extends TypedEventTarget {
                 this.log('warning', `Failed to connect to server at ${serverUrl}, force setting`);
             }
             else {
-                if (this.sync) {
+                // Close the new sync manager and restore the old one
+                newSyncManager.closeServerConnection();
+                this.mediator.unRegisterComponent('syncManager');
+                if (oldSyncManager) {
                     // re-establish old connection
-                    this.sync.initServerConnection();
+                    this.mediator.registerComponent('syncManager', oldSyncManager);
+                    oldSyncManager.initServerConnection();
                 }
-                newSyncManager.closeServerConnection();
                 throw new SyncError(`Failed to connect to server at ${serverUrl}, not setting`);
             }
         }
-        // connection succeeded (or force=true)
-        // switch to the new syncManager
-        this.mediator.unRegisterComponent('syncManager');
-        this.mediator.registerComponent('syncManager', newSyncManager);
+        // connection succeeded (or force=true) - new sync manager is already registered
         // save
         await this.persistentStorageManager.save();
     }

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/OpenPgpLib.d.mts

@@ -0,0 +1,20 @@
+/**
+ * Interface for OpenPGP operations
+ */
+export interface OpenPgpLib {
+    /**
+     * Encrypts the given data using OpenPGP.
+     * @param data - The data to encrypt.
+     * @param password - The password to use for encryption.
+     * @returns A promise that resolves to the encrypted data.
+     */
+    encrypt(data: string, password: string): Promise<string>;
+    /**
+     * Decrypts the given data using OpenPGP.
+     * @param data - The data to decrypt.
+     * @param password - The password to use for decryption.
+     * @returns A promise that resolves to the decrypted data.
+     */
+    decrypt(data: string, password: string): Promise<string>;
+}
+export default OpenPgpLib;

package/build/interfaces/PasswordExtraDict.d.ts

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

package/build/interfaces/PasswordExtraDict.js

@@ -0,0 +1 @@
+export {};

package/build/interfaces/PlatformProviders.d.mts

@@ -0,0 +1,26 @@
+import type CryptoLib from './CryptoLib.mjs';
+import type { QrCodeLib } from './QrCodeLib.mjs';
+import type { OpenPgpLib } from './OpenPgpLib.mjs';
+/**
+ * Interface for platform-specific providers
+ * Includes platform-specific implementations for various libraries
+ */
+export interface PlatformProviders {
+    /**
+     * Cryptographic operations provider
+     */
+    CryptoLib: new () => CryptoLib;
+    /**
+     * WebSocket library
+     */
+    WebSocketLib: () => typeof WebSocket;
+    /**
+     * QR code generation library with platform-specific extensions
+     */
+    QrCodeLib: new () => QrCodeLib;
+    /**
+     * OpenPGP encryption library
+     */
+    OpenPgpLib: new () => OpenPgpLib;
+}
+export default PlatformProviders;

package/build/interfaces/PlatformProviders.mjs

@@ -0,0 +1 @@
+export {};

package/build/interfaces/QrCodeLib.d.mts

@@ -0,0 +1,19 @@
+import type { ImageData } from 'canvas';
+/**
+ * Interface for QR code operations
+ */
+export interface QrCodeLib {
+    /**
+     * Generates a QR code as a data URL.
+     * @param text - The text to encode.
+     * @returns A promise that resolves to a data URL string.
+     */
+    toDataURL(text: string): Promise<string>;
+    /**
+     * Gets ImageData from various input types for QR code processing.
+     * @param imageInput - The image input (string URL, File, or Uint8Array).
+     * @returns A promise that resolves to ImageData.
+     */
+    getImageDataFromInput(imageInput: string | File | Uint8Array): Promise<ImageData>;
+}
+export default QrCodeLib;

package/build/interfaces/QrCodeLib.mjs

@@ -0,0 +1 @@
+export {};

package/build/main.d.mts

@@ -2,12 +2,13 @@ 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';
+import type { PlatformProviders } from './interfaces/PlatformProviders.mjs';
 import { TwoFALibError, InitializationError, AuthenticationError, EntryNotFoundError, TokenGenerationError } from './TwoFALibError.mjs';
 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, };
+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/{CryptoProviders/browser/index.d.mts → 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/{CryptoProviders/browser/index.mjs → 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/browser/index.d.mts

@@ -0,0 +1,6 @@
+import type { PlatformProviders } from '../../interfaces/PlatformProviders.mjs';
+/**
+ * Browser-specific platform providers
+ */
+export declare const browserProviders: PlatformProviders;
+export default browserProviders;

package/build/platformProviders/browser/index.mjs

@@ -0,0 +1,13 @@
+import BrowserCryptoLib from './cryptoLib.mjs';
+import { BrowserQrCodeLib } from './qrCodeLib.mjs';
+import { BrowserOpenPgpLib } from './openPgpLib.mjs';
+/**
+ * Browser-specific platform providers
+ */
+export const browserProviders = {
+    CryptoLib: BrowserCryptoLib,
+    WebSocketLib: () => WebSocket,
+    QrCodeLib: BrowserQrCodeLib,
+    OpenPgpLib: BrowserOpenPgpLib,
+};
+export default browserProviders;

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

@@ -0,0 +1,20 @@
+import type { OpenPgpLib } from '../../interfaces/OpenPgpLib.mjs';
+/**
+ * Browser implementation of OpenPGP library wrapper
+ */
+export declare class BrowserOpenPgpLib implements OpenPgpLib {
+    private openPgpModule;
+    /**
+     * Gets the OpenPGP module, loading it if necessary
+     * @returns Promise that resolves to the OpenPGP module
+     */
+    private getOpenPgpModule;
+    /**
+     * @inheritdoc
+     */
+    encrypt(data: string, password: string): Promise<string>;
+    /**
+     * @inheritdoc
+     */
+    decrypt(data: string, password: string): Promise<string>;
+}

package/build/platformProviders/browser/openPgpLib.mjs

@@ -0,0 +1,44 @@
+/**
+ * Browser implementation of OpenPGP library wrapper
+ */
+export class BrowserOpenPgpLib {
+    constructor() {
+        this.openPgpModule = null;
+    }
+    /**
+     * Gets the OpenPGP module, loading it if necessary
+     * @returns Promise that resolves to the OpenPGP module
+     */
+    async getOpenPgpModule() {
+        if (!this.openPgpModule) {
+            this.openPgpModule = await import('openpgp');
+            // enable Authenticated Encryption with Associated Data
+            this.openPgpModule.config.aeadProtect = true;
+        }
+        return this.openPgpModule;
+    }
+    /**
+     * @inheritdoc
+     */
+    async encrypt(data, password) {
+        const openPgp = await this.getOpenPgpModule();
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const encrypted = await openPgp.encrypt({
+            message: await openPgp.createMessage({ text: data }),
+            passwords: [password],
+            format: 'armored',
+        });
+        return encrypted;
+    }
+    /**
+     * @inheritdoc
+     */
+    async decrypt(data, password) {
+        const openPgp = await this.getOpenPgpModule();
+        const decrypted = await openPgp.decrypt({
+            message: await openPgp.readMessage({ armoredMessage: data }),
+            passwords: [password],
+        });
+        return decrypted.data;
+    }
+}

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

@@ -0,0 +1,25 @@
+import type { ImageData } from 'canvas';
+import type { QrCodeLib } from '../../interfaces/QrCodeLib.mjs';
+/**
+ * Gets the ImageData from an image, for browser environments.
+ * This ImageData is then further processed to get QR codes.
+ * @param input - The image to get the ImageData from.
+ * @returns A promise that resolves to the ImageData.
+ */
+export declare const getImageDataFromInput: (input: string | File | Uint8Array) => Promise<ImageData>;
+/**
+ * Browser implementation of QR code library wrapper
+ */
+export declare class BrowserQrCodeLib implements QrCodeLib {
+    private qrCodeModule;
+    /**
+     * Gets the QR code module, loading it if necessary
+     * @returns Promise that resolves to the QR code module
+     */
+    private getQrCodeModule;
+    /**
+     * @inheritdoc
+     */
+    toDataURL(text: string): Promise<string>;
+    getImageDataFromInput: (input: string | File | Uint8Array) => Promise<ImageData>;
+}