imzo-agnost 1.0.0 → 1.2.1

package/dist/index.mjs

@@ -30,6 +30,18 @@ var __decorateElement = (array, flags, name, decorators, target, extra) => {
   return __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
 };
 
+// polyfills/process-polyfill.js
+if (typeof globalThis !== "undefined" && typeof globalThis.process === "undefined") {
+  globalThis.process = {
+    env: {
+      NODE_ENV: "production"
+    },
+    versions: {
+      node: null
+    }
+  };
+}
+
 // src/e-imzo/capiws.ts
 var CAPIWS = typeof EIMZOEXT !== "undefined" ? EIMZOEXT : {
   URL: (window.location.protocol.toLowerCase() === "https:" ? "wss://127.0.0.1:64443" : "ws://127.0.0.1:64646") + "/service/cryptapi",
@@ -1094,12 +1106,383 @@ _init7 = __decoratorStart(_a7);
 IDCardPlugin = __decorateElement(_init7, 0, "IDCardPlugin", _IDCardPlugin_decorators, IDCardPlugin);
 __runInitializers(_init7, 1, IDCardPlugin);
 
+// src/core/session-manager.ts
+var EIMZOSessionManager = class {
+  config;
+  sessions = /* @__PURE__ */ new Map();
+  cleanupInterval = null;
+  constructor(config = {}) {
+    this.config = {
+      storageType: "sessionStorage",
+      autoUnloadAfter: 6 * 60 * 60 * 1e3,
+      // 6 hours default
+      keyPrefix: "eimzo_key_",
+      ...config
+    };
+    this.initializeFromStorage();
+    this.startCleanupTimer();
+  }
+  /**
+   * KeyId ni session storage ga saqlash
+   */
+  saveKeySession(keyId, certificateId, certificate, autoUnload = true) {
+    const now = Date.now();
+    const session = {
+      keyId,
+      certificateId,
+      loadedAt: now,
+      expiresAt: now + this.config.autoUnloadAfter,
+      certificate,
+      autoUnload
+    };
+    this.sessions.set(certificateId, session);
+    this.saveToStorage(certificateId, session);
+    console.log(
+      `\u{1F511} Key session saved: ${certificateId} (expires in ${this.config.autoUnloadAfter / 1e3 / 60} minutes)`
+    );
+  }
+  /**
+   * Certificate ID bo'yicha keyId ni olish
+   */
+  getKeyId(certificateId) {
+    const session = this.sessions.get(certificateId);
+    if (!session) {
+      this.loadFromStorage(certificateId);
+      return this.sessions.get(certificateId)?.keyId ?? null;
+    }
+    if (Date.now() > session.expiresAt) {
+      void this.removeKeySession(certificateId);
+      return null;
+    }
+    return session.keyId;
+  }
+  /**
+   * Barcha active key sessions ni olish
+   */
+  getActiveSessions() {
+    const now = Date.now();
+    const activeSessions = [];
+    for (const [certId, session] of this.sessions.entries()) {
+      if (now <= session.expiresAt) {
+        activeSessions.push(session);
+      } else {
+        void this.removeKeySession(certId);
+      }
+    }
+    return activeSessions;
+  }
+  /**
+   * Session ni kengaytirish (6 soat yana qo'shish)
+   */
+  extendSession(certificateId) {
+    const session = this.sessions.get(certificateId);
+    if (!session) return false;
+    const now = Date.now();
+    session.expiresAt = now + this.config.autoUnloadAfter;
+    void this.saveToStorage(certificateId, session);
+    console.log(`\u23F0 Session extended for ${certificateId}`);
+    return true;
+  }
+  /**
+   * Key session ni o'chirish
+   */
+  async removeKeySession(certificateId) {
+    const session = this.sessions.get(certificateId);
+    if (session) {
+      if (session.autoUnload) {
+        await this.unloadKeyFromEIMZO(session.keyId);
+      }
+      this.sessions.delete(certificateId);
+      this.removeFromStorage(certificateId);
+      console.log(`\u{1F5D1}\uFE0F Key session removed: ${certificateId}`);
+    }
+  }
+  /**
+   * Barcha sessionlarni tozalash
+   */
+  async clearAllSessions() {
+    const sessions = Array.from(this.sessions.keys());
+    for (const certId of sessions) {
+      await this.removeKeySession(certId);
+    }
+    console.log("\u{1F9F9} All key sessions cleared");
+  }
+  /**
+   * Storage configuration ni o'zgartirish
+   */
+  updateConfig(newConfig) {
+    this.config = { ...this.config, ...newConfig };
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+    }
+    this.startCleanupTimer();
+  }
+  // Private methods
+  saveToStorage(certificateId, session) {
+    const key = this.config.keyPrefix + certificateId;
+    const data = JSON.stringify(session);
+    try {
+      switch (this.config.storageType) {
+        case "sessionStorage":
+          if (typeof sessionStorage !== "undefined") {
+            sessionStorage.setItem(key, data);
+          }
+          break;
+        case "localStorage":
+          if (typeof localStorage !== "undefined") {
+            localStorage.setItem(key, data);
+          }
+          break;
+        case "cookie":
+          this.setCookie(key, data, session.expiresAt);
+          break;
+        case "memory":
+          break;
+      }
+    } catch (error) {
+      console.warn("Failed to save to storage:", error);
+    }
+  }
+  loadFromStorage(certificateId) {
+    const key = this.config.keyPrefix + certificateId;
+    try {
+      let data = null;
+      switch (this.config.storageType) {
+        case "sessionStorage":
+          if (typeof sessionStorage !== "undefined") {
+            data = sessionStorage.getItem(key);
+          }
+          break;
+        case "localStorage":
+          if (typeof localStorage !== "undefined") {
+            data = localStorage.getItem(key);
+          }
+          break;
+        case "cookie":
+          data = this.getCookie(key);
+          break;
+        case "memory":
+          return null;
+      }
+      if (data) {
+        const session = JSON.parse(data);
+        if (Date.now() > session.expiresAt) {
+          this.removeFromStorage(certificateId);
+          return null;
+        }
+        this.sessions.set(certificateId, session);
+        return session;
+      }
+    } catch (error) {
+      console.warn("Failed to load from storage:", error);
+    }
+    return null;
+  }
+  removeFromStorage(certificateId) {
+    const key = this.config.keyPrefix + certificateId;
+    try {
+      switch (this.config.storageType) {
+        case "sessionStorage":
+          if (typeof sessionStorage !== "undefined") {
+            sessionStorage.removeItem(key);
+          }
+          break;
+        case "localStorage":
+          if (typeof localStorage !== "undefined") {
+            localStorage.removeItem(key);
+          }
+          break;
+        case "cookie":
+          this.deleteCookie(key);
+          break;
+        case "memory":
+          break;
+      }
+    } catch (error) {
+      console.warn("Failed to remove from storage:", error);
+    }
+  }
+  initializeFromStorage() {
+    if (typeof window === "undefined") return;
+    try {
+      const keys = [];
+      switch (this.config.storageType) {
+        case "sessionStorage":
+          if (typeof sessionStorage !== "undefined") {
+            for (let i = 0; i < sessionStorage.length; i++) {
+              const key = sessionStorage.key(i);
+              if (key?.startsWith(this.config.keyPrefix)) {
+                keys.push(key);
+              }
+            }
+          }
+          break;
+        case "localStorage":
+          if (typeof localStorage !== "undefined") {
+            for (let i = 0; i < localStorage.length; i++) {
+              const key = localStorage.key(i);
+              if (key?.startsWith(this.config.keyPrefix)) {
+                keys.push(key);
+              }
+            }
+          }
+          break;
+        case "cookie":
+          break;
+      }
+      keys.forEach((key) => {
+        const certificateId = key.replace(this.config.keyPrefix, "");
+        this.loadFromStorage(certificateId);
+      });
+    } catch (error) {
+      console.warn("Failed to initialize from storage:", error);
+    }
+  }
+  startCleanupTimer() {
+    this.cleanupInterval = setInterval(
+      () => {
+        void this.cleanupExpiredSessions();
+      },
+      10 * 60 * 1e3
+    );
+  }
+  async cleanupExpiredSessions() {
+    const now = Date.now();
+    const expiredSessions = [];
+    for (const [certId, session] of this.sessions.entries()) {
+      if (now > session.expiresAt) {
+        expiredSessions.push(certId);
+      }
+    }
+    for (const certId of expiredSessions) {
+      await this.removeKeySession(certId);
+    }
+    if (expiredSessions.length > 0) {
+      console.log(`\u{1F552} Cleaned up ${expiredSessions.length} expired sessions`);
+    }
+  }
+  async unloadKeyFromEIMZO(keyId) {
+    try {
+      if (typeof window !== "undefined") {
+        const windowWithCAPiWS = window;
+        if (windowWithCAPiWS.CAPIWS) {
+          const CAPIWS2 = windowWithCAPiWS.CAPIWS;
+          return new Promise((resolve) => {
+            CAPIWS2.callFunction({
+              plugin: "pfx",
+              name: "unloadKey",
+              arguments: [keyId],
+              onSuccess: () => {
+                console.log(`\u{1F513} Key unloaded from E-IMZO: ${keyId}`);
+                resolve();
+              },
+              onError: (error, reason) => {
+                console.warn(`Failed to unload key ${keyId}:`, reason);
+                resolve();
+              }
+            });
+          });
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to unload key from E-IMZO:", error);
+    }
+  }
+  // Cookie utility methods
+  setCookie(name, value, expiresAt) {
+    if (typeof document === "undefined") return;
+    const expires = new Date(expiresAt).toUTCString();
+    const options = this.config.cookieOptions ?? {};
+    let cookieString = `${name}=${encodeURIComponent(value)}; expires=${expires}`;
+    if (options.domain) cookieString += `; domain=${options.domain}`;
+    if (options.path) cookieString += `; path=${options.path}`;
+    if (options.secure) cookieString += "; secure";
+    if (options.sameSite) cookieString += `; samesite=${options.sameSite}`;
+    document.cookie = cookieString;
+  }
+  getCookie(name) {
+    if (typeof document === "undefined") return null;
+    const nameEQ = name + "=";
+    const cookies = document.cookie.split(";");
+    for (let cookie of cookies) {
+      cookie = cookie.trim();
+      if (cookie.startsWith(nameEQ)) {
+        return decodeURIComponent(cookie.substring(nameEQ.length));
+      }
+    }
+    return null;
+  }
+  deleteCookie(name) {
+    if (typeof document === "undefined") return;
+    const options = this.config.cookieOptions ?? {};
+    let cookieString = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 UTC`;
+    if (options.domain) cookieString += `; domain=${options.domain}`;
+    if (options.path) cookieString += `; path=${options.path}`;
+    document.cookie = cookieString;
+  }
+  /**
+   * Cleanup when instance is destroyed
+   */
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+};
+var sessionManager = new EIMZOSessionManager();
+
 // src/plugins/pfx.ts
 var _PfxPlugin_decorators, _init8, _a8;
 _PfxPlugin_decorators = [RegisterPlugin];
 var PfxPlugin = class extends (_a8 = EIMZOPlugin) {
   name = "pfx";
-  description = "Plugin for working with PFX key storage files";
+  description = "Plugin for working with PFX key storage files with session management";
+  // Session management configuration
+  updateSessionConfig(config) {
+    sessionManager.updateConfig(config);
+  }
+  // Certificate cache for keyId lookup
+  certificateCache = /* @__PURE__ */ new Map();
+  /**
+   * Get keyId from certificate identifier
+   * Used for: await pfxPlugin.verifyPasswordAsync(keyId);
+   * @param certificateId - Format: "disk:path:name:alias" or just "alias"
+   * @returns keyId or null if not found
+   */
+  getKeyId(certificateId) {
+    return sessionManager.getKeyId(certificateId);
+  }
+  /**
+   * Get all active key sessions
+   */
+  getActiveSessions() {
+    return sessionManager.getActiveSessions();
+  }
+  /**
+   * Find certificate ID by partial match (alias, name, etc.)
+   */
+  findCertificateId(searchTerm) {
+    for (const [certId, cert] of this.certificateCache.entries()) {
+      if (cert.alias === searchTerm || cert.name === searchTerm || certId.includes(searchTerm)) {
+        return certId;
+      }
+    }
+    const sessions = sessionManager.getActiveSessions();
+    for (const session of sessions) {
+      if (session.certificateId.includes(searchTerm)) {
+        return session.certificateId;
+      }
+    }
+    return null;
+  }
+  /**
+   * Clear all sessions
+   */
+  async clearAllSessions() {
+    await sessionManager.clearAllSessions();
+    this.certificateCache.clear();
+  }
   // Callback-based methods
   /**
    * Get list of available disks
@@ -1120,10 +1503,60 @@ var PfxPlugin = class extends (_a8 = EIMZOPlugin) {
     this.callMethod("list_all_certificates", [], onSuccess, onError);
   };
   /**
-   * Load key and get key identifier
+   * Load key and get key identifier with session management
+   * @param disk - Storage disk name
+   * @param path - Path to PFX file
+   * @param name - File name
+   * @param alias - Certificate alias
+   * @param saveForHours - Save in session for automatic management (6 hours default)
    */
-  loadKey = (disk, path, name, alias, onSuccess, onError) => {
-    this.callMethod("load_key", [disk, path, name, alias], onSuccess, onError);
+  loadKey = (disk, path, name, alias, onSuccess, onError, saveForHours) => {
+    const originalOnSuccess = (event, response) => {
+      if (!response.data) return;
+      const keyResponse = response.data;
+      const certificateId = `${disk}:${path}:${name}:${alias}`;
+      const certificate = {
+        disk,
+        path,
+        name,
+        alias,
+        serialNumber: "",
+        subjectName: "",
+        validFromDate: "",
+        validToDate: "",
+        issuerName: "",
+        subjectId: "",
+        publicKeyAlgorithm: "",
+        signAlgorithm: "",
+        keyUsage: "",
+        extendedKeyUsage: "",
+        crlDistributionPoints: "",
+        authorityInfoAccess: "",
+        subjectAltName: "",
+        issuerAltName: "",
+        subjectKeyIdentifier: "",
+        authorityKeyIdentifier: "",
+        basicConstraints: "",
+        certificatePolicies: "",
+        keyUsageNonRepudiation: false,
+        keyUsageDigitalSignature: false,
+        keyUsageContentCommitment: false,
+        extendedKeyUsageTimeStamping: false
+      };
+      this.certificateCache.set(certificateId, certificate);
+      if (saveForHours && saveForHours > 0 && keyResponse.keyId) {
+        sessionManager.saveKeySession(
+          keyResponse.keyId,
+          certificateId,
+          certificate,
+          true
+          // Auto unload enabled
+        );
+        console.log(`\u{1F4BE} Key session saved for ${saveForHours} hours: ${certificateId}`);
+      }
+      onSuccess(event, response);
+    };
+    this.callMethod("load_key", [disk, path, name, alias], originalOnSuccess, onError);
   };
   /**
    * Unload key by identifier
@@ -1189,11 +1622,32 @@ var PfxPlugin = class extends (_a8 = EIMZOPlugin) {
    */
   listAllCertificatesAsync = this.createPromiseMethod("list_all_certificates");
   /**
-   * Load key (Promise version)
+   * Load key (Promise version) with session management
+   * @param disk Storage disk name
+   * @param path Path to PFX file
+   * @param name File name
+   * @param alias Certificate alias
+   * @param saveForHours Save in session for automatic management
    */
-  loadKeyAsync = this.createPromiseMethod(
-    "load_key"
-  );
+  loadKeyAsync = async (disk, path, name, alias, saveForHours) => {
+    return new Promise((resolve, reject) => {
+      this.loadKey(
+        disk,
+        path,
+        name,
+        alias,
+        (event, response) => {
+          if (response.success && response.data) {
+            resolve(response.data);
+          } else {
+            reject(new Error(response.reason ?? "Unknown error"));
+          }
+        },
+        reject,
+        saveForHours
+      );
+    });
+  };
   /**
    * Unload key (Promise version)
    */
@@ -1261,11 +1715,52 @@ _Pkcs7Plugin_decorators = [RegisterPlugin];
 var Pkcs7Plugin = class extends (_a10 = EIMZOPlugin) {
   name = "pkcs7";
   description = "Plugin for working with PKCS#7/CMS format";
+  // Utility method to check if string is base64
+  isBase64(str) {
+    try {
+      const base64Pattern = /^[A-Za-z0-9+/]*={0,2}$/;
+      if (!base64Pattern.test(str)) return false;
+      const decoded = atob(str);
+      const encoded = btoa(decoded);
+      return encoded === str;
+    } catch {
+      return false;
+    }
+  }
   // Callback-based methods
   /**
-   * Create PKCS#7/CMS document by signing with key
+   * Create PKCS#7/CMS document by signing with key (enhanced version)
+   * @param data - String data or already base64 encoded data
+   * @param keyId - Key identifier
+   * @param options - Creation options with smart defaults
+   */
+  createPkcs7Enhanced = (data, keyId, options = {}, onSuccess, onError) => {
+    const {
+      detached = false,
+      // Default to attached (no)
+      autoBase64 = true
+      // Default to auto base64 encoding
+    } = options;
+    let data64 = data;
+    if (autoBase64 && !this.isBase64(data)) {
+      try {
+        data64 = btoa(data);
+      } catch (_error) {
+        data64 = btoa(unescape(encodeURIComponent(data)));
+      }
+    }
+    let detachedParam = "";
+    if (typeof detached === "boolean") {
+      detachedParam = detached ? "yes" : "no";
+    } else {
+      detachedParam = detached;
+    }
+    this.callMethod("create_pkcs7", [data64, keyId, detachedParam], onSuccess, onError);
+  };
+  /**
+   * Create PKCS#7/CMS document by signing with key (original method)
    */
-  createPkcs7 = (data64, keyId, detached = "", onSuccess, onError) => {
+  createPkcs7 = (data64, keyId, detached = "no", onSuccess, onError) => {
     this.callMethod("create_pkcs7", [data64, keyId, detached], onSuccess, onError);
   };
   /**
@@ -1275,7 +1770,21 @@ var Pkcs7Plugin = class extends (_a10 = EIMZOPlugin) {
     this.callMethod("get_pkcs7_attached_info", [pkcs764, trustStoreId], onSuccess, onError);
   };
   /**
-   * Get full information about PKCS#7/CMS document (detached)
+   * Get full information about PKCS#7/CMS document (detached) with auto base64
+   */
+  getPkcs7DetachedInfoEnhanced = (data, pkcs764, trustStoreId = "", autoBase64 = true, onSuccess, onError) => {
+    let data64 = data;
+    if (autoBase64 && !this.isBase64(data)) {
+      try {
+        data64 = btoa(data);
+      } catch (_error) {
+        data64 = btoa(unescape(encodeURIComponent(data)));
+      }
+    }
+    this.callMethod("get_pkcs7_detached_info", [data64, pkcs764, trustStoreId], onSuccess, onError);
+  };
+  /**
+   * Get full information about PKCS#7/CMS document (detached) - original
    */
   getPkcs7DetachedInfo = (data64, pkcs764, trustStoreId = "", onSuccess, onError) => {
     this.callMethod("get_pkcs7_detached_info", [data64, pkcs764, trustStoreId], onSuccess, onError);
@@ -1291,6 +1800,25 @@ var Pkcs7Plugin = class extends (_a10 = EIMZOPlugin) {
       onError
     );
   };
+  /**
+   * Verify PKCS#7/CMS document (detached) with auto base64
+   */
+  verifyPkcs7DetachedEnhanced = (data, pkcs764, trustStoreId, requesterId = "", autoBase64 = true, onSuccess, onError) => {
+    let data64 = data;
+    if (autoBase64 && !this.isBase64(data)) {
+      try {
+        data64 = btoa(data);
+      } catch (_error) {
+        data64 = btoa(unescape(encodeURIComponent(data)));
+      }
+    }
+    this.callMethod(
+      "verify_pkcs7_detached",
+      [data64, pkcs764, trustStoreId, requesterId],
+      onSuccess,
+      onError
+    );
+  };
   /**
    * Verify PKCS#7/CMS document (detached) - STUB
    */
@@ -1349,9 +1877,32 @@ var Pkcs7Plugin = class extends (_a10 = EIMZOPlugin) {
   };
   // Promise-based methods
   /**
-   * Create PKCS#7/CMS document (Promise version)
+   * Create PKCS#7/CMS document (Enhanced Promise version)
+   * @param data String data (auto base64 encoded) or base64 data
+   * @param keyId Key identifier
+   * @param options Creation options with smart defaults
+   */
+  createPkcs7Async = async (data, keyId, options = {}) => {
+    return new Promise((resolve, reject) => {
+      this.createPkcs7Enhanced(
+        data,
+        keyId,
+        options,
+        (_event, response) => {
+          if (response.success && response.data) {
+            resolve(response.data);
+          } else {
+            reject(new Error(response.reason ?? "Unknown error"));
+          }
+        },
+        reject
+      );
+    });
+  };
+  /**
+   * Create PKCS#7/CMS document (Original Promise version for backward compatibility)
    */
-  createPkcs7Async = this.createPromiseMethod("create_pkcs7");
+  createPkcs7LegacyAsync = this.createPromiseMethod("create_pkcs7");
   /**
    * Get PKCS#7 attached info (Promise version)
    */
@@ -1359,17 +1910,60 @@ var Pkcs7Plugin = class extends (_a10 = EIMZOPlugin) {
     "get_pkcs7_attached_info"
   );
   /**
-   * Get PKCS#7 detached info (Promise version)
+   * Get PKCS#7 detached info (Enhanced Promise version)
+   */
+  getPkcs7DetachedInfoAsync = async (data, pkcs764, trustStoreId = "", autoBase64 = true) => {
+    return new Promise((resolve, reject) => {
+      this.getPkcs7DetachedInfoEnhanced(
+        data,
+        pkcs764,
+        trustStoreId,
+        autoBase64,
+        (_event, response) => {
+          if (response.success && response.data) {
+            resolve(response.data);
+          } else {
+            reject(new Error(response.reason ?? "Unknown error"));
+          }
+        },
+        reject
+      );
+    });
+  };
+  /**
+   * Get PKCS#7 detached info (Original Promise version)
    */
-  getPkcs7DetachedInfoAsync = this.createPromiseMethod("get_pkcs7_detached_info");
+  getPkcs7DetachedInfoLegacyAsync = this.createPromiseMethod("get_pkcs7_detached_info");
   /**
    * Verify PKCS#7 attached (Promise version)
    */
   verifyPkcs7AttachedAsync = this.createPromiseMethod("verify_pkcs7_attached");
   /**
-   * Verify PKCS#7 detached (Promise version)
+   * Verify PKCS#7 detached (Enhanced Promise version)
+   */
+  verifyPkcs7DetachedAsync = async (data, pkcs764, trustStoreId, requesterId = "", autoBase64 = true) => {
+    return new Promise((resolve, reject) => {
+      this.verifyPkcs7DetachedEnhanced(
+        data,
+        pkcs764,
+        trustStoreId,
+        requesterId,
+        autoBase64,
+        (_event, response) => {
+          if (response.success && response.data) {
+            resolve(response.data);
+          } else {
+            reject(new Error(response.reason ?? "Unknown error"));
+          }
+        },
+        reject
+      );
+    });
+  };
+  /**
+   * Verify PKCS#7 detached (Original Promise version)
    */
-  verifyPkcs7DetachedAsync = this.createPromiseMethod("verify_pkcs7_detached");
+  verifyPkcs7DetachedLegacyAsync = this.createPromiseMethod("verify_pkcs7_detached");
   /**
    * Attach timestamp token (Promise version)
    */
@@ -1770,38 +2364,11 @@ function setupGlobalObjects() {
     win.EIMZOClient = e_imzo_client_default;
     win.capiws = capiws_default;
     win.eimzoApi = eimzoApi;
-    const processEnv = process.env;
-    const isDev = typeof process !== "undefined" && processEnv.NODE_ENV === "development";
-    if (isDev) {
-      win.imzoPlugins = {
-        version: "1.0.0",
-        loaded: true,
-        plugins: [],
-        debug: true
-      };
-      console.info("\u{1F527} E-IMZO Agnostic Library - Development Mode");
-      console.info("Available APIs:", {
-        CAPIWS: "Main CAPIWS client for E-IMZO communication",
-        EIMZOClient: "Legacy E-IMZO client wrapper",
-        capiws: "Legacy alias for CAPIWS",
-        eimzoApi: "Modern plugin-based E-IMZO API",
-        imzoPlugins: "Plugin system information"
-      });
-    }
-    if (isDev) {
-      console.info("\u2705 E-IMZO Global Setup - Success");
-      console.info("Global status:", {
-        CAPIWS: Boolean(win.CAPIWS),
-        EIMZOClient: Boolean(win.EIMZOClient),
-        capiws: Boolean(win.capiws),
-        eimzoApi: Boolean(win.eimzoApi),
-        imzoPlugins: Boolean(win.imzoPlugins)
-      });
-    }
+    typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions.node);
   }
 }
 setupGlobalObjects();
 
-export { capiws_default as CAPIWS, EIMZOApi, e_imzo_client_default as EIMZOClient, EIMZOPlugin, PluginManager, dates, eimzo_api_default as eimzoApi, ftjcPlugin, pfxPlugin, pkcs7Plugin };
+export { capiws_default as CAPIWS, EIMZOApi, e_imzo_client_default as EIMZOClient, EIMZOPlugin, EIMZOSessionManager, PluginManager, dates, eimzo_api_default as eimzoApi, ftjcPlugin, pfxPlugin, pkcs7Plugin, sessionManager };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map