imzo-agnost 1.0.0 → 1.2.1

package/dist/index.js

@@ -33,6 +33,18 @@ var EIMZOAgnost = (function (exports) {
     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",
@@ -1097,12 +1109,383 @@ var EIMZOAgnost = (function (exports) {
   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
@@ -1123,10 +1506,60 @@ var EIMZOAgnost = (function (exports) {
       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
@@ -1192,11 +1625,32 @@ var EIMZOAgnost = (function (exports) {
      */
     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)
      */
@@ -1264,11 +1718,52 @@ var EIMZOAgnost = (function (exports) {
   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);
     };
     /**
@@ -1278,7 +1773,21 @@ var EIMZOAgnost = (function (exports) {
       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);
@@ -1294,6 +1803,25 @@ var EIMZOAgnost = (function (exports) {
         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
      */
@@ -1352,9 +1880,32 @@ var EIMZOAgnost = (function (exports) {
     };
     // 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)
      */
@@ -1362,17 +1913,60 @@ var EIMZOAgnost = (function (exports) {
       "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)
      */
@@ -1773,34 +2367,7 @@ var EIMZOAgnost = (function (exports) {
       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();
@@ -1809,12 +2376,14 @@ var EIMZOAgnost = (function (exports) {
   exports.EIMZOApi = EIMZOApi;
   exports.EIMZOClient = e_imzo_client_default;
   exports.EIMZOPlugin = EIMZOPlugin;
+  exports.EIMZOSessionManager = EIMZOSessionManager;
   exports.PluginManager = PluginManager;
   exports.dates = dates;
   exports.eimzoApi = eimzo_api_default;
   exports.ftjcPlugin = ftjcPlugin;
   exports.pfxPlugin = pfxPlugin;
   exports.pkcs7Plugin = pkcs7Plugin;
+  exports.sessionManager = sessionManager;
 
   return exports;