shogun-core 6.2.3 → 6.3.0

package/dist/{core.js → src/core.js}

@@ -1,12 +1,45 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ShogunCore = void 0;
-const errorHandler_1 = require("./utils/errorHandler");
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { ErrorHandler } from "./utils/errorHandler.js";
 // Import managers
-const PluginManager_1 = require("./managers/PluginManager");
-const AuthManager_1 = require("./managers/AuthManager");
-const EventManager_1 = require("./managers/EventManager");
-const CoreInitializer_1 = require("./managers/CoreInitializer");
+import { PluginManager } from "./managers/PluginManager.js";
+import { AuthManager } from "./managers/AuthManager.js";
+import { EventManager } from "./managers/EventManager.js";
+import { CoreInitializer } from "./managers/CoreInitializer.js";
 /**
  * Main ShogunCore class - implements the IShogunCore interface
  *
@@ -18,7 +51,7 @@ const CoreInitializer_1 = require("./managers/CoreInitializer");
  *
  * @since 2.0.0
  */
-class ShogunCore {
+var ShogunCore = /** @class */ (function () {
     /**
      * Initialize the Shogun SDK
      * @param config - SDK Configuration object
@@ -26,45 +59,53 @@ class ShogunCore {
      * Initializes all required components including storage, event emitter, GunInstance connection,
      * and plugin system.
      */
-    constructor(config) {
+    function ShogunCore(config) {
         this._user = null;
         this.config = config;
         // Initialize managers
-        this.eventManager = new EventManager_1.EventManager();
-        this.pluginManager = new PluginManager_1.PluginManager(this);
-        this.authManager = new AuthManager_1.AuthManager(this);
-        this.coreInitializer = new CoreInitializer_1.CoreInitializer(this);
+        this.eventManager = new EventManager();
+        this.pluginManager = new PluginManager(this);
+        this.authManager = new AuthManager(this);
+        this.coreInitializer = new CoreInitializer(this);
         // Initialize async components
-        this.coreInitializer.initialize(config).catch((error) => {
+        this.coreInitializer.initialize(config).catch(function (error) {
             if (typeof console !== "undefined" && console.warn) {
                 console.warn("Error during async initialization:", error);
             }
         });
     }
-    /**
-     * Access to the Gun instance
-     * @returns The Gun instance
-     */
-    get gun() {
-        return this._gun;
-    }
-    /**
-     * Access to the current user
-     * @returns The current Gun user instance
-     */
-    get user() {
-        return this._user;
-    }
+    Object.defineProperty(ShogunCore.prototype, "gun", {
+        /**
+         * Access to the Gun instance
+         * @returns The Gun instance
+         */
+        get: function () {
+            return this._gun;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ShogunCore.prototype, "user", {
+        /**
+         * Access to the current user
+         * @returns The current Gun user instance
+         */
+        get: function () {
+            return this._user;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * Gets the current user information
      * @returns Current user object or null
      */
-    getCurrentUser() {
+    ShogunCore.prototype.getCurrentUser = function () {
         if (!this.db) {
             return null;
         }
         return this.db.getCurrentUser();
-    }
+    };
     // *********************************************************************************************************
     // 🔌 PLUGIN MANAGEMENT 🔌
     // *********************************************************************************************************
@@ -73,99 +114,99 @@ class ShogunCore {
      * @param plugin Plugin instance to register
      * @throws Error if a plugin with the same name is already registered
      */
-    register(plugin) {
+    ShogunCore.prototype.register = function (plugin) {
         this.pluginManager.register(plugin);
-    }
+    };
     /**
      * Unregisters a plugin from the Shogun SDK
      * @param pluginName Name of the plugin to unregister
      */
-    unregister(pluginName) {
+    ShogunCore.prototype.unregister = function (pluginName) {
         this.pluginManager.unregister(pluginName);
-    }
+    };
     /**
      * Retrieve a registered plugin by name
      * @param name Name of the plugin
      * @returns The requested plugin or undefined if not found
      * @template T Type of the plugin or its public interface
      */
-    getPlugin(name) {
+    ShogunCore.prototype.getPlugin = function (name) {
         return this.pluginManager.getPlugin(name);
-    }
+    };
     /**
      * Get information about all registered plugins
      * @returns Array of plugin information objects
      */
-    getPluginsInfo() {
+    ShogunCore.prototype.getPluginsInfo = function () {
         return this.pluginManager.getPluginsInfo();
-    }
+    };
     /**
      * Get the total number of registered plugins
      * @returns Number of registered plugins
      */
-    getPluginCount() {
+    ShogunCore.prototype.getPluginCount = function () {
         return this.pluginManager.getPluginCount();
-    }
+    };
     /**
      * Check if all plugins are properly initialized
      * @returns Object with initialization status for each plugin
      */
-    getPluginsInitializationStatus() {
+    ShogunCore.prototype.getPluginsInitializationStatus = function () {
         return this.pluginManager.getPluginsInitializationStatus();
-    }
+    };
     /**
      * Validate plugin system integrity
      * @returns Object with validation results
      */
-    validatePluginSystem() {
+    ShogunCore.prototype.validatePluginSystem = function () {
         return this.pluginManager.validatePluginSystem();
-    }
+    };
     /**
      * Attempt to reinitialize failed plugins
      * @returns Object with reinitialization results
      */
-    reinitializeFailedPlugins() {
+    ShogunCore.prototype.reinitializeFailedPlugins = function () {
         return this.pluginManager.reinitializeFailedPlugins();
-    }
+    };
     /**
      * Check plugin compatibility with current ShogunCore version
      * @returns Object with compatibility information
      */
-    checkPluginCompatibility() {
+    ShogunCore.prototype.checkPluginCompatibility = function () {
         return this.pluginManager.checkPluginCompatibility();
-    }
+    };
     /**
      * Get comprehensive debug information about the plugin system
      * @returns Complete plugin system debug information
      */
-    getPluginSystemDebugInfo() {
+    ShogunCore.prototype.getPluginSystemDebugInfo = function () {
         return this.pluginManager.getPluginSystemDebugInfo();
-    }
+    };
     /**
      * Check if a plugin is registered
      * @param name Name of the plugin to check
      * @returns true if the plugin is registered, false otherwise
      */
-    hasPlugin(name) {
+    ShogunCore.prototype.hasPlugin = function (name) {
         return this.pluginManager.hasPlugin(name);
-    }
+    };
     /**
      * Get all plugins of a specific category
      * @param category Category of plugins to filter
      * @returns Array of plugins in the specified category
      */
-    getPluginsByCategory(category) {
+    ShogunCore.prototype.getPluginsByCategory = function (category) {
         return this.pluginManager.getPluginsByCategory(category);
-    }
+    };
     /**
      * Get an authentication method plugin by type
      * @param type The type of authentication method
      * @returns The authentication plugin or undefined if not available
      * This is a more modern approach to accessing authentication methods
      */
-    getAuthenticationMethod(type) {
+    ShogunCore.prototype.getAuthenticationMethod = function (type) {
         return this.authManager.getAuthenticationMethod(type);
-    }
+    };
     // *********************************************************************************************************
     // 🔐 ERROR HANDLER 🔐
     // *********************************************************************************************************
@@ -174,9 +215,10 @@ class ShogunCore {
      * @param count - Number of errors to retrieve (default: 10)
      * @returns List of most recent errors
      */
-    getRecentErrors(count = 10) {
-        return errorHandler_1.ErrorHandler.getRecentErrors(count);
-    }
+    ShogunCore.prototype.getRecentErrors = function (count) {
+        if (count === void 0) { count = 10; }
+        return ErrorHandler.getRecentErrors(count);
+    };
     // *********************************************************************************************************
     // 🔐 AUTHENTICATION
     // *********************************************************************************************************
@@ -186,17 +228,17 @@ class ShogunCore {
      * @description Verifies authentication status by checking GunInstance login state
      * and presence of authentication credentials in storage
      */
-    isLoggedIn() {
+    ShogunCore.prototype.isLoggedIn = function () {
         return this.authManager.isLoggedIn();
-    }
+    };
     /**
      * Perform user logout
      * @description Logs out the current user from GunInstance and emits logout event.
      * If user is not authenticated, the logout operation is ignored.
      */
-    logout() {
+    ShogunCore.prototype.logout = function () {
         this.authManager.logout();
-    }
+    };
     /**
      * Authenticate user with username and password
      * @param username - Username
@@ -205,9 +247,13 @@ class ShogunCore {
      * @description Attempts to log in user with provided credentials.
      * Emits login event on success.
      */
-    async login(username, password, pair) {
-        return this.authManager.login(username, password, pair);
-    }
+    ShogunCore.prototype.login = function (username, password, pair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.authManager.login(username, password, pair)];
+            });
+        });
+    };
     /**
      * Login with GunDB pair directly
      * @param pair - GunDB SEA pair for authentication
@@ -215,9 +261,13 @@ class ShogunCore {
      * @description Authenticates user using a GunDB pair directly.
      * Emits login event on success.
      */
-    async loginWithPair(username, pair) {
-        return this.authManager.loginWithPair(username, pair);
-    }
+    ShogunCore.prototype.loginWithPair = function (username, pair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.authManager.loginWithPair(username, pair)];
+            });
+        });
+    };
     /**
      * Register a new user with provided credentials
      * @param username - Username
@@ -228,9 +278,13 @@ class ShogunCore {
      * @description Creates a new user account with the provided credentials.
      * Validates password requirements and emits signup event on success.
      */
-    async signUp(username, password, pair) {
-        return this.authManager.signUp(username, password, pair);
-    }
+    ShogunCore.prototype.signUp = function (username, password, pair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.authManager.signUp(username, password, pair)];
+            });
+        });
+    };
     // 📢 EVENT EMITTER 📢
     /**
      * Emits an event through the core's event emitter.
@@ -239,91 +293,97 @@ class ShogunCore {
      * @param data The data to pass with the event.
      * @returns {boolean} Indicates if the event had listeners.
      */
