favalib 0.0.11 → 0.0.12

package/build/TwoFaLib.d.mts

@@ -1,5 +1,5 @@
 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';
@@ -34,7 +34,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 cryptoLib - An instance of CryptoLib that is compatible with the environment.
+     * @param platformProviders - The platform-specific providers containing CryptoLib and other providers.
      * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
      * @param privateKey - The private key used for cryptographic operations.
      * @param symmetricKey - The symmetric key used for cryptographic operations.
@@ -50,7 +50,7 @@ declare class TwoFaLib extends TypedEventTarget<TwoFaLibEventMapEvents> {
      * @throws {InitializationError} If some parameter has an invalid value
      * @throws {AuthenticationError} If the provided passphrase 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, passphraseExtraDict: PassphraseExtraDict, 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,7 +30,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 cryptoLib - An instance of CryptoLib that is compatible with the environment.
+     * @param platformProviders - The platform-specific providers containing CryptoLib and other providers.
      * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
      * @param privateKey - The private key used for cryptographic operations.
      * @param symmetricKey - The symmetric key used for cryptographic operations.
@@ -46,7 +46,7 @@ class TwoFaLib extends TypedEventTarget {
      * @throws {InitializationError} If some parameter has an invalid value
      * @throws {AuthenticationError} If the provided passphrase is incorrect.
      */
-    constructor(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, favaMeta, vault, saveFunction, syncState) {
+    constructor(deviceType, platformProviders, passphraseExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, favaMeta, vault, saveFunction, syncState) {
         super();
         if (!deviceType) {
             throw new InitializationError('Device type is required');
@@ -70,7 +70,7 @@ 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),
@@ -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/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/OpenPgpLib.mjs

@@ -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

@@ -6,8 +6,9 @@ import type { Encrypted, EncryptedPrivateKey, EncryptedSymmetricKey, EncryptedPu
 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, Passphrase, Salt, DeviceId, DeviceType, DeviceFriendlyName, DeviceInfo, PublicSyncDevice, SaveFunction, PlatformProviders, };

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>;
+}

package/build/platformProviders/browser/qrCodeLib.mjs

@@ -0,0 +1,69 @@
+import { TwoFALibError } from '../../TwoFALibError.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 const getImageDataFromInput = (input) => {
+    return new Promise((resolve, reject) => {
+        if (input instanceof Uint8Array) {
+            reject(new TwoFALibError('Uint8Array input not supported in browser environment'));
+            return;
+        }
+        const img = new Image();
+        img.onload = () => {
+            const canvas = document.createElement('canvas');
+            canvas.width = img.width;
+            canvas.height = img.height;
+            const ctx = canvas.getContext('2d');
+            if (!ctx) {
+                reject(new TwoFALibError('Could not create canvas context'));
+                return;
+            }
+            ctx.drawImage(img, 0, 0);
+            resolve(ctx.getImageData(0, 0, img.width, img.height));
+        };
+        img.onerror = () => reject(new TwoFALibError('Failed to load image'));
+        if (typeof input === 'string') {
+            // URL or Data URL
+            img.src = input;
+        }
+        else {
+            // File object
+            const reader = new FileReader();
+            reader.onload = (e) => {
+                img.src = e.target?.result;
+            };
+            reader.onerror = () => reject(new TwoFALibError('Failed to read file'));
+            reader.readAsDataURL(input);
+        }
+    });
+};
+/**
+ * Browser implementation of QR code library wrapper
+ */
+export class BrowserQrCodeLib {
+    constructor() {
+        this.qrCodeModule = null;
+        this.getImageDataFromInput = getImageDataFromInput;
+    }
+    /**
+     * Gets the QR code module, loading it if necessary
+     * @returns Promise that resolves to the QR code module
+     */
+    async getQrCodeModule() {
+        if (!this.qrCodeModule) {
+            const qrcode = await import('qrcode');
+            this.qrCodeModule = qrcode.default;
+        }
+        return this.qrCodeModule;
+    }
+    /**
+     * @inheritdoc
+     */
+    async toDataURL(text) {
+        const qrCode = await this.getQrCodeModule();
+        return qrCode.toDataURL(text);
+    }
+}

package/build/{CryptoProviders/node/index.mjs → 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/index.mjs';
+import { generatePassphraseHash } from '../browser/cryptoLib.mjs';
 const generateKeyPair = promisify(generateKeyPairCb);
 const generateKey = promisify(generateKeyCb);
 /**

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

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

package/build/platformProviders/node/index.mjs

@@ -0,0 +1,13 @@
+import NodeCryptoLib from './cryptoLib.mjs';
+import { NodeQrCodeLib } from './qrCodeLib.mjs';
+import { NodeOpenPgpLib } from './openPgpLib.mjs';
+/**
+ * Node.js-specific platform providers
+ */
+export const nodeProviders = {
+    CryptoLib: NodeCryptoLib,
+    WebSocketLib: () => WebSocket,
+    QrCodeLib: NodeQrCodeLib,
+    OpenPgpLib: NodeOpenPgpLib,
+};
+export default nodeProviders;

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

@@ -0,0 +1,20 @@
+import type { OpenPgpLib } from '../../interfaces/OpenPgpLib.mjs';
+/**
+ * Node.js implementation of OpenPGP library wrapper
+ */
+export declare class NodeOpenPgpLib 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/node/openPgpLib.mjs

@@ -0,0 +1,44 @@
+/**
+ * Node.js implementation of OpenPGP library wrapper
+ */
+export class NodeOpenPgpLib {
+    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/node/qrCodeLib.d.mts

@@ -0,0 +1,28 @@
+import type { ImageData } from 'canvas';
+import type { QrCodeLib } from '../../interfaces/QrCodeLib.mjs';
+/**
+ * Gets the ImageData from an image, for Node.js environments.
+ * This ImageData is then further processed to get QR codes.
+ * @param inputImage - The image to get the ImageData from.
+ * @returns A promise that resolves to the ImageData.
+ */
+export declare const getImageDataFromInput: (inputImage: string | File | Uint8Array) => Promise<ImageData>;
+/**
+ * Node.js implementation of QR code library wrapper
+ */
+export declare class NodeQrCodeLib 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>;
+    /**
+     * @inheritdoc
+     */
+    getImageDataFromInput(imageInput: string | File | Uint8Array): Promise<ImageData>;
+}

package/build/platformProviders/node/qrCodeLib.mjs

@@ -0,0 +1,54 @@
+import { TwoFALibError } from '../../TwoFALibError.mjs';
+import { isUint8Array } from 'uint8array-extras';
+/**
+ * Gets the ImageData from an image, for Node.js environments.
+ * This ImageData is then further processed to get QR codes.
+ * @param inputImage - The image to get the ImageData from.
+ * @returns A promise that resolves to the ImageData.
+ */
+export const getImageDataFromInput = async (inputImage) => {
+    if (inputImage instanceof File) {
+        throw new TwoFALibError('Getting data from QR where image type is "File" is not supported in the node environment');
+    }
+    const canvasLib = await import('canvas');
+    const { createCanvas, loadImage } = canvasLib;
+    // eslint-disable-next-line no-restricted-globals
+    const input = isUint8Array(inputImage) ? Buffer.from(inputImage) : inputImage;
+    const image = await loadImage(input); // canvaslib expects a buffer
+    const canvas = createCanvas(image.width, image.height);
+    const ctx = canvas.getContext('2d');
+    ctx.drawImage(image, 0, 0);
+    return ctx.getImageData(0, 0, image.width, image.height);
+};
+/**
+ * Node.js implementation of QR code library wrapper
+ */
+export class NodeQrCodeLib {
+    constructor() {
+        this.qrCodeModule = null;
+    }
+    /**
+     * Gets the QR code module, loading it if necessary
+     * @returns Promise that resolves to the QR code module
+     */
+    async getQrCodeModule() {
+        if (!this.qrCodeModule) {
+            const qrcode = await import('qrcode');
+            this.qrCodeModule = qrcode.default;
+        }
+        return this.qrCodeModule;
+    }
+    /**
+     * @inheritdoc
+     */
+    async toDataURL(text) {
+        const qrCode = await this.getQrCodeModule();
+        return qrCode.toDataURL(text);
+    }
+    /**
+     * @inheritdoc
+     */
+    async getImageDataFromInput(imageInput) {
+        return getImageDataFromInput(imageInput);
+    }
+}

package/build/subclasses/ExportImportManager.mjs

@@ -51,7 +51,7 @@ class ExportImportManager {
         }
         if (passphrase) {
             await validatePassphraseStrength(this.libraryLoader, passphrase, this.passphraseExtraDict);
-            return encryptExport(await this.libraryLoader.getOpenPGPLib(), exportData, passphrase);
+            return encryptExport(this.libraryLoader.getOpenPGPLib(), exportData, passphrase);
         }
         return exportData;
     }
@@ -59,7 +59,7 @@ class ExportImportManager {
         return generateTextExport(this.vaultDataManager.getAllEntries());
     }
     async generateHtmlExport() {
-        const qrGeneratorLib = await this.libraryLoader.getQrGeneratorLib();
+        const qrGeneratorLib = this.libraryLoader.getQrGeneratorLib();
         return generateHtmlExport(qrGeneratorLib, this.vaultDataManager.getAllEntries());
     }
     /**
@@ -71,7 +71,7 @@ class ExportImportManager {
      */
     async importFromTextFile(fileContents, passphrase) {
         if (passphrase) {
-            const decrypted = await decryptExport(await this.libraryLoader.getOpenPGPLib(), fileContents, passphrase);
+            const decrypted = await decryptExport(this.libraryLoader.getOpenPGPLib(), fileContents, passphrase);
             return this.importFromTextFile(decrypted);
         }
         const lines = fileContents.trim().split('\n');

package/build/subclasses/LibraryLoader.d.mts

@@ -1,52 +1,66 @@
 import type CryptoLib from '../interfaces/CryptoLib.mjs';
+import type { PlatformProviders } from '../interfaces/PlatformProviders.mjs';
+import type { QrCodeLib } from '../interfaces/QrCodeLib.mjs';
+import type { OpenPgpLib } from '../interfaces/OpenPgpLib.mjs';
 /**
  * Class responsible for loading various external (big) libraries required by the application.
  * All libraries (except CryptoLib) are loaded on demand. This helps to reduce the initial bundle size.
  */
 declare class LibraryLoader {
+    private platformProviders;
     private cryptoLib;
     private openPgpLib?;
     private qrGeneratorLib?;
     private jsQrLib?;
-    private canvasLib?;
     private urlParserLib?;
     private zxcvbn?;
+    private webSocketLib?;
     /**
      * Constructs a new instance of LibraryLoader.
-     * @param cryptoLib - An instance of CryptoLib that is required for library operations.
-     * @throws {InitializationError} If the provided CryptoLib instance is invalid.
+     * @param platformProviders - Platform-specific providers containing CryptoLib and other providers.
+     * @throws {InitializationError} If the provided platform providers are invalid.
      */
-    constructor(cryptoLib: CryptoLib);
+    constructor(platformProviders: PlatformProviders);
     /**
      * @returns The CryptoLib instance.
      */
     getCryptoLib(): CryptoLib;
+    /**
+     * @returns The PlatformProviders instance.
+     */
+    getPlatformProviders(): PlatformProviders;
     /**
      * Loads and returns the OpenPGP library on demand.
      * @returns A promise that resolves to the OpenPGP library.
      */
-    getOpenPGPLib(): Promise<typeof import("openpgp")>;
+    getOpenPGPLib(): OpenPgpLib;
     /**
      * Loads and returns the QR Generator library on demand.
      * @returns A promise that resolves to the QR Generator library.
      */
-    getQrGeneratorLib(): Promise<typeof import("qrcode")>;
+    getQrGeneratorLib(): QrCodeLib;
     /**
      * Loads and returns the JsQR library on demand.
      * @returns A promise that resolves to the JsQR library.
      */
     getJsQrLib(): Promise<typeof import("jsqr").default>;
-    /**
-     * Loads and returns the Canvas library on demand.
-     * @returns A promise that resolves to the Canvas library.
-     * @throws {TwoFALibError} If the library cannot be loaded in a browser environment.
-     */
-    getCanvasLib(): Promise<typeof import("canvas")>;
     /**
      * Loads and returns the URL Parser library on demand.
      * @returns A promise that resolves to the URL Parser library.
      */
     getUrlParserLib(): Promise<typeof import("whatwg-url")>;
+    /**
+     * Loads and returns the WebSocket library on demand.
+     * @returns The WebSocket library.
+     */
+    getWebSocketLib(): {
+        new (url: string | URL, protocols?: string | string[]): WebSocket;
+        prototype: WebSocket;
+        readonly CONNECTING: 0;
+        readonly OPEN: 1;
+        readonly CLOSING: 2;
+        readonly CLOSED: 3;
+    };
     /**
      * Loads and returns the Zxcvbn library on demand.
      * @returns A promise that resolves to the Zxcvbn library.

package/build/subclasses/LibraryLoader.mjs

@@ -1,4 +1,4 @@
-import { InitializationError, TwoFALibError } from '../TwoFALibError.mjs';
+import { InitializationError } from '../TwoFALibError.mjs';
 /**
  * Class responsible for loading various external (big) libraries required by the application.
  * All libraries (except CryptoLib) are loaded on demand. This helps to reduce the initial bundle size.
@@ -6,14 +6,15 @@ import { InitializationError, TwoFALibError } from '../TwoFALibError.mjs';
 class LibraryLoader {
     /**
      * Constructs a new instance of LibraryLoader.
-     * @param cryptoLib - An instance of CryptoLib that is required for library operations.
-     * @throws {InitializationError} If the provided CryptoLib instance is invalid.
+     * @param platformProviders - Platform-specific providers containing CryptoLib and other providers.
+     * @throws {InitializationError} If the provided platform providers are invalid.
      */
-    constructor(cryptoLib) {
-        if (!cryptoLib) {
-            throw new InitializationError('CryptoLib is required');
+    constructor(platformProviders) {
+        if (!platformProviders?.CryptoLib) {
+            throw new InitializationError('PlatformProviders with CryptoLib is required');
         }
-        this.cryptoLib = cryptoLib;
+        this.platformProviders = platformProviders;
+        this.cryptoLib = new platformProviders.CryptoLib();
     }
     /**
      * @returns The CryptoLib instance.
@@ -21,28 +22,26 @@ class LibraryLoader {
     getCryptoLib() {
         return this.cryptoLib;
     }
+    /**
+     * @returns The PlatformProviders instance.
+     */
+    getPlatformProviders() {
+        return this.platformProviders;
+    }
     /**
      * Loads and returns the OpenPGP library on demand.
      * @returns A promise that resolves to the OpenPGP library.
      */
-    async getOpenPGPLib() {
-        if (!this.openPgpLib) {
-            const module = await import('openpgp');
-            // enable Authenticated Encryption with Associated Data
-            module.config.aeadProtect = true;
-            this.openPgpLib = module;
-        }
+    getOpenPGPLib() {
+        this.openPgpLib ??= new this.platformProviders.OpenPgpLib();
         return this.openPgpLib;
     }
     /**
      * Loads and returns the QR Generator library on demand.
      * @returns A promise that resolves to the QR Generator library.
      */
-    async getQrGeneratorLib() {
-        if (!this.qrGeneratorLib) {
-            const module = await import('qrcode');
-            this.qrGeneratorLib = module.default;
-        }
+    getQrGeneratorLib() {
+        this.qrGeneratorLib ??= new this.platformProviders.QrCodeLib();
         return this.qrGeneratorLib;
     }
     /**
@@ -56,21 +55,6 @@ class LibraryLoader {
         }
         return this.jsQrLib;
     }
-    /**
-     * Loads and returns the Canvas library on demand.
-     * @returns A promise that resolves to the Canvas library.
-     * @throws {TwoFALibError} If the library cannot be loaded in a browser environment.
-     */
-    async getCanvasLib() {
-        if (typeof window !== 'undefined') {
-            throw new TwoFALibError('Canvas lib can not be loaded in browser env');
-        }
-        if (!this.canvasLib) {
-            const module = await import('canvas');
-            this.canvasLib = module.default;
-        }
-        return this.canvasLib;
-    }
     /**
      * Loads and returns the URL Parser library on demand.
      * @returns A promise that resolves to the URL Parser library.
@@ -82,6 +66,14 @@ class LibraryLoader {
         }
         return this.urlParserLib;
     }
+    /**
+     * Loads and returns the WebSocket library on demand.
+     * @returns The WebSocket library.
+     */
+    getWebSocketLib() {
+        this.webSocketLib ??= this.platformProviders.WebSocketLib();
+        return this.webSocketLib;
+    }
     /**
      * Loads and returns the Zxcvbn library on demand.
      * @returns A promise that resolves to the Zxcvbn library.

package/build/subclasses/SyncManager.mjs

@@ -141,12 +141,13 @@ class SyncManager {
      * Initializes the WebSocket connection to the server.
      */
     initServerConnection() {
-        const ws = new WebSocket(this.serverUrl);
+        const WebSocketLib = this.libraryLoader.getWebSocketLib();
+        const ws = new WebSocketLib(this.serverUrl);
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const syncManager = this;
-        ws.addEventListener('error', (event) => {
-            // eslint-disable-next-line @typescript-eslint/no-base-to-string
-            syncManager.log('warning', `Error in websocket: ${event.toString()}`);
+        ws.addEventListener('error', () => {
+            // no error information seems to be available...
+            syncManager.log('warning', `Error in websocket.`);
         });
         ws.addEventListener('message', function message(message) {
             try {
@@ -326,7 +327,7 @@ class SyncManager {
         };
         let returnQr = null;
         if (returnAs.qr) {
-            const qrGeneratorLib = await this.libraryLoader.getQrGeneratorLib();
+            const qrGeneratorLib = this.libraryLoader.getQrGeneratorLib();
             returnQr = await qrGeneratorLib.toDataURL(JSON.stringify(returnData));
         }
         const returnText = returnAs.text
@@ -352,7 +353,7 @@ class SyncManager {
         if (this.activeAddDeviceFlow) {
             throw new SyncAddDeviceFlowConflictError();
         }
-        const { addDevicePassword, initiatorDeviceId, timestamp, pass1Result } = await decodeInitiatorData(initiatorData, initiatorDataType, await this.libraryLoader.getJsQrLib(), this.libraryLoader.getCanvasLib.bind(this));
+        const { addDevicePassword, initiatorDeviceId, timestamp, pass1Result } = await decodeInitiatorData(initiatorData, initiatorDataType, await this.libraryLoader.getJsQrLib(), this.libraryLoader.getQrGeneratorLib());
         if (!addDevicePassword ||
             !initiatorDeviceId ||
             !timestamp ||

package/build/utils/creationUtils.d.mts

@@ -1,5 +1,5 @@
 import type { ZxcvbnResult } from '@zxcvbn-ts/core';
-import type CryptoLib from '../interfaces/CryptoLib.mjs';
+import type { PlatformProviders } from '../interfaces/PlatformProviders.mjs';
 import type { Passphrase } from '../interfaces/CryptoLib.mjs';
 import type { DeviceType } from '../interfaces/SyncTypes.mjs';
 import TwoFaLib from '../TwoFaLib.mjs';
@@ -25,14 +25,14 @@ export declare const getPassphraseStrength: (libraryLoader: LibraryLoader, passp
 export declare const validatePassphraseStrength: (libraryLoader: LibraryLoader, passphrase: Passphrase, passphraseExtraDict: PassphraseExtraDict) => Promise<void>;
 /**
  * Returns utility functions useful in creating a new twoFaLib vault
- * @param cryptoLib - An instance of CryptoLib that is compatible with the environment.
+ * @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 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.
  */
-export declare const getTwoFaLibVaultCreationUtils: (cryptoLib: CryptoLib, deviceType: DeviceType, passphraseExtraDict: PassphraseExtraDict, saveFunction?: SaveFunction, serverUrl?: string) => {
+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<{
         twoFaLib: TwoFaLib;

package/build/utils/creationUtils.mjs

@@ -62,10 +62,11 @@ export const validatePassphraseStrength = async (libraryLoader, passphrase, pass
  */
 const createNewTwoFaLibVault = async (libraryLoader, deviceType, serverUrl, passphraseExtraDict, saveFunction, passphrase) => {
     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 deviceId = genUuidV4();
-    const twoFaLib = new TwoFaLib(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, {
+    const twoFaLib = new TwoFaLib(deviceType, platformProviders, passphraseExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, {
         deviceId,
     }, [], saveFunction, {
         serverUrl,
@@ -93,6 +94,7 @@ const createNewTwoFaLibVault = async (libraryLoader, deviceType, serverUrl, pass
  */
 const loadTwoFaLibFromLockedRepesentation = async (libraryLoader, deviceType, passphraseExtraDict, saveFunction, lockedRepresentationString, passphrase) => {
     const cryptoLib = libraryLoader.getCryptoLib();
+    const platformProviders = libraryLoader.getPlatformProviders();
     const lockedRepresentation = JSON.parse(lockedRepresentationString);
     if (!lockedRepresentation ||
         !lockedRepresentation.encryptedPrivateKey ||
@@ -109,22 +111,22 @@ const loadTwoFaLibFromLockedRepesentation = async (libraryLoader, deviceType, pa
         !vaultState.sync?.devices) {
         throw new InitializationError('encryptedVaultState is incomplete or corrupted');
     }
-    return new TwoFaLib(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, lockedRepresentation.encryptedPrivateKey, lockedRepresentation.encryptedSymmetricKey, lockedRepresentation.salt, publicKey, {
+    return new TwoFaLib(deviceType, platformProviders, passphraseExtraDict, privateKey, symmetricKey, lockedRepresentation.encryptedPrivateKey, lockedRepresentation.encryptedSymmetricKey, lockedRepresentation.salt, publicKey, {
         deviceId: vaultState.deviceId,
         deviceFriendlyName: vaultState.deviceFriendlyName,
     }, vaultState.vault, saveFunction, vaultState.sync);
 };
 /**
  * Returns utility functions useful in creating a new twoFaLib vault
- * @param cryptoLib - An instance of CryptoLib that is compatible with the environment.
+ * @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 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.
  */
-export const getTwoFaLibVaultCreationUtils = (cryptoLib, deviceType, passphraseExtraDict, saveFunction, serverUrl) => {
-    const libraryLoader = new LibraryLoader(cryptoLib);
+export const getTwoFaLibVaultCreationUtils = (platformProviders, deviceType, passphraseExtraDict, saveFunction, serverUrl) => {
+    const libraryLoader = new LibraryLoader(platformProviders);
     return {
         getPassphraseStrength: getPassphraseStrength.bind(null, libraryLoader),
         createNewTwoFaLibVault: createNewTwoFaLibVault.bind(null, libraryLoader, deviceType, serverUrl, passphraseExtraDict, saveFunction),

package/build/utils/exportImportUtils.d.mts

@@ -1,6 +1,8 @@
 import type { NewEntry } from '../interfaces/Entry.mjs';
 import type Entry from '../interfaces/Entry.mjs';
 import type { EntryId } from '../interfaces/Entry.mjs';
+import type { QrCodeLib } from '../interfaces/QrCodeLib.mjs';
+import type { OpenPgpLib } from '../interfaces/OpenPgpLib.mjs';
 /**
  * Parses an OTP URI and extracts the relevant information to create a new entry.
  * @param UrlParser - The URL parsing library.
@@ -15,7 +17,7 @@ export declare const parseOtpUri: (UrlParser: typeof import("whatwg-url"), otpUr
  * @param entries - An array of OTP entries.
  * @returns A promise that resolves to the HTML string.
  */
-export declare const generateHtmlExport: (qrGeneratorLib: typeof import("qrcode"), entries: Entry[]) => Promise<string>;
+export declare const generateHtmlExport: (qrGeneratorLib: QrCodeLib, entries: Entry[]) => Promise<string>;
 /**
  * Generates a text export of OTP URIs for the provided entries.
  * @param entries - An array of OTP entries.
@@ -42,7 +44,7 @@ export declare const processImportLines: (lines: string[], importFromUri: (uri:
  * @param password - The password to use for encryption.
  * @returns A promise that resolves to the encrypted data.
  */
-export declare const encryptExport: (openPgpLib: typeof import("openpgp"), data: string, password: string) => Promise<string>;
+export declare const encryptExport: (openPgpLib: OpenPgpLib, data: string, password: string) => Promise<string>;
 /**
  * Decrypts the given data using OpenPGP.
  * @param openPgpLib - The OpenPGP library.
@@ -50,4 +52,4 @@ export declare const encryptExport: (openPgpLib: typeof import("openpgp"), data:
  * @param password - The password to use for decryption.
  * @returns A promise that resolves to the decrypted data.
  */
-export declare const decryptExport: (openPgpLib: typeof import("openpgp"), data: string, password: string) => Promise<string>;
+export declare const decryptExport: (openPgpLib: OpenPgpLib, data: string, password: string) => Promise<string>;

package/build/utils/exportImportUtils.mjs

@@ -162,13 +162,7 @@ export const processImportLines = async (lines, importFromUri) => {
  * @returns A promise that resolves to the encrypted data.
  */
 export const encryptExport = async (openPgpLib, data, password) => {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const encrypted = await openPgpLib.encrypt({
-        message: await openPgpLib.createMessage({ text: data }),
-        passwords: [password],
-        format: 'armored',
-    });
-    return encrypted;
+    return openPgpLib.encrypt(data, password);
 };
 /**
  * Decrypts the given data using OpenPGP.
@@ -178,9 +172,5 @@ export const encryptExport = async (openPgpLib, data, password) => {
  * @returns A promise that resolves to the decrypted data.
  */
 export const decryptExport = async (openPgpLib, data, password) => {
-    const decrypted = await openPgpLib.decrypt({
-        message: await openPgpLib.readMessage({ armoredMessage: data }),
-        passwords: [password],
-    });
-    return decrypted.data;
+    return openPgpLib.decrypt(data, password);
 };

package/build/utils/qrUtils.d.mts

@@ -1,20 +1,4 @@
-import type { ImageData } from 'canvas';
 import LibraryLoader from '../subclasses/LibraryLoader.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 getImageDataBrowser: (input: string | File) => Promise<ImageData>;
-/**
- * Gets the ImageData from an image, for Node.js environments.
- * This ImageData is then further processed to get QR codes.
- * @param canvasLib - The Canvas library.
- * @param inputImage - The image to get the ImageData from.
- * @returns A promise that resolves to the ImageData.
- */
-export declare const getImageDataNode: (canvasLib: typeof import("canvas"), inputImage: Uint8Array | string) => Promise<ImageData>;
 /**
  * Import an entry from a QR code image.
  * @param libraryLoader - An instance of LibraryLoader.

package/build/utils/qrUtils.mjs

@@ -1,59 +1,4 @@
-import { isUint8Array } from 'uint8array-extras';
 import { TwoFALibError } from '../TwoFALibError.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 const getImageDataBrowser = (input) => {
-    return new Promise((resolve, reject) => {
-        const img = new Image();
-        img.onload = () => {
-            const canvas = document.createElement('canvas');
-            canvas.width = img.width;
-            canvas.height = img.height;
-            const ctx = canvas.getContext('2d');
-            if (!ctx) {
-                reject(new TwoFALibError('Could not create canvas context'));
-                return;
-            }
-            ctx.drawImage(img, 0, 0);
-            resolve(ctx.getImageData(0, 0, img.width, img.height));
-        };
-        img.onerror = () => reject(new TwoFALibError('Failed to load image'));
-        if (typeof input === 'string') {
-            // URL or Data URL
-            img.src = input;
-        }
-        else {
-            // File object
-            const reader = new FileReader();
-            reader.onload = (e) => {
-                img.src = e.target?.result;
-            };
-            reader.onerror = () => reject(new TwoFALibError('Failed to read file'));
-            reader.readAsDataURL(input);
-        }
-    });
-};
-/**
- * Gets the ImageData from an image, for Node.js environments.
- * This ImageData is then further processed to get QR codes.
- * @param canvasLib - The Canvas library.
- * @param inputImage - The image to get the ImageData from.
- * @returns A promise that resolves to the ImageData.
- */
-export const getImageDataNode = async (canvasLib, inputImage) => {
-    const { createCanvas, loadImage } = canvasLib;
-    // eslint-disable-next-line no-restricted-globals
-    const input = isUint8Array(inputImage) ? Buffer.from(inputImage) : inputImage;
-    const image = await loadImage(input); // canvaslib expects a buffer
-    const canvas = createCanvas(image.width, image.height);
-    const ctx = canvas.getContext('2d');
-    ctx.drawImage(image, 0, 0);
-    return ctx.getImageData(0, 0, image.width, image.height);
-};
 /**
  * Import an entry from a QR code image.
  * @param libraryLoader - An instance of LibraryLoader.
@@ -63,19 +8,8 @@ export const getImageDataNode = async (canvasLib, inputImage) => {
  */
 export const getDataFromQRImage = async (libraryLoader, imageInput) => {
     const jsQr = await libraryLoader.getJsQrLib();
-    let imageData;
-    if (typeof window !== 'undefined') {
-        // Browser environment
-        imageData = await getImageDataBrowser(imageInput);
-    }
-    else {
-        if (imageInput instanceof File) {
-            throw new TwoFALibError('Getting data from QR where image type is "File" is not supported in the node environment');
-        }
-        // Node.js environment
-        const canvasLib = await libraryLoader.getCanvasLib();
-        imageData = await getImageDataNode(canvasLib, imageInput);
-    }
+    const qrLib = libraryLoader.getQrGeneratorLib();
+    const imageData = await qrLib.getImageDataFromInput(imageInput);
     const qrCodeResult = jsQr(imageData.data, imageData.width, imageData.height);
     if (!qrCodeResult) {
         throw new TwoFALibError("Couldn't read QR code data from image");

package/build/utils/syncUtils.d.mts

@@ -1,13 +1,14 @@
 import { InitiateAddDeviceFlowResult } from '../interfaces/SyncTypes.mjs';
+import type { QrCodeLib } from '../interfaces/QrCodeLib.mjs';
 /**
  * Decodes the initiator data from a string or QR code.
  * @param initiatorData - The initiator data to decode.
  * @param initiatorDataType The type of the initiatorData, determines how it should be decoded
  * @param jsQr - The QR code decoder.
- * @param getCanvasLib - A function to get the Canvas library.
+ * @param qrCodeLib - The extended QR code library with platform-specific image processing.
  * @returns A promise that resolves to the decoded initiator data.
  */
-export declare const decodeInitiatorData: (initiatorData: string | Uint8Array | File, initiatorDataType: "text" | "qr", jsQr: typeof import("jsqr").default, getCanvasLib: () => Promise<typeof import("canvas")>) => Promise<InitiateAddDeviceFlowResult>;
+export declare const decodeInitiatorData: (initiatorData: string | Uint8Array | File, initiatorDataType: "text" | "qr", jsQr: typeof import("jsqr").default, qrCodeLib: QrCodeLib) => Promise<InitiateAddDeviceFlowResult>;
 /**
  * Converts a JSONified Uint8Array to a Uint8Array.
  * A JSONified Uint8Array is the output of JSON.stringify on a Uint8Array.

package/build/utils/syncUtils.mjs

@@ -1,33 +1,17 @@
 import { base64ToString } from 'uint8array-extras';
-import { getImageDataBrowser, getImageDataNode } from './qrUtils.mjs';
 import { SyncError } from '../TwoFALibError.mjs';
 /**
  * Decodes the initiator data from a string or QR code.
  * @param initiatorData - The initiator data to decode.
  * @param initiatorDataType The type of the initiatorData, determines how it should be decoded
  * @param jsQr - The QR code decoder.
- * @param getCanvasLib - A function to get the Canvas library.
+ * @param qrCodeLib - The extended QR code library with platform-specific image processing.
  * @returns A promise that resolves to the decoded initiator data.
  */
-export const decodeInitiatorData = async (initiatorData, initiatorDataType, jsQr, getCanvasLib) => {
+export const decodeInitiatorData = async (initiatorData, initiatorDataType, jsQr, qrCodeLib) => {
     if (initiatorDataType === 'qr') {
         try {
-            let imageData;
-            if (typeof window !== 'undefined') {
-                if (initiatorData instanceof Uint8Array) {
-                    throw new SyncError('Invalid initiator data type, should be a string or File in browser environment');
-                }
-                // Browser environment
-                imageData = await getImageDataBrowser(initiatorData);
-            }
-            else {
-                if (!(initiatorData instanceof Uint8Array)) {
-                    throw new SyncError('Invalid initiator data type, should be a Uint8Array in Node.js environment');
-                }
-                // Node.js environment
-                const canvasLib = await getCanvasLib();
-                imageData = await getImageDataNode(canvasLib, initiatorData);
-            }
+            const imageData = await qrCodeLib.getImageDataFromInput(initiatorData);
             const qrCodeResult = jsQr(imageData.data, imageData.width, imageData.height);
             if (!qrCodeResult) {
                 throw new SyncError('Invalid QR code');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "favalib",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "description": "",
   "type": "module",
   "exports": {
@@ -8,13 +8,13 @@
       "import": "./build/main.mjs",
       "types": "./build/main.d.mts"
     },
-    "./cryptoProviders/browser": {
-      "import": "./build/CryptoProviders/browser/index.mjs",
-      "types": "./build/CryptoProviders/browser/index.d.mts"
+    "./platformProviders/browser": {
+      "import": "./build/platformProviders/browser/index.mjs",
+      "types": "./build/platformProviders/browser/index.d.mts"
     },
-    "./cryptoProviders/node": {
-      "import": "./build/CryptoProviders/node/index.mjs",
-      "types": "./build/CryptoProviders/node/index.d.mts"
+    "./platformProviders/node": {
+      "import": "./build/platformProviders/node/index.mjs",
+      "types": "./build/platformProviders/node/index.d.mts"
     }
   },
   "types": "./build/main.d.mts",
@@ -39,6 +39,7 @@
     "@zxcvbn-ts/language-common": "^3.0.4",
     "@zxcvbn-ts/language-en": "^3.0.2",
     "canvas": "^3.1.0",
+    "esbuild": "^0.25.8",
     "hash-wasm": "^4.12.0",
     "jpake-ts": "^1.0.1",
     "jsqr": "^1.4.0",
@@ -48,7 +49,6 @@
     "totp-generator": "^1.0.0",
     "typescript-event-target": "^1.1.1",
     "uint8array-extras": "^1.4.0",
-    "unws": "^0.3.2",
     "uuid": "^11.1.0",
     "whatwg-url": "^14.2.0",
     "ws": "^8.18.2"