favalib 0.0.10 → 0.0.12

package/build/Command/commandConstructors.d.mts

@@ -2,12 +2,12 @@ import AddEntryCommand from './commands/AddEntryCommand.mjs';
 import AddSyncDeviceCommand from './commands/AddSyncDeviceCommand.mjs';
 import DeleteEntryCommand from './commands/DeleteEntryCommand.mjs';
 import UpdateEntryCommand from './commands/UpdateEntryCommand.mjs';
-import ChangeSyncDeviceInfoCommand from './commands/ChangeDeviceInfoCommand.mjs';
+import ChangeDeviceInfoCommand from './commands/ChangeDeviceInfoCommand.mjs';
 declare const commandConstructors: {
     AddEntry: typeof AddEntryCommand;
     DeleteEntry: typeof DeleteEntryCommand;
     UpdateEntry: typeof UpdateEntryCommand;
     AddSyncDevice: typeof AddSyncDeviceCommand;
-    ChangeSyncDeviceInfo: typeof ChangeSyncDeviceInfoCommand;
+    ChangeDeviceInfo: typeof ChangeDeviceInfoCommand;
 };
 export default commandConstructors;

package/build/Command/commandConstructors.mjs

@@ -2,12 +2,12 @@ import AddEntryCommand from './commands/AddEntryCommand.mjs';
 import AddSyncDeviceCommand from './commands/AddSyncDeviceCommand.mjs';
 import DeleteEntryCommand from './commands/DeleteEntryCommand.mjs';
 import UpdateEntryCommand from './commands/UpdateEntryCommand.mjs';
-import ChangeSyncDeviceInfoCommand from './commands/ChangeDeviceInfoCommand.mjs';
+import ChangeDeviceInfoCommand from './commands/ChangeDeviceInfoCommand.mjs';
 const commandConstructors = {
     AddEntry: AddEntryCommand,
     DeleteEntry: DeleteEntryCommand,
     UpdateEntry: UpdateEntryCommand,
     AddSyncDevice: AddSyncDeviceCommand,
-    ChangeSyncDeviceInfo: ChangeSyncDeviceInfoCommand,
+    ChangeDeviceInfo: ChangeDeviceInfoCommand,
 };
 export default commandConstructors;

package/build/Command/commands/ChangeDeviceInfoCommand.d.mts

@@ -1,7 +1,7 @@
 import type TwoFaLibMediator from '../../TwoFaLibMediator.mjs';
 import Command from '../BaseCommand.mjs';
 import type { DeviceFriendlyName, DeviceId, DeviceType } from '../../interfaces/SyncTypes.mjs';
-export interface ChangeSyncDeviceInfoData {
+export interface ChangeDeviceInfoData {
     deviceId: DeviceId;
     newDeviceInfo: {
         deviceFriendlyName?: DeviceFriendlyName;
@@ -11,17 +11,17 @@ export interface ChangeSyncDeviceInfoData {
 /**
  * Represents a command that when executed changes the device info of a sync device
  */
-declare class ChangeDeviceInfoCommand extends Command<ChangeSyncDeviceInfoData> {
+declare class ChangeDeviceInfoCommand extends Command<ChangeDeviceInfoData> {
     /**
-     * Creates a new ChangeSyncDeviceMetaCommand instance.
+     * Creates a new ChangeDeviceMetaCommand instance.
      * @inheritdoc
      * @param data - The id of the device to change and the new meta info
      */
-    constructor(data: ChangeSyncDeviceInfoData, id?: string, timestamp?: number, version?: string, fromRemote?: boolean);
+    constructor(data: ChangeDeviceInfoData, id?: string, timestamp?: number, version?: string, fromRemote?: boolean);
     /**
-     * Executes the command to change the sync device info
+     * Executes the command to change the device info
      * @inheritdoc
-     * @throws {InvalidCommandError} If the referenced sync device cannot be found
+     * @throws {InvalidCommandError} If the referenced device cannot be found
      */
     execute(mediator: TwoFaLibMediator): Promise<void>;
     /**

package/build/Command/commands/ChangeDeviceInfoCommand.mjs

@@ -5,7 +5,7 @@ import Command from '../BaseCommand.mjs';
  */
 class ChangeDeviceInfoCommand extends Command {
     /**
-     * Creates a new ChangeSyncDeviceMetaCommand instance.
+     * Creates a new ChangeDeviceMetaCommand instance.
      * @inheritdoc
      * @param data - The id of the device to change and the new meta info
      */
@@ -13,9 +13,9 @@ class ChangeDeviceInfoCommand extends Command {
         super('ChangeDeviceInfo', data, id, timestamp, version, fromRemote);
     }
     /**
-     * Executes the command to change the sync device info
+     * Executes the command to change the device info
      * @inheritdoc
-     * @throws {InvalidCommandError} If the referenced sync device cannot be found
+     * @throws {InvalidCommandError} If the referenced device cannot be found
      */
     async execute(mediator) {
         if (!this.validate(mediator)) {

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

@@ -2,7 +2,7 @@ import type { AddEntryData } from '../Command/commands/AddEntryCommand.mjs';
 import type { DeleteEntryData } from '../Command/commands/DeleteEntryCommand.mjs';
 import type { UpdateEntryData } from '../Command/commands/UpdateEntryCommand.mjs';
 import type { AddSyncDeviceData } from '../Command/commands/AddSyncDeviceCommand.mjs';
-import type { ChangeSyncDeviceInfoData } from '../Command/commands/ChangeDeviceInfoCommand.mjs';
+import type { ChangeDeviceInfoData } from '../Command/commands/ChangeDeviceInfoCommand.mjs';
 export type SyncCommand = ({
     type: 'AddEntry';
     data: AddEntryData;
@@ -16,9 +16,9 @@ export type SyncCommand = ({
     type: 'AddSyncDevice';
     data: AddSyncDeviceData;
 } | {
-    type: 'ChangeSyncDeviceInfo';
-    data: ChangeSyncDeviceInfoData;
+    type: 'ChangeDeviceInfo';
+    data: ChangeDeviceInfoData;
 }) & {
     id: string;
 };
-export type CommandData = AddEntryData | DeleteEntryData | UpdateEntryData | AddSyncDeviceData | ChangeSyncDeviceInfoData;
+export type CommandData = AddEntryData | DeleteEntryData | UpdateEntryData | AddSyncDeviceData | ChangeDeviceInfoData;

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