-    emit(eventName, data) {
+    ShogunCore.prototype.emit = function (eventName, data) {
         return this.eventManager.emit(eventName, data);
-    }
+    };
     /**
      * Add an event listener
      * @param eventName The name of the event to listen for
      * @param listener The callback function to execute when the event is emitted
      * @returns {this} Returns this instance for method chaining
      */
-    on(eventName, listener) {
+    ShogunCore.prototype.on = function (eventName, listener) {
         this.eventManager.on(eventName, listener);
         return this;
-    }
+    };
     /**
      * Add a one-time event listener
      * @param eventName The name of the event to listen for
      * @param listener The callback function to execute when the event is emitted
      * @returns {this} Returns this instance for method chaining
      */
-    once(eventName, listener) {
+    ShogunCore.prototype.once = function (eventName, listener) {
         this.eventManager.once(eventName, listener);
         return this;
-    }
+    };
     /**
      * Remove an event listener
      * @param eventName The name of the event to stop listening for
      * @param listener The callback function to remove
      * @returns {this} Returns this instance for method chaining
      */
-    off(eventName, listener) {
+    ShogunCore.prototype.off = function (eventName, listener) {
         this.eventManager.off(eventName, listener);
         return this;
-    }
+    };
     /**
      * Remove all listeners for a specific event or all events
      * @param eventName Optional. The name of the event to remove listeners for.
      * If not provided, all listeners for all events are removed.
      * @returns {this} Returns this instance for method chaining
      */
-    removeAllListeners(eventName) {
+    ShogunCore.prototype.removeAllListeners = function (eventName) {
         this.eventManager.removeAllListeners(eventName);
         return this;
-    }
+    };
     /**
      * Set the current authentication method
      * This is used by plugins to indicate which authentication method was used
      * @param method The authentication method used
      */
-    setAuthMethod(method) {
+    ShogunCore.prototype.setAuthMethod = function (method) {
         this.authManager.setAuthMethod(method);
-    }
+    };
     /**
      * Get the current authentication method
      * @returns The current authentication method or undefined if not set
      */
-    getAuthMethod() {
+    ShogunCore.prototype.getAuthMethod = function () {
         return this.authManager.getAuthMethod();
-    }
+    };
     /**
      * Saves the current user credentials to storage
      */
-    async saveCredentials(credentials) {
-        try {
-            this.storage.setItem("userCredentials", JSON.stringify(credentials));
-        }
-        catch (error) {
-            if (typeof console !== "undefined" && console.warn) {
-                console.warn("Failed to save credentials to storage");
-            }
-            if (typeof console !== "undefined" && console.error) {
-                console.error(`Error saving credentials:`, error);
-            }
-        }
-    }
-    getIsLoggedIn() {
+    ShogunCore.prototype.saveCredentials = function (credentials) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                try {
+                    this.storage.setItem("userCredentials", JSON.stringify(credentials));
+                }
+                catch (error) {
+                    if (typeof console !== "undefined" && console.warn) {
+                        console.warn("Failed to save credentials to storage");
+                    }
+                    if (typeof console !== "undefined" && console.error) {
+                        console.error("Error saving credentials:", error);
+                    }
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    ShogunCore.prototype.getIsLoggedIn = function () {
         return !!(this.user && this.user.is);
-    }
-}
-exports.ShogunCore = ShogunCore;
-ShogunCore.API_VERSION = "^6.2.1";
+    };
+    ShogunCore.API_VERSION = "^6.2.1";
+    return ShogunCore;
+}());
+export { ShogunCore };
 // Global declarations are handled in the original core.ts file
 // to avoid conflicts, we only set the window properties here
 if (typeof window !== "undefined") {
-    window.Shogun = (config) => {
+    window.Shogun = function (config) {
         return new ShogunCore(config);
     };
 }
-exports.default = ShogunCore;
+export default ShogunCore;

package/dist/src/crypto/asymmetric.js

@@ -0,0 +1,168 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { arrayBufferToBase64, base64ToArrayBuffer } from "./hashing.js";
+// RSA Key Generation and Encryption/Decryption Methods
+export var generateKeyPair = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var keyPair, publicKeyJWK, privateKeyJWK, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 4, , 5]);
+                return [4 /*yield*/, crypto.subtle.generateKey({
+                        name: "RSA-OAEP",
+                        modulusLength: 4096, // Can be 1024, 2048, or 4096
+                        publicExponent: new Uint8Array([1, 0, 1]), // 65537 in bytes
+                        hash: "SHA-256", // Can be "SHA-1", "SHA-256", "SHA-384", or "SHA-512"
+                    }, true, // Whether the key is extractable
+                    ["encrypt", "decrypt"])];
+            case 1:
+                keyPair = _a.sent();
+                return [4 /*yield*/, crypto.subtle.exportKey("jwk", keyPair.publicKey)];
+            case 2:
+                publicKeyJWK = _a.sent();
+                return [4 /*yield*/, crypto.subtle.exportKey("jwk", keyPair.privateKey)];
+            case 3:
+                privateKeyJWK = _a.sent();
+                return [2 /*return*/, {
+                        publicKey: publicKeyJWK,
+                        privateKey: privateKeyJWK,
+                    }];
+            case 4:
+                error_1 = _a.sent();
+                console.error("Error generating key pair:", error_1);
+                throw error_1;
+            case 5: return [2 /*return*/];
+        }
+    });
+}); };
+export var deserializePublicKey = function (key) { return __awaiter(void 0, void 0, void 0, function () {
+    var jwkKey, publicKey, error_2;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 2, , 3]);
+                jwkKey = typeof key === "string" ? JSON.parse(key) : key;
+                // Validate that required JWK properties exist
+                if (!jwkKey.kty) {
+                    throw new Error('Invalid JWK: missing "kty" property');
+                }
+                return [4 /*yield*/, crypto.subtle.importKey("jwk", // Import format
+                    jwkKey, // The key in JWK format
+                    {
+                        name: "RSA-OAEP", // Algorithm name
+                        hash: "SHA-256", // Hash algorithm
+                    }, true, // Extractable flag
+                    ["encrypt"])];
+            case 1:
+                publicKey = _a.sent();
+                return [2 /*return*/, publicKey];
+            case 2:
+                error_2 = _a.sent();
+                console.error("Error deserializing public key:", error_2);
+                throw error_2;
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+export var deserializePrivateKey = function (key) { return __awaiter(void 0, void 0, void 0, function () {
+    var jwkKey, privateKey, error_3;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 2, , 3]);
+                jwkKey = typeof key === "string" ? JSON.parse(key) : key;
+                // Validate that required JWK properties exist
+                if (!jwkKey.kty) {
+                    throw new Error('Invalid JWK: missing "kty" property');
+                }
+                return [4 /*yield*/, crypto.subtle.importKey("jwk", // Import format
+                    jwkKey, // The key in JWK format
+                    {
+                        name: "RSA-OAEP", // Algorithm name
+                        hash: "SHA-256", // Hash algorithm
+                    }, true, // Extractable flag
+                    ["decrypt"])];
+            case 1:
+                privateKey = _a.sent();
+                return [2 /*return*/, privateKey];
+            case 2:
+                error_3 = _a.sent();
+                console.error("Error deserializing private key:", error_3);
+                throw error_3;
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+export var encrypt = function (message, publicKey) { return __awaiter(void 0, void 0, void 0, function () {
+    var encodedMessage, encrypted;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                encodedMessage = new TextEncoder().encode(message);
+                return [4 /*yield*/, crypto.subtle.encrypt({
+                        name: "RSA-OAEP",
+                    }, publicKey, encodedMessage)];
+            case 1:
+                encrypted = _a.sent();
+                return [2 /*return*/, arrayBufferToBase64(encrypted)];
+        }
+    });
+}); };
+export var decrypt = function (encryptedMessage, privateKey) { return __awaiter(void 0, void 0, void 0, function () {
+    var buffer, decrypted, message, error_4;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                buffer = base64ToArrayBuffer(encryptedMessage);
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, crypto.subtle.decrypt({
+                        name: "RSA-OAEP",
+                    }, privateKey, buffer)];
+            case 2:
+                decrypted = _a.sent();
+                message = new TextDecoder().decode(decrypted);
+                return [2 /*return*/, message];
+            case 3:
+                error_4 = _a.sent();
+                console.error("Decryption error:", error_4);
+                throw new Error("Unable to decrypt message. Incorrect private key.");
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };